BeanPostProcessor和Ordered

?abc!

于 2024-08-27 20:07:25 发布

阅读量529

点赞数 10

分类专栏： # Spring 文章标签： java

本文链接：https://blog.csdn.net/yyuggjggg/article/details/141576734

版权

Spring 专栏收录该内容

36 篇文章 2 订阅

订阅专栏

1. 概述

BeanPostProcessor 和 Ordered 接口用于在Spring容器初始化Bean的过程中进行自定义处理，并控制处理顺序

2. BeanPostProcessor

BeanPostProcessor 接口允许你在Spring容器初始化Bean的前后对Bean进行自定义处理。它有两个方法：

postProcessBeforeInitialization(Object bean, String beanName)：在Bean初始化之前调用。
postProcessAfterInitialization(Object bean, String beanName)：在Bean初始化之后调用。
- bean：容器正在创建的那个bean的引用；
- beanName：容器正在创建的那个bean的名称；

2.1 bean的生命周期

在这里插入图片描述

描述如下：

首先由Spring容器创建bean实例；
为bean的属性注入值；
若bean实现了各类Aware接口，则调用相应的set方法，
- 比如说，实现了BeanNameAware接口的bean，此时容器将调用bean的setBeanName方法，将bean的name作为参数；
- 实现了ApplicationContextAware接口的bean，此时容器将执行bean的setApplicationContext方法，将bean所在的上下文对象作为参数……
若容器中包含实现了BeanPostProcessor接口的bean，则此时将调用这些bean的postProcessBeforeInitialization方法，将当前正在创建的bean的引用以及bean的name作为参数传入；
若bean实现了InitializingBean接口，此时将调用bean的afterPropertiesSet方法；
若bean指定了自定义的初始化方法，比如说通过配置文件的init-method选项，则此时将执行这个自定义初始化方法；
若容器中包含实现了BeanPostProcessor接口的bean，则此时将调用这些bean的postProcessAfterInitialization方法，将当前正在创建的bean的引用以及bean的name作为参数传入；
- 可以在一个容器中注册多个不同的BeanPostProcessor的实现类对象，而bean在创建的过程中，将会轮流执行这些对象实现的before和after方法
- 执行顺序通过BeanPostProcessor的实现类实现这个Ordered接口，并实现接口的getOrder方法
这个时候，bean就算是初始化完毕，可以被使用了，在容器销毁之前，这个对象将一直保存在容器中；
若bean实现了DisposableBean接口，则在容器销毁时，会调用bean的destroy方法；
如果bean定义了自定义的销毁方法，则在容器销毁时，会调用这个自定义的销毁方法；
容器销毁成功，bean也被回收

2.2 使用注意

2.2.1 BeanPostProcessor依赖的bean，不会执行BeanPostProcessor的方法

当我们在BeanPostProcessor的实现类中，依赖了其他的bean，
那么被依赖的bean被创建时，将不会执行它所在的BeanPostProcessor实现类实现的方法，

比如我们修改PostBean的实现，如下所示：

容器在创建User这个bean时，不会执行PostBean实现的两个方法，
因为由于PostBean依赖于user，所以user需要在PostBean之前创建完成，
这也就意味着在user创建时，PostBean还未初始化完成，所以不会调用它的方法。

@Component
public class PostBean implements BeanPostProcessor, Ordered {
    // 让PostBean依赖User
    @Autowired
    private User user;

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) 
        throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) 
        throws BeansException {
        return bean;
    }
}

2.2.2 BeanPostProcessor以及依赖的bean无法使用AOP

Spring的AOP代理就是作为BeanPostProcessor实现的，

所以我们无法对BeanPostProcessor的实现类使用AOP织入通知，

也无法对BeanPostProcessor的实现类依赖的bean使用AOP织入通知。

2.3 将BeanPostProcessor注册到Spring容器中

2.3.1 @Component注解

使用@Component注解：在实现类上添加@Component注解，这样Spring会自动扫描并注册这个bean。

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    // 实现方法
}

2.3.2 使用@Bean配置BeanPostProcessor的限制

使用Java配置类：如果你使用的是Java配置类，可以在配置类中注册这个bean。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public MyBeanPostProcessor myBeanPostProcessor() {
        return new MyBeanPostProcessor();
    }
}

示例如下：


/**
 * 此BeanPostProcessor的实现类，还实现了Ordered接口
 */
public class PostBean implements BeanPostProcessor, Ordered {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("before -- " + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("after -- " + beanName);
        return bean;
    }

    @Override
    public int getOrder() {
        return 0;
    }
}

在配置类中，声明PostBean可以有以下几种方式

只有第一种和第二种方式，会让Spring容器将PostBean当作BeanPostProcessor处理
而第三种方式，则会被当作一个普通Bean处理，实现BeanPostProcessor的两个方法都不会被调用，
- 因为在PostBean的继承体系中，Ordered和BeanPostProcessor是同级别的，
- Spring无法识别出这个Ordered对象，也是一个BeanPostProcessor对象；
- 但是使用PostBean却可以，因为PostBean类型就是BeanPostProcessor的子类型
- 所以，在使用@Bean声明工厂方法返回BeanPostProcessor实现类对象时，返回值必须是BeanPostProcessor类型，或者更低级的类型。
```
@Configuration
public class BeanConfig {

    // 方式1：PostBean
    @Bean
    public PostBean postBean() {
        return new PostBean();
    }

    // 方式2：返回值为BeanPostProcessor
    @Bean
    public BeanPostProcessor postBean() {
        return new PostBean();
    }

    // 方式3：返回值为Ordered
    @Bean
    public Ordered postBean() {
        return new PostBean();
    }
}
```

2.3.3 spring.factories

创建 BeanPostProcessor 实现类：

首先，创建一个实现 BeanPostProcessor 接口的类。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyAutoConfiguration {

    @Bean
    public MyBeanPostProcessor myBeanPostProcessor() {
        return new MyBeanPostProcessor();
    }
}

创建自动配置类：创建一个自动配置类，并在其中定义 BeanPostProcessor 的 @Bean 方法

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyAutoConfiguration {

    @Bean
    public MyBeanPostProcessor myBeanPostProcessor() {
        return new MyBeanPostProcessor();
    }
}

创建 spring.factories 文件：在 src/main/resources/META-INF/ 目录下创建 spring.factories 文件，并在其中添加自动配置类的全限定名

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.MyAutoConfiguration

目录结构

src/main/java/
    com/example/
        MyBeanPostProcessor.java
        MyAutoConfiguration.java
src/main/resources/
    META-INF/
        spring.factories

2.3.4 Xml

在XML中注册这个bean。

<bean id="myBeanPostProcessor" class="com.example.MyBeanPostProcessor"/>

3. Order

Ordered 接口用于控制多个 BeanPostProcessor 的执行顺序。它有一个方法：

getOrder()：返回一个整数值，表示处理器的顺序。值越小，优先级越高。

4. 多个 BeanPostProcessor 的顺序

如果有多个 BeanPostProcessor，可以通过实现 Ordered 接口来控制它们的执行顺序。值越小，优先级越高。

5. 举例

自定义Bean后处理器

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;

@Component
public class CustomBeanPostProcessor implements BeanPostProcessor, Ordered {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof MyService) {
            System.out.println("Before Initialization: " + beanName);
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof MyService) {
            System.out.println("After Initialization: " + beanName);
        }
        return bean;
    }

    @Override
    public int getOrder() {
        return 1; // 优先级，值越小优先级越高
    }
}

服务类

import org.springframework.stereotype.Service;

@Service
public class MyService {
    public void serve() {
        System.out.println("Service method executed");
    }
}

主类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

另一个自定义Bean后处理器

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;

@Component
public class AnotherBeanPostProcessor implements BeanPostProcessor, Ordered {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof MyService) {
            System.out.println("Another Before Initialization: " + beanName);
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof MyService) {
            System.out.println("Another After Initialization: " + beanName);
        }
        return bean;
    }

    @Override
    public int getOrder() {
        return 2; // 优先级，值越小优先级越高
    }
}

运行示例

Before Initialization: myService
Another Before Initialization: myService
After Initialization: myService
Another After Initialization: myService
Service method executed