- A+
所属分类：.NET技术
AOP
视频讲解
面向切面编程AOP的对面向对象编程OOP的一个补充，它的特点是将系统逻辑和业务逻辑采取《非侵入式》分离。我们把系统封装成一个一个的切面（单一职责）进行顺意编排组合，插入（织入）到业务逻辑的执行过程（织入点）。
系统逻辑：异常处理，身份认证，授权，mvc，数据校验，事务处理。
业务逻辑：就是我们的业务Service。
切面：用于封装系统逻辑，比如身份认证filter，或者中间件
切入点：就是管道的位置。名词
织入：就是插入到管道的切入点的过程。动词
AOP的特点：
1.非侵入式
2.低耦合
3.代码服用
4.单一职责
5.可插拔
实现方式：
1.管道链，比如aspnetcore的中间件，mvc中的Filter
2.静态代理：思考如何加强一个List，使得在插入时打印日志？
3.动态代理：Emit
4.三种模式都需要通过一些技术进行串联，实现链式调用，构成管道。静态代理通过接口进行串联，动态代理通过反射进行串联。管道通过接口获取委托进行串联。委托本质也是接口。
代理：就是增强，代理对象必须尽量实现目标对象的功能，在此基础上进行加强。比如vpn，你的电脑的网络就是目标对象，vpn就是代理服务，代理服务起码得实现联网功能吧，然后对网络进行加强，访问到一些你的本机网络访问不到的东西。
掌握了AOP技术我们可以实现很多好处，做到非侵入式的增强业务逻辑。
//侵入式方案，把这个看懂。后面就是围绕这个开展，高出非侵入式 public static void A() { Console.WriteLine("A:开始"); B();//A，B的调用关系强行绑定，有侵入性 Console.WriteLine("A:结束"); } public static void B() { Console.WriteLine("B:开始"); C(); Console.WriteLine("B:结束"); } public static void C() { Console.WriteLine("Hello World"); } public static void Dobasic() { A(); } 静态代理
1.代理就是实现目标对象的标准（接口），在目标方法执行之前和之后进行逻辑织入的过程。代理的目的就是为了加强。代理不负责实现接口，一般通过target来实现接口。即代理除了可以增强之外还能简化接口的实现。
2.静态代理就是在代理之前就已经确定了代理关系。需要自己实现标准并编写代理类。代理类中的逻辑只能代理一些标准（实现多个接口）。无法代理所有标准。
3.静态代理可以实现不改变目标对象的源码的情况下进行加强，完成目标对象的能力，并且在此基础之上进行加强。
4.可以简化实现的成本，不改变业务代码，只需要编写额外的增强逻辑。不需要关系具体的业务实现。
5.代理和代理直接通过接口可以进行互相代理，链式调用，顺意编排组合，实现系统的多样化。
/// <summary> /// 定义标准1 /// </summary> public interface IPhoneService { string Mobile { get; set; } string Message { get; set; } void Send(); } //实现标准-不是代理模式 public class PhoneService : IPhoneService { public string Mobile { get; set; } public string Message { get; set; } public PhoneService(string mobile, string message) { Mobile = mobile; Message = message; } public virtual void Send() { Console.WriteLine($"已发送短信：{Message}到{Mobile}"); } } //代理模式： //1.实现目标对象的标准 //2.依赖目标对象（被代理对象） //3.业务织入 public class PhoneServiceProxy : IPhoneService//实现标准 { private readonly IPhoneService _target; public PhoneServiceProxy1(IPhoneService target) { _target = target; } public string Mobile { get => _target.Mobile; set => _target.Mobile = value; } public string Message { get => _target.Message; set => _target.Message = value; } /// <summary> /// 子类重写父类方法 /// </summary> public void Send() { Console.WriteLine("Proxy1:已对手机号进行验证"); _target.Send(); Console.WriteLine("Proxy1:已确认对方已经收到"); } } /// <summary> /// 定义标准1 /// </summary> public interface IPhoneService { string Mobile { get; set; } string Message { get; set; } void Send(); } /// <summary> /// 定义标准2 /// </summary> public interface IEmailService { string Email { get; set; } string Message { get; set; } void Send(); } /// <summary> /// 业务逻辑1 /// </summary> public class PhoneService : IPhoneService { public string Mobile { get; set; } public string Message { get; set; } public PhoneService(string mobile, string message) { Mobile = mobile; Message = message; } public virtual void Send() { Console.WriteLine($"已发送短信：{Message}到{Mobile}"); } } /// <summary> /// 业务逻辑2 /// </summary> public class EmailService : IEmailService { public string Email { get; set; } public string Message { get; set; } public EmailService(string email, string message) { Email = email; Message = message; } public virtual void Send() { Console.WriteLine($"已发送邮件：{Message}到{Email}"); } } /// <summary> /// 切面1：校验能力（系统逻辑） /// taget方式 /// </summary> public class PhoneServiceProxy1 : IPhoneService//实现标准1 { private readonly IPhoneService _target; public PhoneServiceProxy1(IPhoneService target) { _target = target; } /// <summary> /// 子类重写父类方法 /// </summary> public void Send() { Console.WriteLine("Proxy1:已对手机号进行验证"); _target.Send(); Console.WriteLine("Proxy1:已确认对方已经收到"); } } /// <summary> /// 切面2：加速能力（系统逻辑） /// </summary> public class PhoneServiceProxy2 : IPhoneService//实现标准1 { private readonly IPhoneService _target; public PhoneServiceProxy2(IPhoneService target) { _target = target; } /// <summary> /// 子类重写父类方法 /// </summary> public void Send() { Console.WriteLine("Proxy2:已开启加速通道"); _target.Send(); Console.WriteLine("Proxy2:已关闭加速通道"); } } //test public static void TestStaticProxy() { //目标对象 IPhoneService target = new PhoneService("10088", "你好啊！"); //切面1：验证，对target进行代理 IPhoneService proxy1 = new PhoneServiceProxy1(target); //切面2：加速，对proxy1进行代理 IPhoneService proxy2 = new PhoneServiceProxy2(proxy1); //执行 proxy2.Send(); //思考如果要实现IEmailService标准，是不是要重写实现类了？ } 动态代理
Castle.Core
动态代理和静态代理的区别就是，代理类由工具生成，需要在运行时确认代理类已经代理关系。代理类中的逻辑写到拦截器里面，可以进行复用。缺点是性能差。里面涉及到大量反射技术。
Castle.Core：原理就是通过子类继承父类或者实现父类标准，通过Castle.Core自动帮你生成代理类，通过一个叫拦截器的东西编写代理类要执行的业务逻辑。Castle.Core会帮你生成代理类，并将拦截器织入到代理类中。
动态代理通过invocation进行串联，本质是反射。
/// <summary> /// 定义标准1 /// </summary> public interface IPhoneService { string Mobile { get; set; } string Message { get; set; } void Send(); } /// <summary> /// 定义标准2 /// </summary> public interface IEmailService { string Email { get; set; } string Message { get; set; } void Send(); } /// <summary> /// 业务逻辑1 /// </summary> public class PhoneService : IPhoneService { public string Mobile { get; set; } public string Message { get; set; } public PhoneService(string mobile, string message) { Mobile = mobile; Message = message; } public virtual void Send() { Console.WriteLine($"已发送短信：{Message}到{Mobile}"); } } /// <summary> /// 业务逻辑2 /// </summary> public class EmailService : IEmailService { public string Email { get; set; } public string Message { get; set; } public EmailService(string email, string message) { Email = email; Message = message; } public virtual void Send() { Console.WriteLine($"已发送邮件：{Message}到{Email}"); } } /// <summary> /// 代理1：任意标准 /// </summary> public class ShareInterceptor1 : IInterceptor { public void Intercept(IInvocation invocation) { Console.WriteLine("Proxy1:已对接收方进行验证"); invocation.Proceed();//执行下一个拦截器或者目标方法 Console.WriteLine("Proxy1:已确认对方已经收到"); } } /// <summary> /// 代理2：任意标准 /// </summary> public class ShareInterceptor2 : IInterceptor { public void Intercept(IInvocation invocation) { Console.WriteLine("Proxy2:已开启加速通道"); invocation.Proceed();//执行下一个拦截器或者目标方法 Console.WriteLine("Proxy2:已关闭加速通道"); } } //通过Castel生成代理类 public static void TestDynamicProxy1() { //创建代理生成器 var generator = new ProxyGenerator(); var target1 = new PhoneService("10088", "你好啊！"); var target2 = new EmailService("[email protected]", "你好啊！"); var interceptor1 = new ShareInterceptor1();//代理1，拦截器1，不需要去实现指定的标准 var interceptor2 = new ShareInterceptor2();//代理2，拦截器2，不需要去实现指定的标准 //使用代理1和代理2去代理手机的标准 IPhoneService dynamicProxy1 = generator.CreateInterfaceProxyWithTarget<IPhoneService>(target1, interceptor1, interceptor2); dynamicProxy1.Send(); //代理邮件的标准 IEmailService dynamicProxy2 = generator.CreateInterfaceProxyWithTarget<IEmailService>(target2, interceptor1, interceptor2); dynamicProxy2.Send(); } 手写Castle.Core的代理类
思考：
generator创建的是什么类型的实列？显然不可能是已有的类型。因为它把拦截器织入进去了。而且没有修改我们的代码，站在面向对象的角度来看只能是实现了我们的接口，Emit动态实现了下面的代码
多个拦截器和目标对象（被代理者）通过Invocation进行串联。Invocation中的Arguments完成链式调用。
手动通过Invocation进行串联
//假设有三个拦截器 //第一个拦截器invocation1：Proxy=interceptor2,Method=Intercept,argument=invocation2 //第二个拦截器invocation2：Proxy=interceptor3,Method=Intercept,argument=invocation3 //第三个拦截器invocation2：Proxy=target,Method=method,argument=arguments //手动实现 public IInvocation GetInvocation(Stack<IInterceptor> stack, object target, Method method, objuect arguments) { var invocation1 = new Invocation() { Proxy = interceptor2, Method = typeof(IInterceptor).GetMethod(nameof(IInterceptor.Intercept)), Arguments = new object[] { new Invocation() { Proxy = interceptor3, Method = typeof(IInterceptor).GetMethod(nameof(IInterceptor.Intercept)), Arguments = new object[] { new Invocation() { Proxy = target, Method = method, Arguments = arguments } } } } } } //递归实现 public IInvocation GetInvocation(Stack<IInterceptor> stack, object target, Method method, objuect arguments) { if(stack.Any()) { var proxy = stack.Pop(); return new Invocation() { Proxy = proxy, Method = typeof(IInterceptor).GetMethod(nameof(IInterceptor.Intercept)), Agrumtns = GetInvocation(stack,method,argumtns) }; } else { return new Invocation() { Proxy = target, Method = method, Agrumtns = arguments }; } } //Castel.Core自动帮我们生成了下面这个类 public class CastelPhoneServiceProxy : IPhoneService { private IPhoneService _taget; private IInterceptor[] _interceptors; public CastelPhoneServiceProxy(IPhoneService taget, IInterceptor[] interceptors) { _taget = taget; _interceptors = interceptors; } public string Mobile { get => _taget.Mobile; set => _taget.Mobile = value; } public string Message { get => _taget.Message; set => _taget.Message = value; } public void Send() { var stack = new Stack<IInterceptor>(_interceptors.Reverse()); if (stack.Any()) { var item = stack.Pop(); var invocation = GetNextInvocation(stack); item.Intercept(invocation); } else { _taget.Send(); } } /// <summary> /// 递归获取Invocaltion /// </summary> /// <param name="stack"></param> /// <returns></returns> private IInvocation GetNextInvocation(Stack<IInterceptor> stack) { if (stack.Any()) { var next = stack.Pop(); return new Invocaltion { Arguments = new object[] { //递归 GetNextInvocation(stack) }, Proxy = next, Method = typeof(IInterceptor).GetMethod(nameof(IInterceptor.Intercept)) ?? throw new NullReferenceException() }; } else { return new Invocaltion { Arguments = new object[] { }, Proxy = _taget, Method = _taget.GetType().GetMethod(nameof(IPhoneService.Send)) ?? throw new NullReferenceException() }; } } } //实现一些castle.core的接口 public class Invocaltion : IInvocation { public object[] Arguments { get; set; } public Type[] GenericArguments { get; set; } public object InvocationTarget { get; set; } public MethodInfo Method { get; set; } public MethodInfo MethodInvocationTarget { get; set; } public object Proxy { get; set; } public object ReturnValue { get; set; } public Type TargetType { get; set; } public IInvocationProceedInfo CaptureProceedInfo() { throw new NotImplementedException(); } public object GetArgumentValue(int index) { throw new NotImplementedException(); } public MethodInfo GetConcreteMethod() { throw new NotImplementedException(); } public MethodInfo GetConcreteMethodInvocationTarget() { throw new NotImplementedException(); } public void Proceed() { Method.Invoke(Proxy, Arguments); } public void SetArgumentValue(int index, object value) { throw new NotImplementedException(); } } EMIT实现
//链路器 public class EmitInvocation { private object? proxy; private MethodInfo? method; private object[]? arguments; public EmitInvocation(object? proxy, MethodInfo? method, object[]? arguments) { this.proxy = proxy; this.method = method; this.arguments = arguments; } public void Proceed() { method?.Invoke(proxy, arguments); } } //拦截器 public interface IEmitInteceptor { void Intercept(EmitInvocation invocation); } //实现拦截器1 public class EmitInteceptor1 : IEmitInteceptor { public void Intercept(EmitInvocation invocation) { Console.WriteLine("prox1:start"); invocation.Proceed(); Console.WriteLine("prox1:end"); } } //实现拦截器1 public class EmitInteceptor2 : IEmitInteceptor { public void Intercept(EmitInvocation invocation) { Console.WriteLine("prox2:start"); invocation.Proceed(); Console.WriteLine("prox2:end"); } } //该工具类帮助我们少写emit代码 public static class EmitProxyInvoker { public static EmitInvocation GetNextInvocation(Stack<IEmitInteceptor> stack, MethodInfo method, object target, object[] arguments) { if (stack.Any()) { var next = stack.Pop(); arguments = new object[] { //递归 GetNextInvocation(stack, method, target, arguments) }; return new EmitInvocation(next, typeof(IEmitInteceptor).GetMethod(nameof(IEmitInteceptor.Intercept)), arguments); } else { return new EmitInvocation(target, method, arguments); } } public static void Invoke(IEmitInteceptor[] interceptors, MethodInfo method, object target, object[] arguments) { var stack = new Stack<IEmitInteceptor>(interceptors.Reverse()); if (stack.Any()) { var item = stack.Pop(); var invocation = GetNextInvocation(stack, method, target, arguments); item.Intercept(invocation); } else { method.Invoke(target, arguments); } } } //业务接口 public interface IEmitService { void Send(); } //将来要生成的代理类 public class EmitServiceProxy : IEmitService { private object _target; private IEmitInteceptor[] _inteceptors; public EmitService() { } public void Send() { var method = _target.GetType().GetMethod(nameof(EmitService.Send)); var arguments = new object[] { }; EmitProxyInvoker.Invoke(_inteceptors, method, _target, new object[] { }); } } public static class EmitProxyGenerator { static AssemblyBuilder _assemblyBuilder; static ModuleBuilder _moduleBuilder; static EmitProxyGenerator() { //创建一个程序集 var assemblyName = new AssemblyName("DynamicProxies"); _assemblyBuilder = AssemblyBuilder .DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run); //创建一个模块 _moduleBuilder = _assemblyBuilder.DefineDynamicModule("Proxies"); } public static TInterface Create<TInterface>(object target, params IEmitInteceptor[] inteceptor) where TInterface : class { #region 定义类型 //定义一个class，如果这个类型已定义直接返回，缓存 var typeName = $"{target.GetType().Name}EmitProxy"; var typeBuilder = _moduleBuilder.DefineType( typeName, TypeAttributes.Public,typeof(object), new Type[] { typeof(TInterface) }); #endregion #region 定义字段 //定义字段 var targetFieldBuilder = typeBuilder.DefineField("target", typeof(object), FieldAttributes.Private); var inteceptorFieldBuilder = typeBuilder.DefineField("inteceptor", typeof(IEmitInteceptor[]), FieldAttributes.Private); #endregion #region 定义构造器 //定义构造器 var constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.ExplicitThis, new Type[] { typeof(object), typeof(IEmitInteceptor[]) }); //获取IL编辑器 var generator = constructorBuilder.GetILGenerator(); generator.Emit(OpCodes.Ldarg_0);//加载this generator.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes) ?? throw new InvalidOperationException()); generator.Emit(OpCodes.Nop); generator.Emit(OpCodes.Nop); // this.age = age; generator.Emit(OpCodes.Ldarg_0);//加载this generator.Emit(OpCodes.Ldarg_1);//加载target参数 generator.Emit(OpCodes.Stfld, targetFieldBuilder);//加载target字段 // this.name = name; generator.Emit(OpCodes.Ldarg_0);//加载this generator.Emit(OpCodes.Ldarg_2);//加载inteceptor参数 generator.Emit(OpCodes.Stfld, inteceptorFieldBuilder);//加载inteceptor字段 generator.Emit(OpCodes.Ret); #endregion #region 实现接口 var methods = typeof(TInterface).GetMethods(); foreach (var item in methods) { var parameterTypes = item.GetParameters().Select(s => s.ParameterType).ToArray(); var methodBuilder = typeBuilder.DefineMethod(item.Name, MethodAttributes.Public| MethodAttributes.Final |MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.HideBySig, CallingConventions.Standard|CallingConventions.HasThis, item.ReturnType, parameterTypes); var generator1 = methodBuilder.GetILGenerator(); //init var methodInfoLocal = generator1.DeclareLocal(typeof(MethodInfo)); var argumentLocal = generator1.DeclareLocal(typeof(object[])); generator1.Emit(OpCodes.Nop); generator1.Emit(OpCodes.Ldarg_0); generator1.Emit(OpCodes.Ldfld, targetFieldBuilder); generator1.Emit(OpCodes.Callvirt, typeof(Type).GetMethod(nameof(Type.GetType),Type.EmptyTypes)); generator1.Emit(OpCodes.Ldstr, item.Name); generator1.Emit(OpCodes.Callvirt, typeof(Type).GetMethod(nameof(Type.GetMethod), new Type[] { typeof(string) })); generator1.Emit(OpCodes.Stloc, methodInfoLocal); generator1.Emit(OpCodes.Ldc_I4_0); generator1.Emit(OpCodes.Newarr, typeof(object)); generator1.Emit(OpCodes.Stloc, argumentLocal); generator1.Emit(OpCodes.Ldarg_0); generator1.Emit(OpCodes.Ldfld, inteceptorFieldBuilder); generator1.Emit(OpCodes.Ldloc_0); generator1.Emit(OpCodes.Ldarg_0); generator1.Emit(OpCodes.Ldfld, targetFieldBuilder); generator1.Emit(OpCodes.Ldc_I4_0); generator1.Emit(OpCodes.Newarr, typeof(object)); generator1.Emit(OpCodes.Call, typeof(EmitProxyInvoker).GetMethod(nameof(EmitProxyUtil.Invoke))); generator1.Emit(OpCodes.Nop); generator1.Emit(OpCodes.Ret); } #endregion //创建:这个type可以用一个线程安全的字典缓存起来，第二次需要这个代理类的时候，就不需要在生成一次emit代码了。 var type = typeBuilder.CreateType() ?? throw new ArgumentException(); var instance = Activator.CreateInstance(type, target, inteceptor); return (TInterface)instance; } } 容器支持
public class DbContext { } public class AService { public DbContext DbContext { get; } public AService(DbContext context) { DbContext = context; } } public static void Test() { var services = new ServiceCollection(); services.AddScoped<DbContext>(); var generator = new ProxyGenerator(); //泛型-不支持动态注入 services.AddScoped(sp => { //通过容器解析依赖 var target = ActivatorUtilities.CreateInstance<AService>(sp); return generator.CreateClassProxyWithTarget(target); }); //反射-可以扫描批量注入 services.AddScoped(typeof(AService), sp => { //通过容器解析依赖 var target = ActivatorUtilities.CreateInstance(sp, typeof(AService)); return generator.CreateClassProxyWithTarget(target); }); } 管道方式
委托方式
1.通过委托构建管道
public delegate Task RequestDelegate(HttpContext context); public class HttpContext { } public class ApplicationBuilder { private readonly List<Func<RequestDelegate, RequestDelegate>> _componen public void Use(Func<RequestDelegate, RequestDelegate> middleware) { _components.Add(middleware); } public void Use(Func<HttpContext, Func<Task>, Task> middleware) { _components.Add((next) => { return async c => { await middleware(c, () => next(c)); }; }); } public void Use(Func<HttpContext, RequestDelegate, Task> middleware) { _components.Add((next) => { return async c => { await middleware(c, next); }; }); } public void Run(RequestDelegate handler) { _components.Add((next) => { return async c => { await handler(c); }; }); } //构建管道 public RequestDelegate Build() { RequestDelegate app = c => { throw new InvalidOperationException("无效的管道"); }; for (int i = _components.Count - 1; i > -1; i--) { app = _components[i](app); } return app; } } 接口方式
2.通过接口构建管道
有点类型动态代理，动态代理是通过Invocation进行反射，而下面的方式是通过接口的方式。反射更加灵活，性能不行。
public interface IChain { Task NextAsync(); } public class FilterChain : IChain { private readonly IFilter _filter; private readonly HttpContext _context; private readonly IChain _next; public FilterChain(IFilter filter, HttpContext context, IChain next) { _filter = filter; _context = context; _next = next; } public async Task NextAsync() { await _filter.InvokeAsync(_context, _next); } } public class ServletChain : IChain { private readonly IServlet _servlet; private readonly HttpContext _context; public ServletChain(IServlet servlet, HttpContext context) { _servlet = servlet; _context = context; } public async Task NextAsync() { await _servlet.DoPostAsync(_context); } } public interface IFilter { Task InvokeAsync(HttpContext context, IChain chain); } public class Filter1 : IFilter { public async Task InvokeAsync(HttpContext context, IChain chain) { Console.WriteLine("身份认证开始"); await chain.NextAsync(); Console.WriteLine("身份认证结束"); } } public class Filter2 : IFilter { public async Task InvokeAsync(HttpContext context, IChain chain) { Console.WriteLine("授权认证开始"); await chain.NextAsync(); Console.WriteLine("授权认证结束"); } } public interface IServlet { Task DoPostAsync(HttpContext context); } public class HelloServlet : IServlet { public Task DoPostAsync(HttpContext context) { Console.WriteLine("Hello World"); return Task.CompletedTask; } } public class WebHost { private readonly List<IFilter> _filters = new List<IFilter>(); public void AddFilter(IFilter filter) { _filters.Add(filter); } public void Exeucte(HttpContext context, IServlet servlet) { //自行处理filter为空的情况,就是直接执行serlvet就好了 var stack = new Stack<IFilter>(_filters); var filter = stack.Pop(); var chain = GetFilterChain(context, servlet,stack); filter.InvokeAsync(context, chain); } private IChain GetFilterChain(HttpContext context, IServlet servlet, Stack<IFilter> filters) { if (filters.Any()) { var filter = filters.Pop(); var chain = GetFilterChain(context, servlet, filters); return new FilterChain(filter, context, chain); } else { return new ServletChain(servlet, context); } } } AOP总结
1.代理分为静态代理和动态代理，静态代理需要自己编写代理类，动态代理由框架生成代理类。
2.代理和管道都需要通过接口（委托）进行链接，串联，形成链式调用。
3.动态代理慎用，因为涉及到反射技术，而且对异步支持不友好。
4.静态代理常用于加强已有类型，比如接口要求一个IList，我们已经拥有了一个list实列，我们需要在在list.Add方法时打印日志，此时我们可以不改变原有的list，通过静态代理实现IList接口来进行对原有的list加强。这个方法在更改框架的时候很有用。我们可以对原有的HttpContext，进行加强。
