当前位置：首页 > article >正文

【手写一个spring】spring源码的简单实现--BeanPostProcessor(实现AOP)以及JDK动态代理/CGLIB动态代理

article 2024/11/24 11:49:00

文章目录

`BeanPostProcessor`概念
`BeanPostProcessor`接口中的两个方法
`BeanPostProcessor`的实例化与注册
`BeanPostProcessor`的执行时机
实现`AOP`
- 动态代理技术
- - `JDK`动态代理：
  - `CGLIB`动态代理：
- `JDK`动态代理和`CGLIB`动态代理的区别
- - `JDK`动态代理
  - `CGLIB`动态代理
  - 使用场景
  - 性能差异
  - 总结

`BeanPostProcessor`概念

BeanPostProcessor是Spring框架中一个非常重要的接口，它允许开发者在Bean的初始化前后对Bean实例进行自定义的修改和处理.

调用的阶段:在Bean对象初识化的前后

`BeanPostProcessor`接口中的两个方法

postProcessBeforeInitialization(Object bean, String beanName)：在Bean初始化方法调用之前执行。该方法允许开发者在Bean的初始化回调之前，对Bean实例进行自定义的处理。
postProcessAfterInitialization(Object bean, String beanName)：在Bean初始化方法调用之后执行。该方法允许开发者在Bean的初始化回调之后，对Bean实例进行进一步的自定义处理，如代理封装等。

`BeanPostProcessor`的实例化与注册

在Spring容器的启动过程中，Spring会自动检测所有实现了BeanPostProcessor接口的Bean定义，并将它们实例化。这些BeanPostProcessor实例会被注册到Spring容器的BeanFactory中，以便在后续的Bean创建过程中使用。

`BeanPostProcessor`的执行时机

当Spring容器创建了一个Bean实例后，会检查是否有BeanPostProcessor实例需要对该Bean进行处理。
如果有，Spring会先调用所有BeanPostProcessor的postProcessBeforeInitialization方法，允许开发者在Bean初始化之前对Bean进行修改。
接着，Spring会调用Bean的初始化方法（如实现了InitializingBean接口的afterPropertiesSet方法，或者在配置文件中指定的init-method）。
最后，Spring会调用所有BeanPostProcessor的postProcessAfterInitialization方法，允许开发者在Bean初始化之后对Bean进行进一步的修改。

自定义一个BeanPostProcessor接口:

/***
 *
 * bean的后置处理器
 * */
public interface BeanPostProcessor {
    /**
     * 前置
     * */
    public void postProcessBeforeInitializetion(String beanName,Object bean);
    
    /**
     * 后置
     * */
    public Object postProcessAfterInitializetion(String beanName, Object bean);
}

自定义一个类:BailLuBeanPostProcessor 对象实现这个接口:(并且,指定了userService执行接口逻辑)

@Component
public class BailLuBeanPostProcessor implements BeanPostProcessor {
    @Override
    public void postProcessBeforeInitializetion(String beanName, Object bean) {
        if("userService".equals(beanName)){
            System.out.println("bean对象初始化前--------");
        }
    }

    /***
     *
     * 后置处理器
     *
     * */

    public Object postProcessAfterInitializetion(String beanName, Object bean) {
        if("userService".equals(beanName)){
         System.out.println("bean对象初始化后-------");
        return bean;
    }
}

容器中调用该接口的时机:

		/**
       *存放实现了BeanPostProcessor接口的Bean对象
       * */
      private ArrayList<BeanPostProcessor> beanPostProcessorList=new ArrayList<>();
							
	  public BaiLuApplicationContext(Class configClass){
							Class<?> clazz = classLoader.loadClass(className);//传入全限定类名
                            if (clazz.isAnnotationPresent(Component.class)) {
                             
                                if(BeanPostProcessor.class.isAssignableFrom(clazz)){
                                    //说明该类实现了BeanPostProcessor接口
                                    BeanPostProcessor instance = (BeanPostProcessor) clazz.newInstance();
                                    beanPostProcessorList.add(instance);
                                }
      }

实现`AOP`

AOP（面向切面编程）的底层原理主要依赖于动态代理技术。这种技术允许开发者在不修改原有代码的情况下，为主干功能添加新的功能或行为。

动态代理技术

AOP底层主要使用两种动态代理技术：JDK动态代理和CGLIB动态代理。

`JDK`动态代理：

JDK动态代理是基于接口的动态代理技术。

Proxy.newProxyInstance 是 Java 中用于创建动态代理对象的方法。这个方法是 java.lang.reflect.Proxy 类的一部分，它允许你在运行时创建一个实现了指定接口的代理对象。这个代理对象会将方法调用转发给一个指定的调用处理器（InvocationHandler）。
当调用代理对象的方法时，实际上会调用InvocationHandler接口的invoke方法，从而可以在该方法中编写增强逻辑。
以下是 Proxy.newProxyInstance 方法的签名：
public static Object newProxyInstance(ClassLoader loader,
                                   Class<?>[] interfaces,
                                    InvocationHandler h)
参数:

ClassLoader loader：定义代理类的类加载器。通常，你可以使用目标类的类加载器来获取这个参数。
Class<?>[] interfaces：代理类要实现的接口列表。代理类将实现这些接口中声明的所有方法。
InvocationHandler h：调用处理器，当代理对象的方法被调用时，这个处理器的 invoke 方法会被调用。

以下是JDK动态代理实现AOP:

存在一个实现了UserInterface接口的实现类:

@Component("userService")
public class UserService implements UserInterface{

    @Autowird
    private OrderService orderService;
    
    public void test(){
        System.out.println("~~~考察AOP切面逻辑~~~");
    }

在后置处理器中生成代理对象proxyInstance

@Component
public class BailLuBeanPostProcessor implements BeanPostProcessor {
	/***
     *
     * 后置处理器
     *
     * */
    public Object postProcessAfterInitializetion(String beanName, Object bean) {

        if("userService".equals(beanName)){
            /*
             * 这里采用的是 JDK动态代理的方式生成代理对象的
             * @Param: proxyInstance--->JDK生成的代理对象,动态代理对象会去执行对象实现的接口
             * */
            Object proxyInstance = Proxy.newProxyInstance(BailLuBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    //这里是进行增强的逻辑
                    System.out.println("执行代理(切面)逻辑");
                    return method.invoke(bean,args);//这里是执行的接口中的逻辑
                }
            });
            return proxyInstance;
        }
        return bean;
    }
}

生成一个代理对象proxyInstance;
使用代理对象proxyInstance调用接口中的方法时,会调用invoke方法的逻辑;
在invoke方法中,对逻辑进行增强,并且调用invoke,实现对原本bean对象中接口的逻辑

`CGLIB`动态代理：

基于父类的动态代理技术，可以代理没有实现接口的类。
AOP（面向切面编程）使用CGLIB动态代理，主要是通过CGLIB库在运行时生成目标类的子类，并在子类中重写目标类的方法以插入额外的逻辑（即横切关注点）。

使用Enhancer类来创建代理对象。

通过设置父类（目标类）和回调（MethodInterceptor），当调用代理对象的方法时，会触发回调方法中的intercept方法，从而可以在该方法中编写增强逻辑。

`JDK`动态代理和`CGLIB`动态代理的区别

`JDK`动态代理

基于接口：JDK动态代理要求被代理的类必须实现一个或多个接口。代理对象会实现这些接口，并将方法调用委托给目标对象。
实现机制：使用Java反射机制来生成代理对象。代理对象会拦截接口中的方法调用，并通过InvocationHandler.invoke()方法执行额外的逻辑。

`CGLIB`动态代理

基于类：CGLIB动态代理通过生成目标类的子类来实现代理。它不要求目标类必须实现接口，因此适用于没有实现接口的类。
实现机制：使用ASM字节码生成框架来生成目标类的子类，并重写目标类的方法以实现代理逻辑。

使用场景

JDK动态代理:适用于接口驱动的编程模式。如果目标类实现了接口，并且希望保持简单的依赖关系，那么JDK动态代理是一个很好的选择。
在Spring AOP中，如果目标对象实现了接口，Spring默认使用JDK动态代理。
CGLIB动态代理:适用于目标类没有实现接口但需要代理的场景。例如，一些现有的类或者第三方库的类没有提供接口，此时可以使用CGLIB动态代理。
在Spring AOP中，如果目标对象没有实现任何接口，Spring AOP会自动使用CGLIB动态代理。

性能差异

JDK动态代理:对于实现了接口的类来说，JDK动态代理在创建代理对象时开销较小，因为它仅依赖反射机制来处理接口方法的调用。
对于频繁调用代理方法的场景，JDK动态代理可能比CGLIB略慢，因为每次调用都涉及反射。
CGLIB动态代理:由于CGLIB是通过字节码生成来创建代理类，生成代理类的开销比JDK动态代理高一些，尤其是在代理类较多的情况下。
但是，CGLIB代理的实际方法调用性能更高，因为它通过字节码操作减少了反射调用的开销。

总结

spring容器会在目标类实现了接口的时候,默认选择JDK动态代理;在目标类没有实现接口的时候,默认选择CGLIB动态代理;
CGLIB是基于字节码生成来创建代理类的,JDK动态代理是基于反射来创建代理类的,JDK生成代理类的开销相较于CGLIB相对较小;
CGLIB代理的实际方法的调用上性能更高,因为他是通过字节码操作减少了反射调用的开销;
CGLIB动态代理需要额外引入CGLIB库依赖,而JDK动态代理是JDK标准库中的一部分,无需引入额外的依赖.
final类和方法：CGLIB动态代理无法代理final类或final方法，因为这些类和方法无法被继承和重写。而JDK动态代理则没有这个问题，因为它只是代理接口中的方法。