AOP

时间 2019-11-13

标签 aop 繁體版

原文原文链接

原文: AOP

AOP

文章目录

1.什么是AOP以及AOP能解决的问题

在程序设计的过程当中，咱们利用OOP(面向对象的思想)，在设计规模更大、逻辑更复杂的系统时，开发周期能变的更短。然而，面向对象设计的惟一问题是，它本质是静态的，封闭的，任何需求的细微变化均可能对开发进度形成重大影响。
设计模式能够解决该问题。GOF将面向对象软件的设计经验做为设计模式纪录下来，它令人们能够更加简单方便地复用成功的设计和体系结构，帮助开发人员作出有利于系统复用的选择。在设计的过程当中，经过各类模式体现了对象的行为，暴露的接口，对象间关系，以及对象分别在不一样层次中表现出来的形态。然而鉴于对象封装的特殊性，“设计模式”的触角始终在接口与抽象中大作文章，而对于对象内部则无能为力。
因此，AOP的设计思想就是针对这种问题出现的，在不破坏原有类型的前提下，给当前类增长新的功能。css

2.AOP的几种实现方式

定义一个IUserProcessor的接口:前端

public interface IUserProcessor
    {
        void RegUser(User user);
        
}

定义一个UserProcessor的实现类：web

public class UserProcessor : IUserProcessor
    {
       

        public void RegUser(User user)
        {
//原始逻辑
            Console.WriteLine("用户已注册。Name:{0},PassWord:{1}", user.Name, user.Password);
        }
    }

2.12.1 装饰器模式实现静态AOP

定义一个UserProcessorDecorator类，实现IUserProcessor接口:设计模式

public  class UserProcessorDecorator:IUserProcessor
    {
        public 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 AfterProceed(User user)
        {
            Console.WriteLine("方法执行后");
        }

        private void BeforeProceed(User user)
        {
            Console.WriteLine("方法执行前");
        }
}

前端使用：markdown

User user = new User()
            {
                Name = "DZB",
                Password = "123123123123"
            };
            //普通方式注册
            Console.WriteLine("*******普通方式注册********");
            IUserProcessor processor = new UserProcessor();
            processor.RegUser(user);
            Console.WriteLine("*******静态AOP方式注册********");
            //静态AOP方式注册
            processor = new UserProcessorDecorator(processor);
        processor.RegUser(user);

虽然解决了易用性，可是咱们很快就发现了另外一些不尽人意的地方，装饰器模式只能适用于特定的类型，约束是比较强的。若是咱们但愿咱们示例中的装饰器能够实现通用，就须要找别的方法了。ide

2.2 Net Remoting.Proxies的RealProxy 动态代理实现AOP

透明代理：svg

//透明代理
        public static class TransparentProxy
        {
            public static T Create<T>()
            {
                T instance = Activator.CreateInstance<T>();
                MyRealProxy<T> realProxy = new MyRealProxy<T>(instance);
                T transparentProxy = (T)realProxy.GetTransparentProxy();
                return transparentProxy;
            }
        }

真实代理:继承自RealProxy：this

//真实代理:继承自RealProxy
        public class MyRealProxy<T> : RealProxy
        {
            private T tTarget;
            public MyRealProxy(T target)
                : base(typeof(T))
            {
                this.tTarget = target;
            }

            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);
            }
            public void BeforeProceede(IMessage msg)
            {
                Console.WriteLine("方法执行前能够加入的逻辑");
            }
            public void AfterProceede(IMessage msg)
            {
                Console.WriteLine("方法执行后能够加入的逻辑");
            }
        }

局限性：实现类UserProcessor必须继承MarshalByRefObjectatom

public class UserProcessor : MarshalByRefObject, IUserProcessor
        {
            public void RegUser(User user)
            {
                Console.WriteLine("用户已注册。用户名称{0} Password{1}", user.Name, user.Password);
            }
        }

前端使用：spa

User user = new User()
            {
                Name = "DZB",
                Password = "123456"
            };
            Console.WriteLine("*********普通注册************");
            UserProcessor processor = new UserProcessor();
            processor.RegUser(user);

            Console.WriteLine("********使用.Net Remoting.RealProxy动态代理实现*************");
            UserProcessor userProcessor = TransparentProxy.Create<UserProcessor>();
            userProcessor.RegUser(user);

2.3 Castle.DynamicProxy动态代理实现AOP

首先添加第三方Castle Nuget包：

实现IInterceptor接口：

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("方法执行后");
            }
        }

局限性：实现类中的方法必须带上Virtual关键字：

public class UserProcessor : IUserProcessor
        {
            /// <summary>
            /// 必须带上virtual
            /// </summary>
            /// <param name="user"></param>
            public virtual void RegUser(User user)
            {
                Console.WriteLine($"用户已注册。Name:{user.Name},PassWord:{user.Password}");
            }
        }

前端使用：

User user = new User()
            {
                Name = "DZB",
                Password = "123456"
            };
            Console.WriteLine("*********普通方法注册************");
            UserProcessor processor = new UserProcessor();
            processor.RegUser(user);

            Console.WriteLine("*******使用Castle.DynamicProxy动态代理实现**************");
            //添加Castle.Core的NUget包
            ProxyGenerator generator = new ProxyGenerator();
            MyInterceptor interceptor = new MyInterceptor();
            UserProcessor userprocessor = generator.CreateClassProxy<UserProcessor>(interceptor);
            userprocessor.RegUser(user);

2.4 Unity容器实现AOP

添加Unity包：

添加一个UserHandler的特性，继承自HandlerAttribute（来自Unity容器）

public class UserHandlerAttribute : HandlerAttribute
        {
            public override ICallHandler CreateHandler(IUnityContainer container)
            {
                ICallHandler handler = new UserHandler() { Order = this.Order };
                return handler;
            }
        }

特性对应的行为：实现ICallHandler接口

public class UserHandler : ICallHandler
        {
            public int Order { get; set; }
            public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
            {
                User user = input.Inputs[0] as User;
                if (user.Password.Length < 10)
                {
                    return input.CreateExceptionMethodReturn(new Exception("密码长度不能小于10位"));
                }
                Console.WriteLine("参数检测无误");


                IMethodReturn methodReturn = getNext()(input, getNext); //getNext.Invoke().Invoke(input, getNext);

                //Console.WriteLine("已完成操做");

                return methodReturn;
            }
        }

给须要添加额外行为的类添加特性：

[UserHandlerAttribute(Order = 1)]
        public interface IUserProcessor
        {
            void RegUser(User user);
        }

前端使用：

User user = new User()
            {
                Name = "DZB",
                Password = "12345678957576"
            };
            {
                Console.WriteLine("**********普通注册***********");
                UserProcessor processor = new UserProcessor();
                processor.RegUser(user);

                Console.WriteLine("*********************");
            }
            {
                //添加Unity容器
                Console.WriteLine("**********Unity注册***********");
                IUnityContainer container = new UnityContainer();//声明一个容器
                container.RegisterType<IUserProcessor, UserProcessor>();//声明UnityContainer并注册IUserProcessor
                IUserProcessor processor = container.Resolve<IUserProcessor>();
                processor.RegUser(user);//调用

                container.AddNewExtension<Interception>().Configure<Interception>()
                    .SetInterceptorFor<IUserProcessor>(new InterfaceInterceptor());


                //IUserProcessor userprocessor = new UserProcessor();
                IUserProcessor userprocessor = container.Resolve<IUserProcessor>();

                Console.WriteLine("********************");
                userprocessor.RegUser(user);//调用
}