【框架】从动态代理理解spring AOP

古城微笑少年丶 2023-07-24 14:42 9阅读 0赞

**目录**

为什么要说动态代理：

动态代理的实现：

动态代理的分类：

Spring 的AOP

一、 使用AspectJ

二、使用xml配置文件

--------------------

# **为什么要说动态代理：** #

动态代理可以实现为对象提供一种代理，以控制这个对象的访问。

我们通常会用到在执行一批操作之前，例如对数据库数据进行增删改，需要保证这一部分操作的完整性，如果出现问题需要回滚到操作之前的状态。而这样的操作在业务上有很多。

最简单粗暴的做法，就是在每一个方法调用之前先加载这一步安全控制方法。

代理模式正是做了这样一件事情，它实现被代理类的接口，并引入被代理类，我们调用UserManagerImpleProxy类来通过代理类实现添加的功能。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3htbDE5OTY_size_16_color_FFFFFF_t_70][]

/*
    * 静态代理类
    * 实现接口UserManager
    * 引入UserManagerImpl
    * */
    public class UserManagerImplProxy implements UserManager {
       
       private UserManagerImpl userManagerImpl;
    
    
       // 构造方法
       public UserManagerImplProxy(UserManagerImpl userManagerImpl) {
          this.userManagerImpl = userManagerImpl;
       }
    
    
       // 具体方法
       public void addUser(String username, String password) {
          // 执行检查方法
          checkSecurity();
          // 调用具体类的实现方法
          userManagerImpl.addUser(username, password);
       }
    
       public void delUser(int userId) {
          checkSecurity();
          userManagerImpl.delUser(userId);
       }
    
       public String findUserById(int userId) {
          checkSecurity();
          return userManagerImpl.findUserById(userId);
       }
    
       public void modifyUser(int userId, String username, String password) {
          checkSecurity();
          userManagerImpl.modifyUser(userId, username, password);
       }
    
       // 检查的方法
       private void checkSecurity() {
          System.out.println("-------checkSecurity-------");
       }  
    }

这是典型的**静态代理**，也就是在运行之前代码编辑好的，静态代理避免了修改原有的类，为了实现基本的开闭原则，在不修改原代码的基础上重新写一个代理类，来实现需要添加的功能。

但是同时这也是它的局限，它并没有避免多次调用checkSecurity()这个方法，每一个需要被代理的类都要有一个代理类，每一个代理类下的每一个方法前面都需要添加这样的方法，在代码量很大的情况下，就会很冗余。

所以出现了动态代理，不需要提前写好代理类，在程序运行的时候加载创建需要的代理类。

这也就是为什么要用动态代理的原因。

# **动态代理的实现：** #

采用最原始的动态代理模式

来实现在加载add方法之前，打印一句话-------checkSecurity------

public class SecurityHandler implements InvocationHandler {
       
       private Object targetObject;
       
       public Object createProxyInstance(Object targetObject) {
          this.targetObject = targetObject;
          return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
                            targetObject.getClass().getInterfaces(),
                            this);
       }
       
       public Object invoke(Object proxy, Method method, Object[] args)
             throws Throwable {
          System.out.println("-------checkSecurity-------");
          
          //调用目标方法
          Object ret = method.invoke(targetObject, args);
          
          return ret;
       }
       
    }

这里method.invoke(目标类，目标类参数)；只需要把需要被代理的类传给这个SecurityHandler类，它就可以动态创建代理类并执行invoke方法在执行方法之前添加上需要的内容

**PS：动态代理，相当于在火腿肠出厂之前，把所有这一批生成的火腿肠，都打上生产日期的码，返回的东西，都是打码后的火腿肠，你在吧火腿肠放入打码器之前，需要先告诉它这个是什么食品：火腿肠。**

**也就是在需要告诉动态代理，这个需要被代理的类是谁，之后动态代理会执行相应的加工方法invoke(),对传入的类进行处理。**

执行结果：

![20200412162851280.png][]

# **动态代理的分类：** #

动态代理也分两种，一种是，提供的这个要被代理的类有接口，一个是没有接口的。

1.  JDK动态代理，是有接口的类的代理
2.  CGlib动态代理，是没有接口的

# **Spring 的AOP** #

spring框架实现了这样的功能，不需要我们自己手动去写动态代理来实现这样的功能，减轻了开发过程中的工作量，更加规范方便。并且，spring会根据需要代理的这个类有无接口来自己选择需要使用的代理类型。

但也不是绝对的，我们也可以在有接口的情况下，强制使用CGlib动态代理：

在spring的配置文件中添加（applicationConfiger.xml）：

>   
> 
> <aop:aspectj-autoproxy proxy-target-class="true"/>

**spring AOP管理的两种风格：实现方式不同**

### 一、 使用AspectJ ###

通过在spring的配置文件中配置   <aop:aspectj-autoproxy/>

把刚刚动态代理的部分，用这样注解的方式代替标识。

@Aspect
    public class SecurityHandler {
       /**
        * 定义Pointcut，Pointcut的名称为addAddMethod()，此方法没有返回值和参数
        * 该方法就是一个标识，不进行调用
        */
       @Pointcut("execution(* add*(..))")
       private void addAddMethod(){};
       
       /**
        * 定义Advice，表示我们的Advice应用到哪些Pointcut订阅的Joinpoint上
        */
       @Before("addAddMethod()")
       //@After("addAddMethod()")
       private void checkSecurity() {
          System.out.println("-------checkSecurity-------");
       }     
    }

>  这里涉及到一些AOP的基础概念：
> 
> **\* 切面（Aspect）：** 一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。 在Spring AOP中，切面可以使用通用类（基于模式的风格） 或者在普通类中以 @Aspect 注解（@AspectJ风格）来实现。
> 
> **\* 连接点（Joinpoint）**： 在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。 在Spring AOP中，一个连接点 总是 代表一个方法的执行。 通过声明一个org.aspectj.lang.JoinPoint类型的参数可以使通知（Advice）的主体部分获得连接点信息。
> 
> **\* 通知（Advice）：** 在切面的某个特定的连接点（Joinpoint）上执行的动作。通知有各种类型，其中包括“around”、“before”和“after”等通知。 通知的类型将在后面部分进行讨论。许多AOP框架，包括Spring，都是以拦截器做通知模型， 并维护一个以连接点为中心的拦截器链。
> 
> **\* 切入点（Pointcut）：** 匹配连接点（Joinpoint）的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。 切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。
> 
> **\* 引入（Introduction）：** （也被称为内部类型声明（inter-type declaration））。声明额外的方法或者某个类型的字段。 Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。 例如，你可以使用一个引入来使bean实现 IsModified 接口，以便简化缓存机制。
> 
> **\* 目标对象（Target Object）：** 被一个或者多个切面（aspect）所通知（advise）的对象。也有人把它叫做 被通知（advised） 对象。 既然Spring AOP是通过运行时代理实现的，这个对象永远是一个 被代理（proxied） 对象。
> 
> **\* AOP代理（AOP Proxy）：** AOP框架创建的对象，用来实现切面契约（aspect contract）（包括通知方法执行等功能）。 在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。 注意：Spring 2.0最新引入的基于模式（schema-based）风格和@AspectJ注解风格的切面声明，对于使用这些风格的用户来说，代理的创建是透明的。
> 
> **\* 织入（Weaving）：** 把切面（aspect）连接到其它的应用程序类型或者对象上，并创建一个被通知（advised）的对象。 这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。 Spring和其他纯Java AOP框架一样，在运行时完成织入。

### 二、使用xml配置文件 ###

可以直接省略掉标识@Aspect,直接使用配置文件配置需要切入的类，切入的方法位置，以及具体执行的内容都可以在这里配置

> <aop:config>
> 
>    <aop:aspect id="securityAspect" ref="securityHandler">
> 
>       
> 
>        
> 
>       <aop:pointcut id="addAddMethod" expression="execution(\* com.bjpowernode.spring.\*.add\*(..)) || execution(\* com.bjpowernode.spring.\*.del\*(..))"/>
> 
>       <aop:before method="checkSecurity" pointcut-ref="addAddMethod"/>
> 
>    </aop:aspect>
> 
> </aop:config>

// 这是具体的执行类
    public class SecurityHandler {
       
       private void checkSecurity(JoinPoint joinPoint) {
          for (int i=0; i<joinPoint.getArgs().length; i++) {
             System.out.println(joinPoint.getArgs()[i]+"-----这是joinPoint.getArgs()的第"+ i);
          }
          
          System.out.println(joinPoint.getSignature().getName()+"------这是joinPoint.getSignature().getName()");
          
          System.out.println("-------checkSecurity-------");
       }     
    }

运行结果：

![20200412163130494.png][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3htbDE5OTY_size_16_color_FFFFFF_t_70]: /images/20230528/dc74f4e9dc9d41b59b89dee0b4dd1714.png
[20200412162851280.png]: /images/20230528/f4473b9b454345c5a3375db7f857fa4e.png
[20200412163130494.png]: /images/20230528/ffd7ade7417a42548a2d18f18237ca63.png