AOP原理及其实现
AOP 是 Aspect-Oriented programming 的缩写，中文翻译为面向切面编程，它是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。它和OOP一样是一种编程思想。
AOP基本概念
横切（cross-cutting）：与对象核心功能无关的公共行为
关注点（concern）：一块我们感兴趣的区域
方面（Aspect）：就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。
连接点（join point）：是程序执行中一个精确执行点，例如类中的一个方法。它是一个抽象的概念，在实现AOP时，并不需要去定义一个连接点。
切入点（point cut）：本质是一个捕获连接点的结构。在AOP中，可以定义一个切入点来捕获相关方法的调用。
通知（advice）：是“切入点”的执行方代码，是执行“方面”的具体逻辑
引入（introduce）：为对象引入附加的方法或属性，从而达到修改对象结构的目的
AOP本质
OOP通过封装、继承及多态等概念来建立一种对象层次结构，用来模式现实事物。因为OOP中每个对象都是独立的，因此当我们需要引入公共行为时（日志、安全、异常），代码显得比较臃肿。而AOP很好的解决了这一问题。它剖开对象内部把”横切”的代码封装成一个“方面”。引用大牛的形象比喻来说“如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。”
AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程部分是核心关注点，与之关系不大的部分是横切关注点。AOP的作用在于分离系统中各种关注点，将核心关注点和横切关注点分离开来。
AOP实现方式
实现AOP的方式有两种：一是动态代理技术，二是采用静态织入方式
动态代理：利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行。一般通过Emit来动态的创建代理类；
静态织入：通过引入特定的语法来创建“方面”，从而在编译期间就织入了“方面”的代码。目前这种实现方式，都是对编译器扩展。这种实现方式性能是最好的
采用动态代理实现AOP
在说动态代理之前，我们要看一下之前是怎么实现“横切”的。
首先，我们有这样一个类，负责处理用户的业务逻辑。
public interface IUserService
{
bool AddUser(User user);
IList<User> GetUsers();
}
public class UserService : IUserService
{
public bool AddUser(User user)
{
Console.WriteLine("添加人员：{0}", user.Name);
return true;
}
public IList<User> GetUsers()
{
return new List<User>
{
new User{Name = "张三",BirthDate = DateTime.Now.AddYears(-1)},
new User{Name = "李四",BirthDate = DateTime.Now.AddYears(-2)},
new User{Name = "王五",BirthDate = DateTime.Now.AddYears(-3)},
};
}
}
现在我们要给所有的核心业务添加日志记录的功能，我们以下几种选择：
1、直接在方法内部添加日志记录的代码
public class UserService : IUserService
{
public bool AddUser(User user)
{
Console.WriteLine("添加人员：{0}", user.Name);
Console.WriteLine("Log:AddUser");
return true;
}
public IList<User> GetUsers()
{
Console.WriteLine("Log:GetUsers");
return new List<User>
{
new User{Name = "张三",BirthDate = DateTime.Now.AddYears(-1)},
new User{Name = "李四",BirthDate = DateTime.Now.AddYears(-2)},
new User{Name = "王五",BirthDate = DateTime.Now.AddYears(-3)},
};
}
}
2、添加一个继承UserServeice的子类，并重写/覆盖父类的方法
public class MyUserService : UserService
{
public new bool AddUser(User user)
{
base.AddUser(user);
Console.WriteLine("Log:AddUser");
return true;
}
public new IList<User> GetUsers()
{
Console.WriteLine("Log:GetUsers");
return base.GetUsers();
}
}
3、写一个静态的代理类
首先声明一个拦截器接口
public interface IInterceptor
{
object Invoke(object obj, string methodName, object[] paramters);
}
然后创建一个日志拦截器
public class LogInterceptor : IInterceptor
{
public object Invoke(object obj, string methodName, object[] paramters)
{
Console.WriteLine("Log:{0}", methodName);
object result = obj.GetType().GetMethod(methodName).Invoke(obj, paramters);
return result;
}
}
最后创建静态代理类
public class MyUserServiceProxy
{
private readonly IInterceptor _interceptor;
private readonly User _user;
public MyUserServiceProxy(User user, IInterceptor interceptor)
{
_user = user;
_interceptor = interceptor;
}
public bool AddUser(User user)
{
return (bool)_interceptor.Invoke(_user, "AddUser", new object[] { user });
}
public IList<User> GetUsers()
{
return (IList<User>)_interceptor.Invoke(_user, "GetUsers", null);
}
}
下面调用
var proxy = new AOPTest.MyUserServiceProxy(new AOPTest.User
{
Name = "Khadron",
BirthDate = DateTime.Now
},
new AOPTest.LogInterceptor());
IList<AOPTest.User> users = proxy.GetUsers();
if (users.Count > 0)
{
proxy.AddUser(users[0]);
}
Console.ReadKey();
相对于前面的两种方法，第三种方法算是比较好的了，不过还是不够好，缺点是不仅必须给每个业务类都重写一个包含日志处理的代理类，而且如果还有其他类似日志处理的模块（权限），那还需要在写一个其他代理类，这样做起来不仅工作量大，而且维护起来也十分麻烦。 采用动态代理的方式很好的解决了这个问题，上面说过主要采用Emit来实现，代码太多就不贴了，请查看我的github，这里面实现了一个简单的AOP框架
.NET平台下AOP框架
动态代理：Castle Dynamic Proxy 、Unity 、LOOM.NET等
静态织入：Postsharp（收费） 、Eos等
个人推荐使用 Castle框架，至此结束
