标签：组成 repr 自定义 动作 编程 变化 单元 summary 需要
一. 什么是AOP:
a) AOP是面向切面编程; 就像oop一样, 它也是一种编程思想;
i. Oop思想→一切皆对象, 对象交互组成功能, 功能叠加组成模块, 模块叠加组成系统; 如果把一个个的类比喻成一个个砖头, 那么系统就是一个房子; 房子是由一块块砖头构成, 所以面向对象非常适合做大型系统; 但是面向对象的在应对系统扩展的时候, 就显得力不从心; 如果砖块需要发生变化, 则就会牵扯到很多地方; 因为面向对象是静态的, 内部就是强耦合的关系; 虽然设计模式可以解决这些问题中的某些部分, 比如可以创建出可扩展, 可重用的架构, 但是设计模式操作的最小单元也是类(砖头), 无法解决类的内部的变化
ii. AOP→面向切面编程, 是对OOP的补充; 主要功能就是为了解决类的内部变化, 在不破坏类封装的同时, 水平扩展类的功能; 降低模块间的耦合度; 注意AOP不是实现业务行为的: 比如一个People类, 本身具有跑步, 吃饭, 睡觉这三个方法, 但是如果你想通过AOP为其增加一个 游泳 的方法, 那么AOP就不适用了; 因为这种属于业务层面, 在封装类的时候, 就应该存在的行为; AOP主要是用来做一些通用的功能, 比如 权限校验/日志记录/发送消息/缓存处理/性能监控 等等一些通用的非业务逻辑的功能;
iii. 总结:
- 所以说AOP 只是对OOP思想的一种补充, 解决类的内部通用功能的变化
- 所有的业务功能还是由OOP来实现, 比如People类需要增加 游泳 方法, 还是得有OOP来完成
- 有了AOP之后, OOP的实现也变得简单了, 因为OOP的代码, 只用关注业务逻辑; 无需再操心各种通用的功能了
二. 利用装饰器模式实现简答的AOP, 没有通用性:
a) 实现代码:
///
/// 1. 这个接口定义一个注册用户的行为
///
public interface IUserProcessor
{
void RegUser(User user);
}
///
/// 2. 普通的实现
///
public class UserProcessor : IUserProcessor
{
public void RegUser(User user)
{
Console.WriteLine("用户已注册。Name:{0},PassWord:{1}", user.Name, user.Password);
}
}
///
/// 3. 利用装饰器模式的实现, 这个就类似于简单的AOP功能,
/// 装饰器即实现了IuserProcessor的接口
/// 但在实现的同时, 还组合进一个IuserProcessor对象;
/// 这就是一个标准的装饰器模式
///
public class UserProcessorDecorator : IUserProcessor
{
//组合一个IUserProcessor对象
private IUserProcessor _UserProcessor { get; set; }
public UserProcessorDecorator(IUserProcessor userprocessor)
{
this._UserProcessor = userprocessor;
}
//实现接口
public void RegUser(User user)
{
BeforeProceed(user);
this._UserProcessor.RegUser(user);
AfterProceed(user);
}
///
/// 定义在业务逻辑执行之前要执行的动作
///
///
private void BeforeProceed(User user)
{
Console.WriteLine("方法执行前");
}
///
/// 定义在业务逻辑执行之后要执行的动作
///
///
private void AfterProceed(User user)
{
Console.WriteLine("方法执行后");
}
}
b) 调用
public static void Show()
{
User user = new User()
{
Name = "孙悟空",
Password = "123456"
};
//5. 装饰器模式使用的方法
IUserProcessor processor = new UserProcessor();
processor.RegUser(user); //普通实现
Console.WriteLine("***************");
user = new User()
{
Name = "八戒AOP",
Password = "567890"
};
processor = new UserProcessorDecorator(processor);
processor.RegUser(user);//使用装饰器模式实现的AOP, 看起来只为此类的此方法单独实现的, 有很大局限性
}
c) 执行结果截图:
三. 使用.net Remoting实现动态代理(AOP), 不太推荐, .net Remoting对父类的限制实在是太大了
a) 创建一个接口, 这里和装饰器模式没有什么区别
///
/// 1. 使用.net Remoting 来实现动态代理, 这里的业务还是和装饰器与代理模式的业务一样
///
public interface IUserProcessor
{
void RegUser(User user);
}
b) 实现接口, 并继承MarshalByRefObject
///
/// 必须继承自MarshalByRefObject父类，否则无法生成;
/// 这个继承就感觉比较恶心了;因为C#中都是单继承的
///
/// 2. 定义一个UserProcessor来实现IUserProcessor, 必须继承一个MarshalByRefObject; 继承此类是.net Remoting的固定写法类; 如果想实现动态代理就必须继承这个类(MarshalByRefObject)
///
public class UserProcessor : MarshalByRefObject, IUserProcessor
{
public void RegUser(User user)
{
Console.WriteLine("用户已注册。用户名称{0} Password{1}", user.Name, user.Password);
}
}
c) 使用Remoting进行对象生成的动态代理的固定写法
///
/// MyRealProxy 就是真实代理, 这个类里面的东西, 属于固定写法, 是.net Remoting封装好的
///
///
public class MyRealProxy : RealProxy
{
private T tTarget;
public MyRealProxy(T target): base(typeof(T))
{
this.tTarget = target;
}
///
/// .net Remoting的核心方法
///
///
///
public override IMessage Invoke(IMessage msg)
{
BeforeProceede(msg); //在执行方法之前做一些其它自定义的动作
//这里执行真实的方法体, 在这个方法体之前(之后)都可以加一点自己的动作
IMethodCallMessage callMessage = (IMethodCallMessage)msg;
object returnValue = callMessage.MethodBase.Invoke(this.tTarget, callMessage.Args);
AfterProceede(msg);//在执行方法之后执行一些其它动作
return new ReturnMessage(returnValue, new object[0], 0, null, callMessage);
}
#region 可以扩展的逻辑
public void BeforeProceede(IMessage msg)
{
Console.WriteLine("方法执行前可以加入的逻辑");
}
public void AfterProceede(IMessage msg)
{
Console.WriteLine("方法执行后可以加入的逻辑");
}
#endregion
}
///
/// 透明代理; 固定的写法, 表示如何使用.net Remoting来生成对象
///
public static class TransparentProxy
{
public static T Create()
{
//使用反射动态创建对象
T instance = Activator.CreateInstance();
//将对象包装一层, 交给MyRealProxy
MyRealProxy realProxy = new MyRealProxy(instance);
//GetTransparentProxy→父类的方法
T transparentProxy = (T)realProxy.GetTransparentProxy();
return transparentProxy;
}
}
d) 调用方法:
public static void Show()
{
User user = new User()
{
Name = "孙悟空",
Password = "123456"
};
UserProcessor processor = new UserProcessor();
processor.RegUser(user);
Console.WriteLine("*********************");
user = new User()
{
Name = "八戒AOP",
Password = "567890"
};
//利用TransparentProxy来创建对象
UserProcessor userProcessor = TransparentProxy.Create();
//调用RegUser时, 会进入到Invoke方法中, 至于为什么会进入到Invoke中, 是由.net Remoting的底层来实现的
userProcessor.RegUser(user);
}
e) 执行结果:
四. 使用Castle实现动态代理
对于Castle来说, 实现接口时, 方法必须是一个虚方法; 主要代码如下:
///
/// 使用Castle\DynamicProxy 实现动态代理
/// 方法必须是虚方法
///
public class CastleProxyAOP
{
///
/// 1. 业务和动态代理/装饰器模式/.net Remoting(RealProxy)都是一样, 定义接口对象
///
public interface IUserProcessor
{
void RegUser(User user);
}
///
/// 2. 业务子类实现IUserProcessor接口
///
public class UserProcessor : IUserProcessor
{
///
/// 必须带上virtual 否则无效
///
///
public virtual void RegUser(User user)
{
Console.WriteLine($"用户已注册。Name:{user.Name},PassWord:{user.Password}");
}
}
///
/// 3. 这里是个重点, Intercept()方法是个重点
///
public class MyInterceptor : IInterceptor
{
public void Intercept(IInvocation invocation)
{
//在方法调用之前执行的动作
PreProceed(invocation);
invocation.Proceed(); //这里是真实的方法调用
//在方法调用之后执行的动作
PostProceed(invocation);
}
public void PreProceed(IInvocation invocation)
{
Console.WriteLine("方法执行前");
}
public void PostProceed(IInvocation invocation)
{
Console.WriteLine("方法执行后");
}
}
public static void Show()
{
User user = new User()
{
Name = "孙悟空",
Password = "456789"
};
//4. 调用
ProxyGenerator generator = new ProxyGenerator();
MyInterceptor interceptor = new MyInterceptor();
//5. 创建对象; (这个也是动态实现的AOP); 固定写法
// 基于里式替换原则,右边是父类, 那么在调用的时候, 根本就不会去管左边是个什么, 直接会调用父类的RegUser方法, 如果要调用子类的RegUser方法, 则必须标注virtual
UserProcessor userprocessor = generator.CreateClassProxy(interceptor);
userprocessor.RegUser(user);
}
}
20181122_C#中AOP初探_装饰器模式的AOP_Remoting实现AOP_Castle实现AOP
标签：组成 repr 自定义 动作 编程 变化 单元 summary 需要
原文地址：https://www.cnblogs.com/wxylog/p/10000228.html