handlerMappings,key是NamepaceURI,value是NamespaceHandler。
最后调用handler.parse来解析自定义标签
### BeanPostProcessor
可以参考官方文档,文档上说的很详细。我的理解就是，BeanPostProcessor是Spring给我们留的一个拓展接口，我们实现这个接口并注册到Spring容器之后，Spring容器就会在后续调用。具体是什么时候调用的呢，看看源码。
Spring主要的启动流程就在org.springframework.context.support.AbstractApplicationContext类的refresh()方法中
```java
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
//注册bean processors 拦截bean的创建
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
```
在上面的代码中，我们从代码注释可以看到，BeanPostProcessor的处理和registerBeanPostProcessors方法有关系，看一下这个方法
```java
/**
* Instantiate and register all BeanPostProcessor beans,
* respecting explicit order if given.
* Must be called before any instantiation of application beans.
*/
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
```
实例化并注册所有的BeanPostProcessor Bean，看一下具体实现
```
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 把实现了PriorityOrdered, Ordered等等的BeanPostProcessors分开
List priorityOrderedPostProcessors = new ArrayList<>();
List internalPostProcessors = new ArrayList<>();
List orderedPostProcessorNames = new ArrayList<>();
List nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
// 注册实现了PriorityOrdered的BeanPostProcessors
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
List orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
List nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
```
这个方法，把BeanPostProcessors先进行分类，然后注册。那它是在何时开始执行的呢，如果直接看代码，可能不是很方便的看到是如何调用的，先运行一次代码，打个断点
可以看到方法的调用栈，嵌套的很多，不过可以看到是从AbstractApplicationContext.finishBeanFactoryInitialization(beanFactory)开始调用的，点击左边的栈帧，可以定位到对应的方法，看个比较重要的
AbstractAutowireCapableBeanFactory.InitializationBean方法
从下图中可以看到在调用Bean的初始化方法前后分别调用了BeanPostProcessor的postProcessBeforeInitialization和postProcessAfterInitialization方法
#### 例子
前面我们都没有使用过bean的init-method功能，测试一下
新建一个类User
```java
package org.lanettiesso.dubbo.example.bean.postprocessor;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
@Data
@Slf4j
public class UserBean {
public void init() {
log.info("----------------------- User init ---------------------");
}
}
```
创建一个BeanPostProcessor的实现类Example1BeanPostProcessor
```java
package org.lanettiesso.dubbo.example.bean.postprocessor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
@Slf4j
public class Example1BeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
log.info("------------------------- BeanPostProcessor before init ------------------------------");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
log.info("------------------------- BeanPostProcessor after init ------------------------------");
return bean;
}
}
```
创建一个application-context-example1.xml
```xml
```
创建一个启动类
```java
package org.lanettiesso.dubbo.example;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class ExampleTest {
@Test
public void testBeanPostProcessor() {
start("example/application-context-example1.xml");
}
private void start(String xmlPath) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(xmlPath);
context.start();
}
}
```
运行结果如下
正如我们在源码中看到的过程一样
#### 总结
- 通过实现BeanPostProcessor接口并注册到Spring容器，我们可以在实现类中对Bean进行操作，例如dubbo-simple中，我们就对Bean进行了动态代理，然后返回给Spring容器的是我们代理后的对象，之后在使用bean的时候需要做什么事，我们都可以在动态代理中做自己的定义
- BeanPostProcessor是在AbstractApplicationContext.registerBeanPostProcessors方法中注册，在AbstractApplicationContext.finishBeanFactoryInitialization方法中调用，具体的调用过程在AbstractAutowireCapableBeanFactory.InitializationBean方法中，调用流程是先执行BeanPostProcessor.postProcessBeforeInitialization然后执行Bean的init-method,最后执行BeanPostProcessor.postProcessAfterInitialization
### BeanDefinitionRegistryPostProcessor
## 动态代理
JDK动态代理和Cglib的比较
```
由于Cglib代理是利用ASM字节码生成框架在内存中生成一个需要被代理类的子类完成代理，而JDK动态代理是利用反射原理完成动态代理，所以Cglib创建的动态代理对象性能比JDk动态代理动态创建出来的代理对象新能要好的多，但是对象创建的速度比JDk动态代理要慢，所以，当Spring使用的是单例情况下可以选用Cglib代理，反之使用JDK动态代理更加合适。同时还有一个问题，被final修饰的类只能使用JDK动态代理，因为被final修饰的类不能被继承，而Cglib则是利用的继承原理实现代理的。
```