【Spring AOP】静态代理设计模式，大牛带你直击优秀开源框架灵魂

房东 --- 目标类

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

}

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. 额外功能 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"/>

3. 定义 切入点：额外功能的加入

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

aop:config

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

</aop:config>

4. 组装（2、3 整合）

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/aop

https://www.springframework.org/schema/aop/spring-aop.xsd">

<bean id="userService" class="com.yusael.aop.UserServiceImpl"/>

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

aop:config

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

<aop:advisor advice-ref="before" pointcut-ref="pc"/>

</aop:config>

</beans>

5. 调用

目的：获得 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 运行过程中动态创建的；

所以不会造成静态代理的缺点：类?件数量过多，影响项目管理的问题。

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

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

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

[](

)动态代理开发详解

===========================================================================

[](

)额外功能的详解

[](

)MethodBeforeAdvice 分析

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

public class Before implements MethodBeforeAdvice {

/**

• 作用: 把需要运行在原始方法执行之前运行的额外功能, 书写在 before 方法中

• Method: 额外功能所增加给的那个原始方法

• Object[]: 额外功能所增加给的那个原始方法的参数

• Object: 额外功能所增加给的那个原始对象

*/

@Override

public void before(Method method, Object[] objects, Object o) throws Throwable {

System.out.println("---new method before advice log---");

}

}

2. 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）

• (..) --> 所有方法

• ---> 修饰符 返回值