我想挑战下个人软肋，动手实现个Spring应用上下文！
做者：小傅哥
博客：https://bugstack.cnhtml
沉淀、分享、成长，让本身和他人都能有所收获！😄
目录
- [x] 第 1 章：开篇介绍，我要带你撸 Spring 啦！
- [x] 第 2 章：小试牛刀，实现一个简单的Bean容器
- [x] 第 3 章：初显身手，运用设计模式，实现 Bean 的定义、注册、获取
- [x] 第 4 章：崭露头角，基于Cglib实现含构造函数的类实例化策略
- [x] 第 5 章：一举成名，为Bean对象注入属性和依赖Bean的功能实现
- [x] 第 6 章：气吞山河，设计与实现资源加载器，从Spring.xml解析和注册Bean对象
- [x] 第 7 章：所向披靡，实现应用上下文，自动识别、资源加载、扩展机制
- [ ] 第 8 章：待归档...
1、前言
你这代码，可不能写死了呀！java
依照项目落地经验来看，咱们在承接紧急的产品需求时候，一般会选择在原有同类项目中进行扩展，若是没有相关类型项目的储备，也可能会选择临时搭建出一个工程来实现产品的需求。但这个时候就会遇到很是现实的问题，选择完整的设计和开发就可能知足不了上线时间，临时拼凑式的完成需求又可能不具有上线后响应产品的临时调整。面试
上线后的调整有哪些呢？项目刚一上线，运营了还不到半天，老板发现本身的配置的活动好像金额配置的过小了，用户都不来，割不到韭菜呀。赶忙半夜联系产品，来来来，你给我这改改，那修修，把人均优惠1万元放大大的，把可能两字缩小放在后面。再把优惠的奖金池配置从10元调整11元，快快快，赶忙修改，你修改了我们能赚1个亿！！！spring
好家伙，项目是临时开发堆出来的，没有后台系统、没有配置中心、没有模块拆分，老板一句句改改改，产品来传达催促，最后背锅的可就是研发了。你这不能写死，这优惠配置得抽出来，这文案也后台下发吧，这接口入参也写死了，再写一个新接口吧！ 一顿操做猛如虎，研发搬砖修接口，运营折腾好几宿，最后PV150！数据库
不管业务、产品、运营如何，但就研发自身来说，尽量的要不避免临时堆出一个服务来，尤为是在团队建设初期或者运营思路常常调整的状况下，更要注重设计细节和实现方案。哪怕去报风险延期，也不要让本身背上一个明知是烂坑还要接的活。设计模式
而本章节说到不把代码写死，就是由于咱们须要继续在手写 Spring 框架中继续扩展新的功能，如一个Bean的定义和实例化的过程先后，是否能够知足咱们进行自定义扩展，对Bean对象执行一些修改、加强、记录等操做呢？ 这个过程基本就是你在使用 Spring 容器框架时候作的一些中间件扩展开发。架构
2、目标
若是你在本身的实际工做中开发过基于 Spring 的技术组件，或者学习过关于 SpringBoot 中间件设计和开发 等内容。那么你必定会继承或者实现了 Spring 对外暴露的类或接口，在接口的实现中获取了 BeanFactory 以及 Bean 对象的获取等内容，并对这些内容作一些操做，例如：修改 Bean 的信息，添加日志打印、处理数据库路由对数据源的切换、给 RPC 服务链接注册中心等。app
在对容器中 Bean 的实例化过程添加扩展机制的同时，还须要把目前关于 Spring.xml 初始化和加载策略进行优化，由于咱们不太可能让面向 Spring 自己开发的 DefaultListableBeanFactory 服务，直接给予用户使用。修改点以下：框架
- DefaultListableBeanFactory、XmlBeanDefinitionReader，是咱们在目前 Spring 框架中对于服务功能测试的使用方式，它能很好的体现出 Spring 是如何对 xml 加载以及注册Bean对象的操做过程，但这种方式是面向 Spring 自己的，还不具有必定的扩展性。
- 就像咱们如今须要提供出一个能够在 Bean 初始化过程当中，完成对 Bean 对象的扩展时，就很难作到自动化处理。因此咱们要把 Bean 对象扩展机制功能和对 Spring 框架上下文的包装融合起来，对外提供完整的服务。
3、设计
为了能知足于在 Bean 对象从注册到实例化的过程当中执行用户的自定义操做，就须要在 Bean 的定义和初始化过程当中插入接口类，这个接口再有外部去实现本身须要的服务。那么在结合对 Spring 框架上下文的处理能力，就能够知足咱们的目标需求了。总体设计结构以下图：ide
- 知足于对 Bean 对象扩展的两个接口，其实也是 Spring 框架中很是具备重量级的两个接口：
BeanFactoryPostProcess和BeanPostProcessor，也几乎是你们在使用 Spring 框架额外新增开发本身组建需求的两个必备接口。 - BeanFactoryPostProcessor，是由 Spring 框架组建提供的容器扩展机制，容许在 Bean 对象注册后但未实例化以前，对 Bean 的定义信息
BeanDefinition执行修改操做。 - BeanPostProcessor，也是 Spring 提供的扩展机制，不过 BeanPostProcessor 是在 Bean 对象实例化以后修改 Bean 对象，也能够替换 Bean 对象。这部分与后面要实现的 AOP 有着密切的关系。
- 同时若是只是添加这两个接口，不作任何包装，那么对于使用者来讲仍是很是麻烦的。咱们但愿于开发 Spring 的上下文操做类，把相应的 XML 加载 、注册、实例化以及新增的修改和扩展都融合进去，让 Spring 能够自动扫描到咱们的新增服务，便于用户使用。
4、实现
1. 工程结构
small-spring-step-06
└── src
├── main
│ └── java
│ └── cn.bugstack.springframework
│ ├── beans
│ │ ├── factory
│ │ │ ├── factory
│ │ │ │ ├── AutowireCapableBeanFactory.java
│ │ │ │ ├── BeanDefinition.java
│ │ │ │ ├── BeanFactoryPostProcessor.java
│ │ │ │ ├── BeanPostProcessor.java
│ │ │ │ ├── BeanReference.java
│ │ │ │ ├── ConfigurableBeanFactory.java
│ │ │ │ └── SingletonBeanRegistry.java
│ │ │ ├── support
│ │ │ │ ├── AbstractAutowireCapableBeanFactory.java
│ │ │ │ ├── AbstractBeanDefinitionReader.java
│ │ │ │ ├── AbstractBeanFactory.java
│ │ │ │ ├── BeanDefinitionReader.java
│ │ │ │ ├── BeanDefinitionRegistry.java
│ │ │ │ ├── CglibSubclassingInstantiationStrategy.java
│ │ │ │ ├── DefaultListableBeanFactory.java
│ │ │ │ ├── DefaultSingletonBeanRegistry.java
│ │ │ │ ├── InstantiationStrategy.java
│ │ │ │ └── SimpleInstantiationStrategy.java
│ │ │ ├── support
│ │ │ │ └── XmlBeanDefinitionReader.java
│ │ │ ├── BeanFactory.java
│ │ │ ├── ConfigurableListableBeanFactory.java
│ │ │ ├── HierarchicalBeanFactory.java
│ │ │ └── ListableBeanFactory.java
│ │ ├── BeansException.java
│ │ ├── PropertyValue.java
│ │ └── PropertyValues.java
│ ├── context
│ │ ├── support
│ │ │ ├── AbstractApplicationContext.java
│ │ │ ├── AbstractRefreshableApplicationContext.java
│ │ │ ├── AbstractXmlApplicationContext.java
│ │ │ └── ClassPathXmlApplicationContext.java
│ │ ├── ApplicationContext.java
│ │ └── ConfigurableApplicationContext.java
│ ├── core.io
│ │ ├── ClassPathResource.java
│ │ ├── DefaultResourceLoader.java
│ │ ├── FileSystemResource.java
│ │ ├── Resource.java
│ │ ├── ResourceLoader.java
│ │ └── UrlResource.java
│ └── utils
│ └── ClassUtils.java
└── test
└── java
└── cn.bugstack.springframework.test
├── bean
│ ├── UserDao.java
│ └── UserService.java
├── common
│ ├── MyBeanFactoryPostProcessor.java
│ └── MyBeanPostProcessor.java
└── ApiTest.java
工程源码：公众号「bugstack虫洞栈」，回复：Spring 专栏，获取完整源码
Spring 应用上下文和对Bean对象扩展机制的类关系，如图 7-3
- 在整个类图中主要体现出来的是关于 Spring 应用上下文以及对 Bean 对象扩展机制的实现。
- 以继承了 ListableBeanFactory 接口的 ApplicationContext 接口开始，扩展出一系列应用上下文的抽象实现类，并最终完成
ClassPathXmlApplicationContext类的实现。而这个类就是最后交给用户使用的类。 - 同时在实现应用上下文的过程当中，经过定义接口：
BeanFactoryPostProcessor、BeanPostProcessor两个接口，把关于对 Bean 的扩展机制串联进去了。
2. 定义 BeanFactoryPostProcessor
cn.bugstack.springframework.beans.factory.config.BeanFactoryPostProcessor
public interface BeanFactoryPostProcessor {
/**
* 在全部的 BeanDefinition 加载完成后，实例化 Bean 对象以前，提供修改 BeanDefinition 属性的机制
*
* @param beanFactory
* @throws BeansException
*/
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}
- 在 Spring 源码中有这样一段描述
Allows for custom modification of an application context's bean definitions,adapting the bean property values of the context's underlying bean factory.其实也就是说这个接口是知足于在全部的 BeanDefinition 加载完成后，实例化 Bean 对象以前，提供修改 BeanDefinition 属性的机制。
3. 定义 BeanPostProcessor
cn.bugstack.springframework.beans.factory.config.BeanPostProcessor
public interface BeanPostProcessor {
/**
* 在 Bean 对象执行初始化方法以前，执行此方法
*
* @param bean
* @param beanName
* @return
* @throws BeansException
*/
Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
/**
* 在 Bean 对象执行初始化方法以后，执行此方法
*
* @param bean
* @param beanName
* @return
* @throws BeansException
*/
Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}
- 在 Spring 源码中有这样一段描述
Factory hook that allows for custom modification of new bean instances,e.g. checking for marker interfaces or wrapping them with proxies.也就是提供了修改新实例化 Bean 对象的扩展点。 - 另外此接口提供了两个方法：
postProcessBeforeInitialization用于在 Bean 对象执行初始化方法以前，执行此方法、postProcessAfterInitialization用于在 Bean 对象执行初始化方法以后，执行此方法。
4. 定义上下文接口
cn.bugstack.springframework.context.ApplicationContext
public interface ApplicationContext extends ListableBeanFactory {
}
- context 是本次实现应用上下文功能新增的服务包
- ApplicationContext，继承于 ListableBeanFactory，也就继承了关于 BeanFactory 方法，好比一些 getBean 的方法。另外 ApplicationContext 自己是 Central 接口，但目前还不须要添加一些获取ID和父类上下文，因此暂时没有接口方法的定义。
cn.bugstack.springframework.context.ConfigurableApplicationContext
public interface ConfigurableApplicationContext extends ApplicationContext {
/**
* 刷新容器
*
* @throws BeansException
*/
void refresh() throws BeansException;
}
- ConfigurableApplicationContext 继承自 ApplicationContext，并提供了 refresh 这个核心方法。若是你有看过一些 Spring 源码，那么必定会看到这个方法。 接下来也是须要在上下文的实现中完成刷新容器的操做过程。
5. 应用上下文抽象类实现
cn.bugstack.springframework.context.support.AbstractApplicationContext
public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
@Override
public void refresh() throws BeansException {
// 1. 建立 BeanFactory，并加载 BeanDefinition
refreshBeanFactory();
// 2. 获取 BeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 3. 在 Bean 实例化以前，执行 BeanFactoryPostProcessor (Invoke factory processors registered as beans in the context.)
invokeBeanFactoryPostProcessors(beanFactory);
// 4. BeanPostProcessor 须要提早于其余 Bean 对象实例化以前执行注册操做
registerBeanPostProcessors(beanFactory);
// 5. 提早实例化单例Bean对象
beanFactory.preInstantiateSingletons();
}
protected abstract void refreshBeanFactory() throws BeansException;
protected abstract ConfigurableListableBeanFactory getBeanFactory();
private void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
Map<String, BeanFactoryPostProcessor> beanFactoryPostProcessorMap = beanFactory.getBeansOfType(BeanFactoryPostProcessor.class);
for (BeanFactoryPostProcessor beanFactoryPostProcessor : beanFactoryPostProcessorMap.values()) {
beanFactoryPostProcessor.postProcessBeanFactory(beanFactory);
}
}
private void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
Map<String, BeanPostProcessor> beanPostProcessorMap = beanFactory.getBeansOfType(BeanPostProcessor.class);
for (BeanPostProcessor beanPostProcessor : beanPostProcessorMap.values()) {
beanFactory.addBeanPostProcessor(beanPostProcessor);
}
}
//... getBean、getBeansOfType、getBeanDefinitionNames 方法
}
- AbstractApplicationContext 继承 DefaultResourceLoader 是为了处理
spring.xml配置资源的加载。 以后是在 refresh() 定义实现过程，包括：
-
- 建立 BeanFactory，并加载 BeanDefinition
-
- 获取 BeanFactory
-
- 在 Bean 实例化以前，执行 BeanFactoryPostProcessor (Invoke factory processors registered as beans in the context.)
-
- BeanPostProcessor 须要提早于其余 Bean 对象实例化以前执行注册操做
-
- 提早实例化单例Bean对象
-
- 另外把定义出来的抽象方法，refreshBeanFactory()、getBeanFactory() 由后面的继承此抽象类的其余抽象类实现。
6. 获取Bean工厂和加载资源
cn.bugstack.springframework.context.support.AbstractRefreshableApplicationContext
public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
private DefaultListableBeanFactory beanFactory;
@Override
protected void refreshBeanFactory() throws BeansException {
DefaultListableBeanFactory beanFactory = createBeanFactory();
loadBeanDefinitions(beanFactory);
this.beanFactory = beanFactory;
}
private DefaultListableBeanFactory createBeanFactory() {
return new DefaultListableBeanFactory();
}
protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory);
@Override
protected ConfigurableListableBeanFactory getBeanFactory() {
return beanFactory;
}
}
- 在 refreshBeanFactory() 中主要是获取了
DefaultListableBeanFactory的实例化以及对资源配置的加载操做loadBeanDefinitions(beanFactory)，在加载完成后便可完成对 spring.xml 配置文件中 Bean 对象的定义和注册，同时也包括实现了接口 BeanFactoryPostProcessor、BeanPostProcessor 的配置 Bean 信息。 - 但此时资源加载还只是定义了一个抽象类方法
loadBeanDefinitions(DefaultListableBeanFactory beanFactory)，继续由其余抽象类继承实现。
7. 上下文中对配置信息的加载
cn.bugstack.springframework.context.support.AbstractXmlApplicationContext
public abstract class AbstractXmlApplicationContext extends AbstractRefreshableApplicationContext {
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) {
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory, this);
String[] configLocations = getConfigLocations();
if (null != configLocations){
beanDefinitionReader.loadBeanDefinitions(configLocations);
}
}
protected abstract String[] getConfigLocations();
}
- 在 AbstractXmlApplicationContext 抽象类的 loadBeanDefinitions 方法实现中，使用 XmlBeanDefinitionReader 类，处理了关于 XML 文件配置信息的操做。
- 同时这里又留下了一个抽象类方法，getConfigLocations()，此方法是为了从入口上下文类，拿到配置信息的地址描述。
8. 应用上下文实现类(ClassPathXmlApplicationContext)
cn.bugstack.springframework.context.support.ClassPathXmlApplicationContext
public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
private String[] configLocations;
public ClassPathXmlApplicationContext() {
}
/**
* 从 XML 中加载 BeanDefinition，并刷新上下文
*
* @param configLocations
* @throws BeansException
*/
public ClassPathXmlApplicationContext(String configLocations) throws BeansException {
this(new String[]{configLocations});
}
/**
* 从 XML 中加载 BeanDefinition，并刷新上下文
* @param configLocations
* @throws BeansException
*/
public ClassPathXmlApplicationContext(String[] configLocations) throws BeansException {
this.configLocations = configLocations;
refresh();
}
@Override
protected String[] getConfigLocations() {
return configLocations;
}
}
- ClassPathXmlApplicationContext，是具体对外给用户提供的应用上下文方法。
- 在继承了 AbstractXmlApplicationContext 以及层层抽象类的功能分离实现后，在此类 ClassPathXmlApplicationContext 的实现中就简单多了，主要是对继承抽象类中方法的调用和提供了配置文件地址信息。
9. 在Bean建立时完成前置和后置处理
cn.bugstack.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();
@Override
protected Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) throws BeansException {
Object bean = null;
try {
bean = createBeanInstance(beanDefinition, beanName, args);
// 给 Bean 填充属性
applyPropertyValues(beanName, bean, beanDefinition);
// 执行 Bean 的初始化方法和 BeanPostProcessor 的前置和后置处理方法
bean = initializeBean(beanName, bean, beanDefinition);
} catch (Exception e) {
throw new BeansException("Instantiation of bean failed", e);
}
addSingleton(beanName, bean);
return bean;
}
public InstantiationStrategy getInstantiationStrategy() {
return instantiationStrategy;
}
public void setInstantiationStrategy(InstantiationStrategy instantiationStrategy) {
this.instantiationStrategy = instantiationStrategy;
}
private Object initializeBean(String beanName, Object bean, BeanDefinition beanDefinition) {
// 1. 执行 BeanPostProcessor Before 处理
Object wrappedBean = applyBeanPostProcessorsBeforeInitialization(bean, beanName);
// 待完成内容：invokeInitMethods(beanName, wrappedBean, beanDefinition);
invokeInitMethods(beanName, wrappedBean, beanDefinition);
// 2. 执行 BeanPostProcessor After 处理
wrappedBean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
return wrappedBean;
}
private void invokeInitMethods(String beanName, Object wrappedBean, BeanDefinition beanDefinition) {
}
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessBeforeInitialization(result, beanName);
if (null == current) return result;
result = current;
}
return result;
}
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (null == current) return result;
result = current;
}
return result;
}
}
- 实现 BeanPostProcessor 接口后，会涉及到两个接口方法，
postProcessBeforeInitialization、postProcessAfterInitialization，分别做用于 Bean 对象执行初始化先后的额外处理。 - 也就是须要在建立 Bean 对象时，在 createBean 方法中添加
initializeBean(beanName, bean, beanDefinition);操做。而这个操做主要主要是对于方法applyBeanPostProcessorsBeforeInitialization、applyBeanPostProcessorsAfterInitialization的使用。 - 另外须要提一下，applyBeanPostProcessorsBeforeInitialization、applyBeanPostProcessorsAfterInitialization 两个方法是在接口类
AutowireCapableBeanFactory中新增长的。
5、测试
1. 事先准备
cn.bugstack.springframework.test.bean.UserDao
public class UserDao {
private static Map<String, String> hashMap = new HashMap<>();
static {
hashMap.put("10001", "小傅哥");
hashMap.put("10002", "八杯水");
hashMap.put("10003", "阿毛");
}
public String queryUserName(String uId) {
return hashMap.get(uId);
}
}
cn.bugstack.springframework.test.bean.UserService
public class UserService {
private String uId;
private String company;
private String location;
private UserDao userDao;
public void queryUserInfo() {
return userDao.queryUserName(uId);
}
// ...get/set
}
- Dao、Service，是咱们日常开发常用的场景。在 UserService 中注入 UserDao，这样就能体现出Bean属性的依赖了。
- 另外这里新增长了 company、location，两个属性信息，便于测试 BeanPostProcessor、BeanFactoryPostProcessor 两个接口对 Bean 属性信息扩展的做用。
2. 实现 BeanPostProcessor 和 BeanFactoryPostProcessor
cn.bugstack.springframework.test.common.MyBeanFactoryPostProcessor
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
BeanDefinition beanDefinition = beanFactory.getBeanDefinition("userService");
PropertyValues propertyValues = beanDefinition.getPropertyValues();
propertyValues.addPropertyValue(new PropertyValue("company", "改成：字节跳动"));
}
}
cn.bugstack.springframework.test.common.MyBeanPostProcessor
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if ("userService".equals(beanName)) {
UserService userService = (UserService) bean;
userService.setLocation("改成：北京");
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
}
- 若是你在 Spring 中作过一些组件的开发那么必定很是熟悉这两个类，本文的测试也是实现了这两个类，对实例化过程当中的 Bean 对象作一些操做。
3. 配置文件
基础配置，无BeanFactoryPostProcessor、BeanPostProcessor，实现类
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="userDao" class="cn.bugstack.springframework.test.bean.UserDao"/>
<bean id="userService" class="cn.bugstack.springframework.test.bean.UserService">
<property name="uId" value="10001"/>
<property name="company" value="腾讯"/>
<property name="location" value="深圳"/>
<property name="userDao" ref="userDao"/>
</bean>
</beans>
加强配置，有BeanFactoryPostProcessor、BeanPostProcessor，实现类
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="userDao" class="cn.bugstack.springframework.test.bean.UserDao"/>
<bean id="userService" class="cn.bugstack.springframework.test.bean.UserService">
<property name="uId" value="10001"/>
<property name="company" value="腾讯"/>
<property name="location" value="深圳"/>
<property name="userDao" ref="userDao"/>
</bean>
<bean class="cn.bugstack.springframework.test.common.MyBeanPostProcessor"/>
<bean class="cn.bugstack.springframework.test.common.MyBeanFactoryPostProcessor"/>
</beans>
- 这里提供了两个配置文件，一个是不包含BeanFactoryPostProcessor、BeanPostProcessor，另一个是包含的。之因此这样配置主要对照验证，在运用 Spring 新增长的应用上下文和不使用的时候，都是怎么操做的。
4. 不用应用上下文
@Test
public void test_BeanFactoryPostProcessorAndBeanPostProcessor(){
// 1.初始化 BeanFactory
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
// 2. 读取配置文件&注册Bean
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
reader.loadBeanDefinitions("classpath:spring.xml");
// 3. BeanDefinition 加载完成 & Bean实例化以前，修改 BeanDefinition 的属性值
MyBeanFactoryPostProcessor beanFactoryPostProcessor = new MyBeanFactoryPostProcessor();
beanFactoryPostProcessor.postProcessBeanFactory(beanFactory);
// 4. Bean实例化以后，修改 Bean 属性信息
MyBeanPostProcessor beanPostProcessor = new MyBeanPostProcessor();
beanFactory.addBeanPostProcessor(beanPostProcessor);
// 5. 获取Bean对象调用方法
UserService userService = beanFactory.getBean("userService", UserService.class);
String result = userService.queryUserInfo();
System.out.println("测试结果：" + result);
}
- DefaultListableBeanFactory 建立 beanFactory 并使用 XmlBeanDefinitionReader 加载配置文件的方式，仍是比较熟悉的。
- 接下来就是对 MyBeanFactoryPostProcessor 和 MyBeanPostProcessor 的处理，一个是在BeanDefinition 加载完成 & Bean实例化以前，修改 BeanDefinition 的属性值，另一个是在Bean实例化以后，修改 Bean 属性信息。
测试结果
测试结果：小傅哥,改成：字节跳动,改成：北京 Process finished with exit code 0
- 经过测试结果能够看到，咱们配置的属性信息已经与 spring.xml 配置文件中不同了。
5. 使用应用上下文
@Test
public void test_xml() {
// 1.初始化 BeanFactory
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:springPostProcessor.xml");
// 2. 获取Bean对象调用方法
UserService userService = applicationContext.getBean("userService", UserService.class);
String result = userService.queryUserInfo();
System.out.println("测试结果：" + result);
}
- 另外使用新增长的 ClassPathXmlApplicationContext 应用上下文类，再操做起来就方便多了，这才是面向用户使用的类，在这里能够一步把配置文件交给 ClassPathXmlApplicationContext，也不须要管理一些自定义实现的 Spring 接口的类。
测试结果
测试结果：小傅哥,改成：字节跳动,改成：北京 Process finished with exit code 0
- 这与不用应用上下文的测试结果是同样，不过如今的方式更加方便了。
6、总结
- 本文主要新增了 Spring 框架中两个很是重要的接口 BeanFactoryPostProcess、BeanPostProcessor 同时还添加了关于应用上下文的实现，ApplicationContext 接口的定义是继承 BeanFactory 外新增长功能的接口，它能够知足于自动识别、资源加载、容器事件、监听器等功能，同时例如一些国际化支持、单例Bean自动初始化等，也是能够在这个类里实现和扩充的。
- 经过本文的实现必定会很是了解 BeanFactoryPostProcess、BeanPostProcessor，之后再作一些关于 Spring 中间件的开发时，若是须要用到 Bean 对象的获取以及修改一些属性信息，那么就可使用这两个接口了。同时 BeanPostProcessor 也是实现 AOP 切面技术的关键所在。
- 有人问：
面试问那么多，但是工做又用不到，是嘎哈么呢？，嘎哈么，那你说你开车上桥的时候，会每次都撞两边的护栏吗，不撞是吧，那不要修了哇，直接就铺一个平板，还省材料了。其实核心技术的原理学习，是更有助于你完成更复杂的架构设计，当你的知识能更全面覆盖所承接的需求时，也就能更好的作出合理的架构和落地。
7、系列推荐
相关文章
- 1. Java开发新手应该挑战一下你的软肋（文末送书）
- 2. Spring的两个上下文
- 3. 个人六月更文挑战总结
- 4. Spring初级：Spring应用上下文
- 5. 个人项目实战11：SimonShop(下)
- 6. 个人第一个android应用上架，记念一下
- 7. Spring IoC容器与应用上下文的设计与实现
- 8. Spring Cloud上下文：应用程序上下文服务
- 9. 滑动文字实现上下拖动
- 10. Spring 刷新应用上下文refreshContext
- 更多相关文章...
- • 第一个Spring程序 - Spring教程
- • PHP 文件上传 - PHP教程
- • Docker容器实战(七) - 容器眼光下的文件系统
- • Spring Cloud 微服务实战(三) - 服务注册与发现
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
