重点标识
加载配置文件的两种方式,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);
}
结语
学海无涯,苦作舟。