【Spring AOP(2)篇】原理及两种实现方式（cglib&jdk动态代理）

Dear 丶 2023-09-25 21:44 4阅读 0赞

**简介：** Spring AOP（Aspect-Oriented Programming，面向切面编程）是 Spring 框架的一个重要特性，用于解耦和切割业务逻辑，是实现面向切面编程的重要手段之一。本文将介绍 Spring AOP 的原理及Spring AOP 的两种实现方式

### Spring AOP实现原理 ###

Spring AOP 是 Spring 框架提供的一种 AOP 实现方式，其核心原理是基于代理模式。它通过将目标对象（也就是被代理对象）包装成一个代理对象，从而实现对目标对象方法的动态拦截和处理，实现面向切面编程的目的。下面举个栗子。

> 假设你去医院看病，医生开了一些检查单让你去做，然后又给你开了一些药物和处方让你去取药。这里的医生就是一个代理对象，而你就是目标对象。医生不仅可以给你开药单，还可以对你的病情进行相应的诊断和建议，甚至可以对你的药物使用情况进行跟踪和评估。  
>   
> 在这个例子中，代理对象（医生）可以在你去做检查之前或取药之后，添加一些额外的逻辑处理。例如，医生可以检查你是否真的需要这些检查，或者是否有更好的药物替代方案。  
> 这就类似于 Spring AOP 的代理对象在目标对象执行方法之前或之后，增加拦截和增强逻辑。  
>   
> 与此同时，代理对象还可以为目标对象屏蔽一些底层细节和对系统的影响，例如，医生可以提供一些健康咨询和建议，帮助你更好地理解自己的身体状况，而无需了解医学专业知识（也就是目标对象的内部实现）。这就类似于 Spring AOP 的代理对象可以为目标对象提供更好的封装和抽象，提高了系统的稳定性和安全性。

通过这个例子，我们可以更好地理解 Spring AOP 的代理原理，并深入理解代理对象和目标对象的区别和联系。代理对象相当于是目标对象的一个代理人，实现了对目标对象方法的拦截和处理，并承担了更多的职责和责任。同时，代理对象也可以起到更好的封装和抽象作用，提高了系统的可维护性和可扩展性。

### Spring AOP 两种实现方式 ###

默认使用 JDK 动态代理（如果目标对象实现了至少一个接口），如果目标对象没有实现接口，则使用 CGLIB 来代理对象。  
可以通过配置参数 **proxyTargetClass** 来强制使用 **CGLIB** 代理，或者设置为 **false** 来强制使用 JDK 动态代理。如果不设置此参数，则根据上述规则来选择代理方式。

#### 1.CGLIB ####

首先，定义好类，并且在类中添加需要增强的方法和切面逻辑。然后，定义一个切面类，调用 Enhancer.create 方法动态生成代理对象，并将 MethodInterceptor 对象传递给代理对象。最终，在 Spring 容器中进行配置和使用即可。  
**上代码**

定义类和方法  
定义一个类 UserService，其中有一个需要增强的 addUser 方法：

public class UserService {
        
        public void addUser(User user) {
        
            System.out.println("Add user: " + user.getName() + ", " + user.getAge());
        }
    }

##### 定义切面类 #####

定义一个切面类 LogAspect，实现 MethodInterceptor 接口，并在 intercept 方法中编写增强逻辑：

@Component
    public class LogAspect implements MethodInterceptor {
        
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        
            System.out.println("Before method: " + method.getName());
            Object result = proxy.invokeSuper(obj, args);
            System.out.println("After method: " + method.getName());
            return result;
        }
    }

##### 配置 Spring AOP #####

在 Spring 配置文件中，定义 bean，并初始化切面类，通过 Enhancer.create 方法动态生成代理对象，并注入到容器中：

@Configuration
    public class AppConfig {
        
        @Autowired
        private LogAspect logAspect;
        
        @Bean
        public UserService userService() {
        
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(UserService.class);
            enhancer.setCallback(logAspect);
            return (UserService) enhancer.create();
        }
        
        @Bean
        public LogAspect logAspect() {
        
            return new LogAspect();
        }
    }

最后，在测试类中通过 Spring 容器获取 UserService 的代理对象，并调用其方法：

@RunWith(SpringRunner.class)
    @ContextConfiguration(classes = AppConfig.class)
    public class UserServiceTest {
        
        @Autowired
        private UserService userService;
        @Test
        public void testAddUser() {
        
            User user = new User();
            user.setName("Tom");
            user.setAge(20);
            userService.addUser(user);
        }
    }

**注解说明：**

- @Component：表示 LogAspect 是一个 Spring bean；
     - @Bean：表示该方法返回的对象将作为一个 bean 注入到 Spring 容器中；
     - Enhancer：CGLIB 提供的类，用于动态生成代理类；
     - setSuperclass：设置需要代理的父类；
     - setCallback：设置 MethodInterceptor 接口的实现类；
     - MethodInterceptor：CGLIB 提供的接口，用于拦截方法调用。

#### 2.JDK 动态代理 ####

首先，定义好接口，并且在实现类中添加需要增强的方法和切面逻辑。然后，定义一个切面类，实现 InvocationHandler 接口，并且在 invoke 方法中编写增强逻辑。最后，通过 Proxy 类动态生成代理对象，并将 InvocationHandler 对象传递给代理对象。最终，在 Spring 容器中进行配置和使用即可。

**上代码**

##### 定义接口和实现类 #####

定义一个接口 UserService 和一个实现类 UserServiceImpl，其中实现类中有一个需要增强的 addUser 方法：

public interface UserService {
        
        void addUser(User user);
    }
    
    @Service
    public class UserServiceImpl implements UserService {
        
        @Override
        public void addUser(User user) {
        
            System.out.println("Add user: " + user.getName() + ", " + user.getAge());
        }
    }

##### 定义切面类 #####

定义一个切面类 LogAspect，并在其 before 方法中实现增强逻辑：

@Component
    @Aspect
    public class LogAspect {
        
        @Before("execution(* com.example.demo.service.UserService.addUser(..)) && args(user)")
        public void before(User user) {
        
            System.out.println("Before adding user: " + user.getName() + ", " + user.getAge());
        }
    }

##### 配置 Spring AOP #####

在 Spring 配置文件中，配置开启 Spring AOP 的注解支持，并扫描切面类：

@Configuration
    @EnableAspectJAutoProxy
    @ComponentScan("com.example.demo")
    public class AppConfig {
        
    
    }

最后，在测试类中通过 Spring 容器获取 UserService 的代理对象，并调用其方法：

**注解说明：**

*  @Aspect：表示 LogAspect 是一个切面类；
 *  @Before：表示 before 类型的通知，在目标方法执行前执行增强逻辑；
 *  @EnableAspectJAutoProxy：表示开启 Spring AOP 的自动代理功能，会自动使用 JDK 动态代理；同时，由于没有 proxyTargetClass 参数（默认为 false ），所以此处使用 JDK 动态代理代理类。

#### 3.CGLIB与JDK动态代理的优缺点 ####

##### JDK动态代理 #####

JDK动态代理是指在运行时动态生成代理类，实现面向切面编程，并且只能代理实现了接口的类。在 Spring AOP 中，JDK 动态代理基于 InvocationHandler 进行 AOP 操作。  
**优点**

*  轻量级：JDK动态代理只需要通过反射调用方法，比CGLib更加轻量级；
 *  可扩展性：由于只针对接口生成代理类，因此支持类的动态加载，以及对新接口方法的支持，更具有扩展性；
 *  安全性：原始类和代理类之间只有接口的关系，不会动态生成类的子类，不存在类的继承关系，更加安全。

**缺点**

*  只能基于接口生成代理对象，无法对类进行代理；
 *  对目标类的要求较高，目标类必须实现接口。

##### CGLib #####

CGLib 全称是Code Generation Library，是二者中性能较高的一种代理方式，它通过动态生成目标类的子类，并在子类中拦截代理类的方法调用。  
**优点**

*  性能高: CGLib 采用了底层字节码技术进行代理，性能比 JDK 动态代理更高；
 *  无需实现接口: 目标类不需要实现接口，也能被代理，更加灵活。

**缺点**

*  不能代理 final 方法和 final 类;
 *  由于采用继承方式实现，可能会覆盖掉默认的构造函数，需要手动实现。

综上所述，JDK动态代理和CGLib各有其优点和缺点。**如果目标类已经实现了接口，建议采用 JDK 动态代理；如果目标类没有实现接口，采用 CGLib 会更合适。** 当然，如果没有特殊需求，采用默认的 JDK 动态代理也可以实现较好的 AOP 功能。