运用Unity结合PolicyInjection实现拦截器[结合操作日志实例]

上一篇文章我们通过Unity自身Unity.InterceptionExtension.IInterceptionBehavior实现一个有系统关异常日志记录；解决代码中到处充满的异常记录的代码；

本文则是通过Unity.InterceptionExtension.ICallHandler实现一个操作日志记录功能；在相应操作方法上通过特性Attribute把操作日志进行统一处理；若想了解Unity依赖注入及AOP功能可以查看先前其它文章；



1：首先我们在公共助手层Command层新建OperateLogCallHandler类及OperateLogAttribute类

其中类OperateLogCallHandler继承自ICallHandler,并且我们定义的属性(MessageInfo,ShowThrow)，此处我们只是简单的显示出操作内容信息，若实际项目可以对下面进行简单修改便可，比如写入日志、数据库等;代码result.Exception == null则表示执行代码没有出现异常才逻辑写入

using Microsoft.Practices.Unity.InterceptionExtension;

namespace Command
{
public class OperateLogCallHandler:ICallHandler
{
public string _messageInfo { set; get; }

public bool _showThrow { get; set; }

private int _order = 0;

public OperateLogCallHandler(string MessageInfo, bool ShowThrow)
{
this._messageInfo = MessageInfo;
this._showThrow = ShowThrow;
}

public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
{
if (input == null) throw new ArgumentNullException("input");
if (getNext == null) throw new ArgumentNullException("getNext");

var result = getNext()(input, getNext);
if (result.Exception == null)
{
//进行逻辑代码编写  比如把操作内容写入数据库
Console.WriteLine("操作的内容为:" + _messageInfo);
}
if (_showThrow) result.Exception = null;
return result;
}

public int Order
{
get
{
return _order;
}
set
{
_order = value;
}
}
}
}

而类OperateLogAttribute则继承自HandlerAttribute,并且我们设定此特性只能作用于方法上;

using Microsoft.Practices.Unity.InterceptionExtension;
namespace Command
{
[AttributeUsage(AttributeTargets.Method)]
public class OperateLogAttribute : HandlerAttribute
{
public string messageInfo { get; set; }

public bool showThrow { get; set; }

public OperateLogAttribute()
{

}

public OperateLogAttribute(string MessagInfo, bool ShowThrow)
{
this.messageInfo = MessagInfo;
this.showThrow = ShowThrow;
}

public override ICallHandler CreateHandler(Microsoft.Practices.Unity.IUnityContainer container)
{
OperateLogCallHandler handler = new OperateLogCallHandler(this.messageInfo, this.showThrow);
handler.Order = this.Order;
return handler;
}
}
}

2:公共层里还有一个助手类UnityContainerHelp,用于读取加载配置

using Microsoft.Practices.Unity;
using Microsoft.Practices.Unity.Configuration;
using Microsoft.Practices.Unity.InterceptionExtension;
using Microsoft.Practices.Unity.InterceptionExtension.Configuration;
using System.Configuration;
using System.Reflection;

namespace Command
{
public class UnityContainerHelp
{
private IUnityContainer container;
public UnityContainerHelp()
{
container = new UnityContainer();
UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
container.LoadConfiguration(section, "FirstClass");
}

public T GetServer<T>()
{
return container.Resolve<T>();
}

/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="ConfigName">配置文件中指定的文字</param>
/// <returns></returns>
public T GetServer<T>(string ConfigName)
{
return container.Resolve<T>(ConfigName);
}

/// <summary>
/// 返回构结函数带参数
/// </summary>
/// <typeparam name="T">依赖对象</typeparam>
/// <param name="parameterList">参数集合（参数名，参数值）</param>
/// <returns></returns>
public T GetServer<T>(Dictionary<string, object> parameterList)
{
var list = new ParameterOverrides();
foreach (KeyValuePair<string, object> item in parameterList)
{
list.Add(item.Key, item.Value);
}
return container.Resolve<T>(list);
}
/// <summary>
/// 返回构结函数带参数
/// </summary>
/// <typeparam name="T">依赖对象</typeparam>
/// <param name="ConfigName">配置文件中指定的文字(没写会报异常)</param>
/// <param name="parameterList">参数集合（参数名，参数值）</param>
/// <returns></returns>
public T GetServer<T>(string ConfigName,Dictionary<string,object> parameterList)
{
var list = new ParameterOverrides();
foreach (KeyValuePair<string, object> item in parameterList)
{
list.Add(item.Key, item.Value);
}
return container.Resolve<T>(ConfigName,list);
}
}
}

3:接着在接口层相应的方法上使用我们刚才创建的特性，注意必需引用Microsoft.Practices.Unity.InterceptionExtension.dll;若则特性将会找不到

using Microsoft.Practices.Unity.InterceptionExtension;
using Command;
namespace IAopBLL
{
public interface IUser
{
[OperateLog(Order = 10, messageInfo = "增加用户", showThrow = true)]
void CreateUser();

[OperateLog(Order = 10, messageInfo = "编辑用户", showThrow = true)]
void UpdateUser();
}
}

4：在BLL层里实现上面的接口，在方法里面我们就不进行任何操作

using IAopDAL;
using IAopBLL;
using Command;
namespace AopBLL
{
public class UserBLL:IUser
{
public void CreateUser()
{
//逻辑代码,此处为了简单就省略不写
}

public void UpdateUser()
{
//逻辑代码,此处为了简单就省略不写
}
}
}

5：下面为主程序调用代码，这里我们简单运用到Unity依赖注入代码

using IAopBLL;
using Command;
namespace AopUnity
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("-----------------------------------");
IUser bllProperty = new UnityContainerHelp().GetServer<IUser>("UserBllAop");
bllProperty.CreateUser();
bllProperty.UpdateUser();
Console.WriteLine("-----------------------------------");
}
}
}

配置文件的内容如下：其中有两个比较要注意的地方(a处 name="UserBllAop" 主程序里有调用 b处 <policyInjection/>拦载器才会起作用）

<?xml version="1.0"?>
<configuration>
<configSections>
<section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Microsoft.Practices.Unity.Configuration"/>
</configSections>
<unity xmlns="http://schemas.microsoft.com/practces/2010/unity">
<sectionExtension type="Microsoft.Practices.Unity.InterceptionExtension.Configuration.InterceptionConfigurationExtension, Microsoft.Practices.Unity.Interception.Configuration"/>
<container name="FirstClass">
<extension type="Interception"/>
<register type="IAopBLL.IUser,IAopBLL" mapTo="AopBLL.UserBLL,AopBLL" name="UserBllAop">
<interceptor type="InterfaceInterceptor" />
<policyInjection/>
</register>
</container>
</unity>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
</startup>
</configuration>

6：运行效果:



从图中我们不难发现Aop已起到作用，在操作没有异常的情况下我们成功获得操作内容；当然其它Aop比如权限判断，事务处理等都可以用此种办法；