Spring(学习笔记)-配置文件与后置处理器！

重点标识

加载配置文件的两种方式，Java配置与Xml配置

后置处理器，简单说明下Bean的生成过程。

对Bean信息修改，在BeanDefintion这里可以修改，是它的后置处理器，即Bean未创建出来，修改后直接影响生成的Bean（BeanFactoryPostProcessor对bean进行修改）

BeanPostProcessor（Bean后置处理器），拿到bean之后再进行修改。

配置文件注入

准备工作，新建一个Datasource类，以及要注入的db文件，如下

public class DatsSource {
    private String url;
    private String username;
    private String password;
    public DatsSource() {
    }
    @Override
    public String toString() {
        return "DatsSource{" +
                "url='" + url + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
    public DatsSource(String url, String username, String password) {
        this.url = url;
        this.username = username;
        this.password = password;
    }
}

db文件如下：db,properties，注意，这个一般放在resource下面：

db.url=jdbc://dev
db.username=root
db.password=123456

Java配置加载配置文件

@Configuration
@PropertySource("classpath:db.properties")
public class JavaConfig {

    @Value("${db.username}")
    String username;
    @Value("${db.password}")
    String url;
    @Value("${db.password}")
    String password;

    @Bean
    DatsSource datsSource(){
        DatsSource datsSource = new DatsSource(url,username,password);
        return datsSource;
    }

}

测试如下：

 public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(JavaConfig.class);
        DatsSource bean = annotationConfigApplicationContext.getBean(DatsSource.class);
        System.out.println(bean);
    }

Xml加载配置文件

<context:property-placeholder location="classpath:db.properties"/>

    <bean class="org.tongzhou.DatsSource" id="datsSource">
        <constructor-arg name="url" value="${db.url}"/>
        <constructor-arg name="username" value="${db.username}"/>
        <constructor-arg name="password" value="${db.password}"/>
    </bean>

测试如下：

 public static void main(String[] args) {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        DatsSource bean = classPathXmlApplicationContext.getBean(DatsSource.class);
        System.out.println(bean);
    }

后置处理器

bean的生成过程，这里注意，是在bean生成后进行加载的，准备代码

BeanPostProcessor

public class User implements InitializingBean {
    private String username;
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                '}';
    }

    public void init(){
        System.out.println("user init");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("user afterPropertiesSet");
    }
}

接下来，我们准备一个MyBeanPostProcessor，来进行修改，这里要注意，每一个Bean加载，都会进入这个方法，所以我们可以根据不同的Bean id来进行定制化，想要改的Bean，进行修改。

public class MyBeanPostProcessor implements org.springframework.beans.factory.config.BeanPostProcessor {

    /**
     * 这两个方法是在bean初始化方法之前和之后加载的，即init-method方法和       
     * afterPropertiesSet方法
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
     if(beanName.equals("user")){
         User bean1 = (User) bean;
         bean1.setUsername("tongzhou");
         return bean1;

     }

        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

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

最后，别忘了在xml中进行配置，实际上就是将MyBeanPostProcessor注入到Spring容器中。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
   <bean class="org.tongzhou.User" id="user" init-method="init"/>
   <bean class="org.tongzhou.MyBeanPostProcessor"/>
</beans>

最后调用，大功告成：

 public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        User bean = context.getBean(User.class);
        System.out.println(bean);
    }

BeanFactoryPostProcessor

这个是在Bean未生成的时候进行修改的，所以不涉及前后。这个会在前面说的BeanPostProcessor前执行。并且只执行一次，可以理解为spring容器的后置处理器，配置文件加载的所有Bean都在这里面。

简单解释一下，下面的代码，getBeanDefinition，获取到想要的Bean，他还有一个getBeanDefinitions，就是获取到所有的Bean，可以进行遍历。
注意，在这里getbean的时候，Bean还没有生成，但是我们调用了getbean方法,就会现场生成一个，提前初始化Bean。
正常来说，Spring容器初始化后，Bean就初始化了，但是这个地方的bean比Spring容器初始化的更早。
BeanDefinitionVisitor 读取Bean中的内容，并且还可以进行修改。

代码准备

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    /**
     * 只有一个方法，相当于Spring容器
     *
     * @param beanFactory
     * @throws BeansException
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

        BeanDefinition user = beanFactory.getBeanDefinition("user");

        BeanDefinitionVisitor visitor = new BeanDefinitionVisitor(strVal -> {

            if (strVal.equals("tongzhou")) {
                return "tongzhou123";
            }
            return strVal;
        });
       visitor.visitBeanDefinition(user);
    }
}

别忘了，注入到Spring容器中。

  <bean class="org.tongzhou.User" id="user">
          <property name="username" value="tongzhou"/>
      </bean>

    <bean class="org.tongzhou.MyBeanFactoryPostProcessor" />

我们看看源码，加深一下理解，
这里有一个经典的例子，就是前面的DataSource注入：
进入到BeanFactoryPostProcessor接口中，查看他的实现方法

PostProcessBeanFactory这个方法里面执行了processProperties这个方法，j进去看一下,就会发现，this.placeholderPrefix这个就是${的处理，后面的和我上面写的差不多，都是使用visitBeanDefinition读取bean的值，并进行修改，这就是Bean的后置处理器，可以提前初始化Bean。

    protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, final ConfigurablePropertyResolver propertyResolver) throws BeansException {
        propertyResolver.setPlaceholderPrefix(this.placeholderPrefix);
        propertyResolver.setPlaceholderSuffix(this.placeholderSuffix);
        propertyResolver.setValueSeparator(this.valueSeparator);
        StringValueResolver valueResolver = (strVal) -> {
            String resolved = this.ignoreUnresolvablePlaceholders ? propertyResolver.resolvePlaceholders(strVal) : propertyResolver.resolveRequiredPlaceholders(strVal);
            if (this.trimValues) {
                resolved = resolved.trim();
            }

            return resolved.equals(this.nullValue) ? null : resolved;
        };
        this.doProcessProperties(beanFactoryToProcess, valueResolver);
    }

结语

学海无涯，苦作舟。