面向切面编程AOP

最新推荐文章于 2024-01-26 12:52:34 发布
最新推荐文章于 2024-01-26 12:52:34 发布
阅读量241 收藏
点赞数
分类专栏： .Net 进阶
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoming1563/article/details/82818828
版权

一、传统的面向对象编程OOP

万物皆对象，专注于类与类之间的交互，由类组成各种功能，功能组咸亨组件，组件又组成系统，适合做大型项目。
但是，由于类是静态的，封闭的，任何需求的变化都会对其带来影响，而在项目的开发过程中，良好的设计是尽量避免对已有类型的更改，因此再前辈的经验中，总结了GOF23种设计模式， 虽然设计模式原则可以解决类与类之间的交互稳定，但如果类的自身变化，需要增加功能需求，则设计模式也解决不了，因此也就出现了面向切面编程的思想了。

二、面向切面编程AOP

面向切面编程，实际上是对OOP的一种补充
允许通过外部方式来修改对象，可以在不破坏类型封装的前提下，去提供新的功能;
AOP只是增加通用逻辑，而不实现核心业务，核心业务还是放在业务类上实现，比如事务、日志、异常、权限、校验、缓存等等。

三、AOP的实现方式：

1. 静态AOP

  • 使用装饰器模式
public interface IUserService
{
    void Register(User user);
}
public class UserService : IUserService
{
    public void Register(User user)
    {
        Console.WriteLine("用户已注册。Name:{0},PassWord:{1}", user.Name, user.Password);
    }
}

/// <summary>
/// 使用装饰器模式提供一个AOP功能
/// </summary>
public class UserServiceDecorator : IUserService
{
    private IUserService UserService { get; set; }
    public UserServiceDecorator(IUserService userService)
    {
        UserService = userService;
    }

    public void Register(User user)
    {
        BeforeProceed(user);

        this.UserProcessor.RegUser(user);

        AfterProceed(user);
    }

    /// <summary>
    /// 业务逻辑之前
    /// </summary>
    /// <param name="user"></param>
    public void BeforeProceed(User user)
    {
        Console.WriteLine("方法执行前");
    }
    /// <summary>
    /// 业务逻辑之后
    /// </summary>
    /// <param name="user"></param>
    public void AfterProceed(User user)
    {
        Console.WriteLine("方法执行后");
    }
}
  • 使用简单代理模式
public abstract class UserService
{
	public abstract void Register(User user);
}

public class WebUserService : UserService
{
	public override void Register(User user)
	{
		Console.WriteLine("用户已注册！");
	}
}

/// <summary>
/// 使用代理模式实现AOP
/// </summary>
public class UserProxy : UserService
{
	private WebUserService webUserService;

	public override void Register(User user)
	{
		if(webUserService == null)
		{
			webUserService = new WebUserService();
		}

		webUserService.Register(user);
	}

	public void Before()
	{

	}

	public void After()
	{

	}
}

2. 动态代理实现AOP （RealProxy/emit生成/Unity）

  • 使用 .Net Remoting/RealProxy实现动态代理，此方式局限在于业务类必须是继承自MarshalByRefObject类型的类
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Proxies;
public class ProxyAOP
{
    public static void Show()
     {
        User user = new User() {
        	Name = "Lucas",
            Password = "123456"
        };
            
        UserService UserService = TransparentProxy.Create<UserService>();
        UserService.RegUser(user);
        int result = UserService.GetUserId();
     }

    /// <summary>
    /// 真实代理
    /// </summary>
    /// <typeparam name="T"></typeparam>
    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("方法执行后可以加入的逻辑");
        }
    }

    /// <summary>
    /// 透明代理
    /// </summary>
    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;
        }
    }


    public interface IUserService
    {
        void RegUser(User user);
        int GetUserId();
    }

    /// <summary>
    /// 必须继承自MarshalByRefObject父类
    /// </summary>
    public class UserService : MarshalByRefObject, IUserService
    {
        public void RegUser(User user)
        {
            Console.WriteLine("用户已注册。用户名称{0} Password{1}", user.Name, user.Password);
        }

        public int GetUserId()
        {
            return 123;
        }
    }
}
  • 使用Castle\DynamicProxy 实现动态代理,其局限性为业务类的方法必须为虚方法
using Castle.DynamicProxy;

public class CastleProxyAOP
{
    public static void Show()
    {
        User user = new User()
        {
            Name = "Lucas",
            Password = "123456"
        };
        
        ProxyGenerator generator = new ProxyGenerator();
        MyInterceptor interceptor = new MyInterceptor();
        UserService UserService = generator.CreateClassProxy<UserService>(interceptor);
        UserService.RegUser(user);
    }
    
    public interface IUserService
    {
        void RegUser(User user);
    }

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

    /// <summary>
    /// 添加的通用逻辑在此类中实现，继承IItercepter类
    /// </summary>
    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("方法执行后");
        }
    }
}
  • 使用Unity实现动态代理,针对整个类而言，不具体到某个方法，如果想要单独为某个方法增加，在handler中检测如果是其他方法的话则直接返回就行了，当然也有其他的方式，可以使用一下的几个方式实现针对某个方法的。
    TransparentProxyInterceptor：直接在类的方法上进行标记，但是这个类必须继承MarshalByRefObject…不建议用
    VirtualMethod：直接在类的方法上进行标记，但这个方法必须是虚方法（就是方法要带virtual关键字）
    InterfaceInterceptor：在接口的方法上进行标记，这样继承这个接口的类里实现这个接口方法的方法就能被拦截
using Unity;
using Unity.Interception.ContainerIntegration;
using Unity.Interception.Interceptors.InstanceInterceptors.InterfaceInterception;
using Unity.Interception.PolicyInjection.Pipeline;
using Unity.Interception.PolicyInjection.Policies;

public class UnityAOP
{
    public static void Show()
    {
        User user = new User() {
            Name = "Lucas",
            Password = "123456"
        };
        
        IUnityContainer container = new UnityContainer();//声明一个容器
        container.RegisterType<IUserService, UserService>();//声明UnityContainer并注册IUserService
        IUserService processor = container.Resolve<IUserService>();
        processor.RegUser(user);//调用

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

        IUserService UserService = container.Resolve<IUserService>();
        UserService.RegUser(user);//调用
        UserService.GetUser(user);//调用

    }

    #region 特性对应的行为
    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位"));
             }

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

             return methodReturn;
        }
    }

    public class LogHandler : ICallHandler
    {
        public int Order { get; set; }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="input">方法调用的参数列表</param>
        /// <param name="getNext"></param>
        /// <returns></returns>
        public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
            {
                User user = input.Inputs[0] as User;
                string message = $"RegUser:Username:{user.Name},Password:{user.Password}";
                Console.WriteLine("日志已记录，Message:{0},Ctime:{1}", message, DateTime.Now);
                return getNext()(input, getNext);
            }
    }

    public class ExceptionHandler : ICallHandler
    {
        public int Order { get; set; }
        public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
            {
                IMethodReturn methodReturn = getNext()(input, getNext);
                if (methodReturn.Exception == null)
                {
                    Console.WriteLine("无异常");
                }
                else
                {
                    Console.WriteLine($"异常:{methodReturn.Exception.Message}");
                }
                return methodReturn;
            }
    }

    public class AfterLogHandler : ICallHandler
    {
        public int Order { get; set; }
        public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
            {
                IMethodReturn methodReturn = getNext()(input, getNext);
                User user = input.Inputs[0] as User;
                string message = string.Format("RegUser:Username:{0},Password:{1}", user.Name, user.Password);
                Console.WriteLine("完成日志，Message:{0},Ctime:{1},计算结果{2}", message, DateTime.Now, methodReturn.ReturnValue);
                return methodReturn;
            }
    }
    #endregion 特性对应的行为

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

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

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

    public class AfterLogHandlerAttribute : HandlerAttribute
    {
        public override ICallHandler CreateHandler(IUnityContainer container)
        {
            return new AfterLogHandler() { Order = this.Order };
        }
    }
    #endregion 特性

    #region 业务
    [UserHandlerAttribute(Order = 1)]
    [ExceptionHandlerAttribute(Order = 3)]
    [LogHandlerAttribute(Order = 2)]
    [AfterLogHandlerAttribute(Order = 5)]
    public interface IUserService
    {
        void RegUser(User user);
        User GetUser(User user);
    }

    public class UserService : IUserService
    {
        public void RegUser(User user)
        {
            Console.WriteLine("用户已注册。");
            //throw new Exception("11");
        }

        public User GetUser(User user)
        {
            return user;
        }
    }
    #endregion 业务
Cording Home
关注
专栏目录
Spring 面向切面编程AOP实现详解
08-25
Spring 面向切面编程AOP实现详解 面向切面编程（AOP）是一种编程技术，旨在将横切关注点从业务逻辑中分离出来，提高系统的可扩展性和可维护性。Spring 作为一个流行的 Java 框架，提供了完备的 AOP 实现机制。 1. ...
面向切面编程aop简介
08-04
面向切面编程（AOP，Aspect Oriented Programming）是Spring框架的重要组成部分，它提供了一种在不修改原有业务代码的基础上，插入额外功能的编程模型。Spring AOP使得开发者能够更方便地实现如日志记录、事务管理、...
AOP
weixin_43751710的博客
03-01 154
AOP简介 AOP也就是面向切面，意思是做出一些通用的功能，如打印日志等，应用于所有需要的地方。传统的面向对象，在每个对象里进行打印日志，重复且无意义。 AOP实现的思路，拦截住一些需要使用打印日志功能的方法，使用动态代理，对原本的方法加入了打印日志的操作。 AOP具体使用方法 先定义一个切点，也就是需要拦截的地方。 围绕着切点，进行日志打印，共有五种执行日志打印的时机： before(前置通知...
在Unity中使用.Net Remoting实现双向通信
weixin_39106746的博客
11-28 1190
前言: 之前公司接到项目的需求是使用一台电脑远程控制另外一台电脑,点击操作端电脑的Button,使显示端显示指定的画面.这个需求本质上两台电脑之间的相互通信,第一个想到的方案就是开发两个app,一个是服务器,一个是客户端,使用Tcp进行通信.本人没有使用这个方案的原因有以下两个: 1.项目需求只是远程控制,本人使用互联网进行连接有一种杀鸡用牛刀的感觉. 2.本人是个前端程序员,该项目开发周期...
Unity 代理模式（实例详解）
最新发布
qqrrjj2011的博客
01-26 1819
在Unity游戏开发中，代理模式（Proxy Design Pattern）用于为另一个对象提供一个代理以控制对这个对象的访问。这些例子展示了如何在Unity中使用代理模式来解决资源管理、网络请求、性能优化、权限控制以及热更新等场景下的问题。每个代理类都封装了一个真实对象，并提供了额外的功能或控制层。
unity进程间通信
myth的博客
09-06 6285
C#
基于框架的Web开发-面向切面编程AOP入门.doc
07-04
总的来说，面向切面编程AOP是一种强大的工具，用于管理横切关注点，它使我们能够编写更加模块化、可重用的代码，特别是在大型企业级应用中，如Web开发，它可以极大地提升代码质量和开发效率。通过合理使用AOP，我们...
浅谈Android面向切面编程（AOP）
01-04
AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是...
Spring面向切面编程AOP
11-29
面向切面编程（AOP，Aspect Oriented Programming）是Spring框架中的一个重要特性，它提供了一种模块化和声明式的方式来处理程序中的横切关注点，如日志、事务管理、安全控制等。AOP的核心概念包括切面、通知、连接...
将 Unity5.3 的老项目升级到 Unity 2018.3 遇到的些许问题。
weixin_30379973的博客
01-18 1928
删除 ParticleEmmiter 等废弃的接口； 删除 WindowsSecurityContext System.Security.Principal.WindowsIdentity 在 .Net Standard 2.0 中无定义，需要注意 api 兼容性版本； System.Runtime.Remoting 4.5 .net runtime does not ...
关于Unity升级到2018.3报 The type or namespace name 'Remoting'...错误
糯米团子的博客
09-13 3302
今天得到好消息是Unity2018.3将支持C#7，于是兴奋地升级了下。结果报了个The type or namespace name 'Remoting' does not exist in the namespace 'System.Runtime'这样的错误。网上查了下这是因为API LEVEL这边默认的是2.0的原因，升级到4.X就解决了。 ...
c# 命名空间_system.runtime.remoting
06-12 822
http://msdn.microsoft.com/zh-cn/library/system.runtime.remoting(VS.80).aspx ...
代理模式详解总结（静态代理）
hiscoming的博客
04-08 266
代理模式的定义：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。 代理模式的主要优点有： 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用； 代理对象可以扩展目标对象的功能； 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度，增加了程序的可扩展性 其主要缺点是： 代理模式会造成系统设计中类的数量增加 在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢； 增加了系统的
unity设置代理，以及解决下载依赖包报错 unable to verify the first certificate的问题
XR风云
09-03 6464
使用unity，必须能够联网，需要下载一些依赖包或者登陆。在公司中，一般都是使用代理进行连接外网的，总结一下unity使用代理联网的一些坑。 1、设置代理 设置代理方式主要有2种， 1、在环境变量中增加HTTP_PROXY与HTTPS_PROXY环境变量，我这不详细介绍了，你们百度。 2、我比较喜欢的使用方式，用文本打开一个文件，把下面代码复制到文件中，修改你们的代理地址与你们的Unity执行文件的路径信息。保存文件为后缀为bat的文件。双击bat文件就可以启动unity hub了。 @echo
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值