【Spring】动态代理开发详解

太过爱你忘了你带给我的痛 2022-09-14 08:41 203阅读 0赞

### 这里写目录标题 ###

*  一、搭建开发环境
 *  二、Spring 动态代理的开发
 *   *  2.1 创建原始对象（目标对象）
     *  2.2 额外功能\`MethodBeforeAdvice\`接口
     *  2.3 定义切入点
     *  2.4 组装
     *  2.5 调用
 *  二、动态代理细节分析
 *  三、动态代理开发详解
 *   *  3.1 MethodBeforeAdvice
     *  3.2 MethodInterceptor（方法拦截器）

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

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

# 一、搭建开发环境 #

<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 动态代理的开发 #

## 2.1 创建原始对象（目标对象） ##

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;
        }
    }

## 2.2 额外功能`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"/>

## 2.3 定义切入点 ##

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

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

## 2.4 组装 ##

步骤二、步骤三进行整合。

## 2.5 调用 ##

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

/** * 用于测试动态代理 */
    @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_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5pyb5aSp6L655pif5a6_size_20_color_FFFFFF_t_70_g_se_x_16]

*  动态代理编程简化代理的开发：在额外功能不改变的前提下，创建其他目标类（原始类）的代理对象时，只需要指定原始（目标）对象即可。
 *  动态代理使得额外功能的维护性大大增强。

# 三、动态代理开发详解 #

## 3.1 MethodBeforeAdvice ##

`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---");
        }
    }

## 3.2 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;
        }
    }

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5pyb5aSp6L655pif5a6_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/dc35d251a182448fb032ac905b1fe280.png