【Spring AOP】静态代理设计模式、Spring 动态代理开发详解、切入点详解（切入点表达式、切入点函数）

你的名字 2023-02-13 03:22 94阅读 0赞

### AOP 编程 ###

*  静态代理设计模式
 *   *  1. 为什么需要代理设计模式
     *  2. 代理设计模式
     *   *  名词解释
         *  代理开发的核心要素
         *  静态代理编码
         *  静态代理存在的问题
 *  Spring 动态代理开发
 *   *  搭建开发环境
     *  Spring 动态代理的开发步骤(5步)
     *  动态代理细节分析
 *  动态代理开发详解
 *   *  额外功能的详解
     *   *  MethodBeforeAdvice 分析
         *  MethodInterceptor（方法拦截器）
 *  切入点详解
 *   *  切入点表达式
     *   *  方法切入点
         *  类切入点
         *  包切入点（实战中用的多）
     *  切入点函数（execution、args、within）
     *   *  exectuion
         *  args
         *  within
         *  @annotation
         *  切入点函数的逻辑运算（and、or）

> 更多内容请查看笔记目录：[【Spring 5.x】学习笔记汇总][Spring 5.x]

# 静态代理设计模式 #

## 1. 为什么需要代理设计模式 ##

在 JavaEE 分层开发开发中，哪个层次对于我们来讲最重要？**Service 层**

Service 层中包含了哪些代码？

*  **核心功能**（代码量较多）：业务运算，DAO 调用
 *  **额外功能**（附加功能，不属于业务，可有可无，代码量小）：事务、日志、性能 …

额外功能书写在 Service 层好不好?

*  Service 层的调用者的角度（Controller)：需要在 Service 层书写额外功能。
 *  软件设计者：Service 层不需要额外功能。

拿现实生活中的例子来做对比，解决方案是 **引入一个代理**。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70]

## 2. 代理设计模式 ##

概念：通过代理类，为原始类（目标类）增加额外的功能  
好处：利于原始类（目标类）的维护

### 名词解释 ###

**目标类 / 原始类**：指的是 **业务类** (核心功能 --> 业务运算、DAO调用)  
**目标方法 / 原始方法**：目标类（原始类）中的方法就是目标方法（原始方法）  
**额外功能 / 附加功能**：日志、事务、性能 …

### 代理开发的核心要素 ###

代理类 = 目标类(原始类) + 额外功能 + 原始类(目标类)实现相同的接口

房东 --- 目标类
    public interface UserService { 
    	m1
    	m2
    }
    public UserServiceImpl implements UserServiceImpl { 
    	m1 ---> 业务运算、调用DAO
    	m2 
    }
    ----------------------------------------------------
    中介 --- 代理类：要实现目标类相同的接口
    public UserServiceProxy implements UserService { 
    	m1
    	m2
    }

### 静态代理编码 ###

**静态代理**：为每⼀个原始类，手工编写⼀个代理类（.java .class）

public class User { }

public interface UserService { 
    	void register(User user);
    	boolean login(String name, String password);
    }

public class UserServiceImpl implements UserService { 
        @Override
        public void register(User user) { 
            System.out.println("UserServiceImpl.register 业务运算 + DAO");
        }
    
        @Override
        public boolean login(String name, String password) { 
            System.out.println("UserServiceImpl.login 业务运算 + DAO");
            return true;
        }
    }

/** * 静态代理类编码实现 */
    public class UserServiceProxy implements UserService {  // 实现原始类相同的接口
        private UserService userService = new UserServiceImpl(); // 代理类中必须有原始类
        @Override
        public void register(User user) { 
            System.out.println("---log---"); // 额外功能
            userService.register(user);
        }
        @Override
        public boolean login(String name, String password) { 
            System.out.println("---log---"); // 额外功能
            return userService.login(name, password);
        }
    }

### 静态代理存在的问题 ###

1.  **静态类文件数量过多，不利于项目管理**  
    `UserServiceImpl`、`UserServiceProxy`  
    `OrderServiceImpl`、`OrderServiceProxy`  
    …
2.  **额外功能维护性差**：在代理类中修改额外功能较为麻烦

# Spring 动态代理开发 #

概念：通过代理类为原始类（目标类）增加额外功能  
好处：利于原始类（目标类）的维护

## 搭建开发环境 ##

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>5.1.14.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.8.9</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.13</version>
    </dependency>

## Spring 动态代理的开发步骤(5步) ##

1.  创建原始对象（目标对象）

public interface UserService { 
        void register(User user);
        boolean login(String name, String password);
    }

1.  额外功能 `MethodBeforeAdvice` 接口

public class Before implements MethodBeforeAdvice { 
        /** * 作用: 把需要运行在原始方法执行之前运行的额外功能, 书写在 before 方法中 */
        @Override
        public void before(Method method, Object[] objects, Object o) throws Throwable { 
            System.out.println("---method before advice log---");
        }
    }

<bean id="before" class="com.yusael.aop.Before"/>

1.  定义 **切入点**：额外功能的加入  
    目的: 由程序员根据自己的需要，决定额外功能加入给哪个原始方法(register、login)

<aop:config>
            <aop:pointcut id="pc" expression="execution(* * (..))"/>
        </aop:config>

1.  组装（2、3 整合）

1.  调用  
    目的：获得 Spring 工厂创建的动态代理对象，并进行调用  
    注意：
    
    1.  Spring 的工厂通过原始对象的 id 值获得的是代理对象
    2.  获得代理对象后，可以通过声明接口类型，进行对象的存储

/** * 用于测试动态代理 */
    @Test
    public void test1() { 
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
        UserService userService = (UserService) ctx.getBean("userService");
        userService.login("admin", "1234");
        userService.register(new User());
    }

## 动态代理细节分析 ##

Spring 创建的动态代理类在哪里？

*  Spring 框架在运行时，通过动态字节码技术，在 JVM 创建的，运行在 JVM 内部，等程序结束后，会和 JVM 一起消失。

什么是 **动态字节码技术**？

*  通过**第三方动态字节码框架**，在 JVM 中创建对应类的字节码，进而创建对象，当虚拟机结束，动态字节码跟着消失。

结论：

*  **动态代理不需要定义类文件，都是 JVM 运行过程中动态创建的**；  
    所以不会造成静态代理的缺点：类⽂件数量过多，影响项目管理的问题。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 1]

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

动态代理编程简化代理的开发

*  在额外功能不改变的前提下，创建其他目标类（原始类）的代理对象时，只需要指定原始（目标）对象即可。

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

动态代理使得 **额外功能的维护性大大增强**。

# 动态代理开发详解 #

## 额外功能的详解 ##

### MethodBeforeAdvice 分析 ###

1.  `MethodBeforeAdvice` 接口作用：额外功能运行在原始方法执行之前，进行额外功能操作。

public class Before implements MethodBeforeAdvice { 
        /** * 作用: 把需要运行在原始方法执行之前运行的额外功能, 书写在 before 方法中 * * Method: 额外功能所增加给的那个原始方法 * login * register * -------- * showOrder * * Object[]: 额外功能所增加给的那个原始方法的参数 * String name,String password * User * -------- * * Object: 额外功能所增加给的那个原始对象 * UserServiceImpl * --------------- * OrderServiceImpl */
        @Override
        public void before(Method method, Object[] objects, Object o) throws Throwable { 
            System.out.println("---new method before advice log---");
        }
    
    }

1.  `before` 方法的 3 个参数在实战中，该如何使用？  
    `before` 方法的参数，在实战中，会根据需要进行使用，不⼀定都会用到，也有可能都不用。  
    孙哥：”我用了 15 年 Spring 一次都没有用到过这个。"

### MethodInterceptor（方法拦截器） ###

`methodinterceptor` 接口：额外功能可以根据需要运行在原始方法执行 **前、后、前后**。

*  参数：`MethodInvocation`：额外功能所增加给的那个原始方法 (login, register)
 *  返回值：`Object`：原始方法的返回值 (没有就返回 null)
 *  `invocation.proceed()`：原始方法运行

额外功能运行在原始方法 **之前**：

public class Around implements MethodInterceptor { 
        @Override
        public Object invoke(MethodInvocation methodInvocation) throws Throwable { 
            System.out.println("---额外功能运行在原始方法执行之前---");
            Object ret = methodInvocation.proceed(); // 原始方法运行, 获取原始方法的返回值
            return ret;
        }
    }

额外功能运行在原始方法 **之后**：

public class Around implements MethodInterceptor { 
        @Override
        public Object invoke(MethodInvocation methodInvocation) throws Throwable { 
            Object ret = methodInvocation.proceed(); // 原始方法运行, 获取原始方法的返回值
            System.out.println("---额外功能运行在原始方法执行之后---");
            return ret;
        }
    }

额外功能运行在原始方法 **之前、之后**：

public class Around implements MethodInterceptor { 
        @Override
        public Object invoke(MethodInvocation methodInvocation) throws Throwable { 
        	System.out.println("---额外功能运行在原始方法执行之前---");
            Object ret = methodInvocation.proceed(); // 原始方法运行, 获取原始方法的返回值
            System.out.println("---额外功能运行在原始方法执行之后---");
            return ret;
        }
    }

额外功能运行在原始方法抛出异常的时候：

public class Around implements MethodInterceptor { 
        @Override
        public Object invoke(MethodInvocation methodInvocation) throws Throwable { 
            Object ret = null;
            try { 
                ret = methodInvocation.proceed(); // 原始方法运行, 获取原始方法的返回值
            } catch (Throwable throwable) { 
                System.out.println("---额外功能运行在原始方法抛异常的时候---");
            }
            return ret;
        }
    }

`MethodInterceptor` 影响原始方法的返回值：

public class Around implements MethodInterceptor { 
        @Override
        public Object invoke(MethodInvocation methodInvocation) throws Throwable { 
            System.out.println("---log---");
            Object ret = methodInvocation.proceed();
            return false;
        }
    }

# 切入点详解 #

切入点决定额外功能加入位置（方法）

<aop:pointcut id="pc" expression="execution(* * (..))"/>

*  `execution()`：**切入点函数**
 *  `* *(..)`：**切入点表达式**

## 切入点表达式 ##

### 方法切入点 ###

定义一个方法
    public void add（int i, int j）
       *               *      (..)

* * (..)    --> 所有方法
    
    *  --->  修饰符 返回值
    *  --->  方法名
    () --->  参数表
    .. --->  对于参数没有要求 (参数有没有，参数有⼏个都行，参数是什么类型的都行)

*  定义 `login` 方法作为切入点：

<aop:pointcut id="pc" expression="execution(* login (..))"/>
    
    
    <aop:pointcut id="pc" expression="execution(* register (..))"/>

*  定义方法名为 `login` 且 有两个字符串类型的参数 作为切入点；

<aop:pointcut id="pc" expression="execution(* login (String,String))"/><
    
    
    <aop:pointcut id="pc" expression="execution(* register (com.yusael.proxy.User))"/>
    
    
    <aop:pointcut id="pc" expression="execution(* login(String, ..))"/>

*  精准方法切入点限定

修饰符  返回值  包  类.方法(参数)

<aop:pointcut id="pc" expression="execution(* com.yusael.proxy.UserServiceImpl.login(..))"/>
    
    <aop:pointcut id="pc" expression="execution(* com.yusael.proxy.UserServiceImpl.login(String, String))"/>

### 类切入点 ###

指定 **特定类作为切入点(额外功能加入的位置)**，这个类中的所有方法，都会加上对应的额外功能。

*  语法1

# 类中所有的方法加入了额外功能
    <aop:pointcut id="pc" expression="execution(* com.yusael.proxy.UserServiceImpl.*(..))"/>

*  语法2

# 忽略包
    1. 类只存在一级包
    <aop:pointcut id="pc" expression="execution(* *.UserServiceImpl.*(..))"/>
    2. 类存在多级包
    <aop:pointcut id="pc" expression="execution(* *..UserServiceImpl.*(..))"/>

### 包切入点（实战中用的多） ###

指定**包作为额外功能加入的位置**，自然包中的所有类及其方法都会加入额外的功能。

*  语法1：

# 切入点包中的所有类，必须在proxy中，不能在proxy包的⼦包中
    <aop:pointcut id="pc" expression="execution(* com.yusael.proxy.*.*(..))"/>

*  语法2：

# 切入点当前包及其⼦包都生效
    <aop:pointcut id="pc" expression="execution(* com.yusael.proxy..*.*(..))"/>

## 切入点函数（execution、args、within） ##

切入点函数：用于执行切入点表达式

### exectuion ###

`execution` 是最为重要的切入点函数，功能最全；可以执行执行 **方法切入点表达式**、**类切入点表达式**、**包切入点表达式**；  
弊端：`execution` 执⾏切入点表达式 ，书写麻烦

execution(* com.yusael.proxy..*.*(..))

注意：其他的 切入点函数 简化的是 `execution` 的书写复杂度，功能上完全⼀致。

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

### args ###

`args` 作用：主要用于 **函数(方法) 参数的匹配**；

切入点：方法参数必须得是 2 个字符串类型的参数
    
    # 使用 execution
    <aop:pointcut id="pc" expression="execution(* *(String, String))"/>
    
    # 使用 args
    <aop:pointcut id="pc" expression="args(String, String)"/>

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

### within ###

`within` 作用：主要用于进行 **类、包切入点表达式** 的匹配。

切入点: UserServiceImpl 这个类
    
    # 使用 execution
    <aop:pointcut id="pc" expression="expression(* *..UserServiceImpl.*(..))"/>
    
    # 使用 within
    <aop:pointcut id="pc" expression="within(*..UserServiceImpl)"/>

切入点: com.yusael.proxy 这个包
    
    # 使用 execution
    <aop:pointcut id="pc" expression="execution(* com.yusael.proxy..*.**(..)"/>
    
    # 使用 within
    <aop:pointcut id="pc" expression="within(com.yusael.proxy..*)"/>

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

### @annotation ###

作用：为具有特殊注解的 **方法** 加入额外功能。

例如我们自定义了一个注解：`Log`

@Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Log { 
    }

然后我们要为使用了 `Log` 注解的方法加入额外功能。

<aop:pointcut id="pc" expression="@annotation(com.yusael.Log)"/>

### 切入点函数的逻辑运算（and、or） ###

切入点函数的逻辑运算 指的是：整合多个切入点函数⼀起配合工作，进而完成更为复杂的需求。

**and 与操作**：

案例: 方法名叫 login 同时 参数是 2个字符串
    # execution
    <aop:pointcut id="pc" expression="execution(* login(String, String))"/>
    # execution and args
    <aop:pointcut id="pc" expression="execution(* login(..)) and args(String, String))"/>

注意：与操作不同⽤于同种类型的切⼊点函数
    以下这个是错误的, 因为不存在同时叫 login 和 register 的方法
    <aop:pointcut id="pc" expression="execution(* login(..)) and execution(* register(..))"/>

**or 或操作**：

案例: 方法名叫 register 或 login 的⽅法作为切⼊点
    <aop:pointcut id="pc" expression="execution(* login(..)) or execution(* register(..))"/>

[Spring 5.x]: https://blog.csdn.net/weixin_43734095/article/details/106309373
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200526233623978.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200527211524289.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ==,size_16,color_FFFFFF,t_70