简单理解spring框架，首先就是一个框架，直白点讲就是提高效率的工具，好比工厂干活，以前是人机械式的工作，现在用上了机器，人只用去操作机器就行了。那么spring工具提供了一个大容器，每次工作前把需要的东西全放进去，用的时候去容器拿，不用像之前用的时候还要跑回去拿。框架终究只是一个工具，如果如何使用手都不熟练，什么工具都不好上手，所以最重要的是基础。
大多数的框架都是一种套路，利用资源加载和反射，在不断的加载配置文件，无论是yml , factories , properties,xml,handlers等等，value值往往就是对应需要类加载的全限定名，再不停地封装缓存信息，加载信息，监听信息等等，最后再去完成类加载之后的对象执行交互或者进一步封装。
首先是构建项目的目录，遵循了web开发的项目结构；使用spring框架，首先导入context核心包，包含了bean,core,expression等IoC功能
我要评论<!--core核心包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.10.RELEASE</version>
</dependency>
所有的bean交给spring容器管理，所以"工作前"需要先启动容器，并将配置的bean放入到容器中：
第一种：ClassPathXmlApplicationContext，加载xml文件，然后解析生成Bean，注册Bean，通过getBean获取对象
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
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
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- DI的解析器，试验过程中注释掉也可以注入？ -->
<context:annotation-config />
<!-- IoC的解析器 -->
<context:component-scan base-package="cn.mytest.spring" />
</beans>
配置了注解方式去注册Bean，测试一下IoC和DI
--需要注入的bean
@Data
@Component
public class NameBean {
private String prefix="张";
private String suffix="三";
}
--IoC
@Component
public class TestBean {
private String name;
@Autowired
NameBean nameBean;
public String test(){
this.name=nameBean.getPrefix()+nameBean.getSuffix();
return name;
}
}
--或者通过@Configuration+@Bean
@Configuration
public class ValidateBean {
@Bean
public ValidateBean get(){
return new ValidateBean();
}
}
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
TestBean testBean = (TestBean)context.getBean("testBean");
System.out.println(testBean.test()); //张三
Object validateBean = context.getBean("validateBean");
}
第二种：AnnotationConfigApplicationContext，初步实践得知，先注册类中贴有@Bean的实例，再直接根据类的简单名去注册bean，跟@Configuration无关
public class ValidateBean {
@Bean
public NameBean getName(){
System.out.println(1111);
return new NameBean();
}
}
// 用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContext
//容器先后注册了NameBean，ValidateBean和TestBean
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ValidateBean.class,TestBean.class);
Object testBean = applicationContext.getBean("testBean");
System.out.println(testBean);//1111 cn.mytest.spring.bean.TestBean@2d6eabae
第三种方式是在web容器启动时构建容器，可以通过配置监听器去初始化spring容器
//ContextLoaderListener在创建时会默认查找WEB-INF/下的applicationContext.xml
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:application.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
最终都会走到父类AbstractApplicationContext的refresh方法中
构建ApplicationContext
spring容器初始化的流程图
第三种方式通过启动web容器，加载监听器ContextLoaderListener，用于监听web容器的生命周期，当web容器启动时就会触发，ServletContext就是整个web容器的’全局变量’
--ContextLoaderListener 容器加载监听器
public void contextInitialized(ServletContextEvent event) {
initWebApplicationContext(event.getServletContext());
}
而initWebApplicationContext初始化spring容器，和springMVC初始化容器调用的方法一致，所以在后者框架中将初始化容器放在servlet节点加载时去做的，而不是用监听器的方式
public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
//判断servletContext容器中是否已经有创建好的app应用容器，有则抛异常
if (servletContext.getAttribute
(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
throw new IllegalStateException("");
}
try {
if (this.context == null) {
//构建一个应用容器返回
this.context = createWebApplicationContext(servletContext);
}
if (this.context instanceof ConfigurableWebApplicationContext) {
ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
//active激活状态标识，使用原子方式保保证唯一线程操作
//AtomicBoolean active = new AtomicBoolean()
//如果环境未激活，也就是未刷新之前设置父上下文、设置上下文id
if (!cwac.isActive()) {
if (cwac.getParent() == null) {
ApplicationContext parent = loadParentContext(servletContext);
cwac.setParent(parent);
}
//配置并刷新当前上下文环境
configureAndRefreshWebApplicationContext(cwac, servletContext);
}
}
//将应用容器添加到servletContext中
servletContext.setAttribute(WebApplicationContext.
ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
}
构建建WebApplicationContext对象流程
自定义容器或是默认的XmlWebApplicationContext是实现ConfigurableWebApplicationContext接口，而后者的父类接口是WebApplicationContext
XmlWebApplicationContext--实现-->ConfigurableWebApplicationContext接口
--继承-->WebApplicationContext接口--继承-->ApplicationContext接口
--ContextLoader
protected WebApplicationContext createWebApplicationContext
(ServletContext sc) {
//根据配置确定构建自定义容器还是默认的容器XmlWebApplicationContext
Class<?> contextClass = determineContextClass(sc);
//isAssignableFrom方法表示调用者是否是参数的父类
if (!ConfigurableWebApplicationContext.class.
isAssignableFrom(contextClass)) {
throw new ApplicationContextException("");
}
return (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
}
determineContextClass类加载需要构建的容器类，可以在web.xml中自定义容器，默认的容器就是XmlWebApplicationContext容器
protected Class<?> determineContextClass(ServletContext servletContext) {
//String CONTEXT_CLASS_PARAM = "contextClass";表示在<context-param>标签中是否有配置的自定义的contextClass
String contextClassName = servletContext.getInitParameter(CONTEXT_CLASS_PARAM);
if (contextClassName != null) {
return ClassUtils.forName(contextClassName, ClassUtils.getDefaultClassLoader());
}
else {
//defaultStrategies通过静态方法在类加载时已经添加了默认的参数
//这个默认的就是XmlWebApplicationContext
contextClassName = defaultStrategies.getProperty(WebApplicationContext.class.getName());
return ClassUtils.forName(contextClassName, ContextLoader.class.getClassLoader());
}
}
--配置自定义的Context
<context-param>
<param-name>contextClass</param-name>
<param-value>
org.springframework.web.context.support.MyWebApplicationContext
</param-value>
</context-param>
defaultStrategies默认策略，加载org.springframework.web.context包下的properties文件：
org.springframework.web.context.WebApplicationContext=org.springframework.web.context.support.XmlWebApplicationContext
spring大量运用了加载资源文件的方式properties.load(inputStream)
--ContextLoader
private static final Properties defaultStrategies;
static {
//String DEFAULT_STRATEGIES_PATH = "ContextLoader.properties";
ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, ContextLoader.class);
defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
}
}
configureAndRefreshWebApplicationContext配置并刷新当前上下文环境
protected void configureAndRefreshWebApplicationContext(
ConfigurableWebApplicationContext wac, ServletContext sc) {
//配置应用程序上下文id
//id：org.springframework..support.XmlWebApplicationContext@710c986
//@后面是hash值避免冲突，容器每次构建时都是唯一
if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
//首先找web.xml中<context-param>配置：param-name为contextId
String idParam = sc.getInitParameter(CONTEXT_ID_PARAM);
if (idParam != null) {
wac.setId(idParam);
}
else {
//默认id:org.springframework.web.context.WebApplicationContext:
wac.setId(ConfigurableWebApplicationContext
.APPLICATION_CONTEXT_ID_PREFIX +
ObjectUtils.getDisplayString(sc.getContextPath()));
}
}
wac.setServletContext(sc);
/**
* 设置配置文件路径
* <context-param>
* <param-name>contextConfigLocation</param-name>
* <param-value>classpath:spring.xml</param-value>
* </context-param>
*/
String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
if (configLocationParam != null) {
wac.setConfigLocation(configLocationParam);
}
//Environment表示当前应用程序正在运行的环境，子类ConfigurableEnvironment：提供设置激活的 profile 和默认的 profile 的功能以及操作 Properties 的工具
ConfigurableEnvironment env = wac.getEnvironment();
//ConfigurableWebEnvironment：提供配置 Servlet 上下文和 Servlet 参数的功能
if (env instanceof ConfigurableWebEnvironment) {
//初始化PropertySources容器:存放多个PropertySource的容器
((ConfigurableWebEnvironment) env).initPropertySources(sc, null);
}
//自定义环境初始化
customizeContext(sc, wac);
//构建容器完成配置的核心方法
wac.refresh();
}
ObjectUtils.identityToString方法：
public static String identityToString(Object obj) {
return obj.getClass().getName() + "@" + getIdentityHexString(obj);
}
initPropertySources初始化PropertySources容器，PropertySource接口类似一个Map，PropertySources的实现类MutablePropertySources用链表实现存放PropertySource
public class MutablePropertySources implements PropertySources {
private final List<PropertySource<?>> propertySourceList;
...
initPropertySources最终由WebApplicationContextUtils.initServletPropertySources实现，servletContext是web容器变量，有web.xml的配置信息(比如context-param)；ServletConfig保存着servlet节点对应容器的配置信息(比如 init-param)，这个初始化其实是想把servletContext,一个servletConfig这两个对象给存到容器的propertySources容器里去
public void initPropertySources(ServletContext servletContext, ServletConfig servletConfig) { WebApplicationContextUtils.initServletPropertySources(getPropertySources(), servletContext, servletConfig);
}
再去加载context-param节点中自定义配置的InitializerClasses，一般用不到
protected void customizeContext(ServletContext sc, ConfigurableWebApplicationContext wac) {
/**
*
* globalInitializerClasses 代表所有的web application都会应用
* contextInitializerClasses 代表只有当前的web application会使用
* 配置自定义的globalInitializerClasses/contextInitializerClasses：
* <context-param>
* <param-name>contextInitializerClasses</param-name>
* <param-value>com..MyContextInitializerClasses</param-value>
* </context-param>
*/ List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>>
initializerClasses = determineContextInitializerClasses(sc);
...
//自定的ApplicationContextInitializer再调用initialize()方法
for (ApplicationContextInitializer<ConfigurableApplicationContext> initializer : this.contextInitializers) {
initializer.initialize(wac);
}
ApplicationContextInitializer容器初始化接口在springboot中频繁用到，refresh之前对ConfiurableApplicationContext的做进一步的设置和处理，在springboot中一键启动时加载所有需要初始化的配置类，比如start相关包中META-INF/spring.factories中配置
其他的配置方式：
mian函数中添加：application.addInitializers(new MyApplicationContextInitializer());
@SpringBootApplication
public class MySpringBootApplication {
public static void main(String[] args) {
SpringApplication application = new SpringApplication(MySpringBootApplication.class);
application.addInitializers(new MyApplicationContextInitializer());
application.run(args);
}
}
配置文件中配置：context.initializer.classes=xxx.MyApplicationContextInitializer
refresh()方法和方法内的具体实现基本都在AbstractApplicationContext类
--AbstractApplicationContext
public void refresh() throws BeansException, IllegalStateException {
//Synchronization monitor for the "refresh" and "destroy"
//简单来说就是在进行refresh或者destroy操作时去拿这个对象加上锁
synchronized (this.startupShutdownMonitor) {
//预处理，容器初始化的设值
prepareRefresh();
//根据不同容器的实现注册bean
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//填充BeanFactory功能，比如AspectJ，spring语言处理器等等
prepareBeanFactory(beanFactory);
try {
// 容器后处理器
postProcessBeanFactory(beanFactory);
// 调用BeanFactoryPostProcessor，激活各种处理器
invokeBeanFactoryPostProcessors(beanFactory);
// 6、注册BeanPostProcessors
registerBeanPostProcessors(beanFactory);
// 7、初始化Message资源
initMessageSource();
// 8、初始事件广播器
initApplicationEventMulticaster();
// 9、留给子类初始化其他Bean(空的模板方法)
onRefresh();
// 10、注册事件监听器
registerListeners();
// 11、初始化其他的单例Bean(非延迟加载的)
finishBeanFactoryInitialization(beanFactory);
// 12、完成刷新过程,通知生命周期处理器lifecycleProcessor刷新过程,同时发出ContextRefreshEvent通知
finishRefresh();
}
catch (BeansException ex) {
// 13、销毁已经创建的Bean
destroyBeans();
// 重置active设值为false
cancelRefresh(ex);
throw ex;
}
finally {
resetCommonCaches();
}
}
}
读取XML配置文件，创建beans流程
preRefresh预刷新，initPropertySources把servletConfig和servletContext放到spring容器的propertySources容器里面
protected void prepareRefresh() {
//设置context的启动时间
this.startupDate = System.currentTimeMillis();
this.closed.set(false);//关闭标识为false
this.active.set(true);//激活标识为true
//configureAndRefreshWebApplicationContext方法中已经做个这个步骤
initPropertySources();
//验证在spring启动的时候自定义配置的环境变量必须存在,重写initPropertySources方法：
//getEnvironment().setRequiredProperties("xx");设值
getEnvironment().validateRequiredProperties();
this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}
obtainFreshBeanFactory中refreshBeanFactory()在AbstractRefreshableApplicationContext和GenericApplicationContext都有实现，但是XmlWebApplicationContext继承了AbstractRefreshableApplicationContext，而AnnotationConfigApplicationContext继承了GenericApplicationContext
--AbstractRefreshableApplicationContext
protected final void refreshBeanFactory() throws BeansException {
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
//新建的DefaultListableBeanFactory，实现ConfigurableListableBeanFactory接口
DefaultListableBeanFactory beanFactory = createBeanFactory();
//前面有设值过：org.springframework.web.context.WebApplicationContext:
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
//加载BeanDefinition，将bean添加到beanDefinitionMap中
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
loadBeanDefinitions有多个实现，这里以默认的XmlWebApplicationContext为例
--XmlWebApplicationContext
// root context的默认配置位置
public static final String DEFAULT_CONFIG_LOCATION = "/WEB-INF/applicationContext.xml";
// 默认配置位置的前缀
public static final String DEFAULT_CONFIG_LOCATION_PREFIX = "/WEB-INF/";
// 默认配置位置的后缀
public static final String DEFAULT_CONFIG_LOCATION_SUFFIX = ".xml";
//通过XmlBeanDefinitionReader加载bean
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// Create a new XmlBeanDefinitionReader for the given BeanFactory.
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
// Configure the bean definition reader with this context's
// resource loading environment.
beanDefinitionReader.setEnvironment(getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
//空实现，留给子类进行自定义初始化
initBeanDefinitionReader(beanDefinitionReader);
//使用给定的reader加载bean定义
loadBeanDefinitions(beanDefinitionReader);
}
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {
//就是context-param配置的contextConfigLocation，没有则返回context的默认配置
String[] configLocations = getConfigLocations();
if (configLocations != null) {
for (String configLocation : configLocations) {
//遍历xml配置文件进行加载解析DOM，最终注册到beanDefinitionMap
reader.loadBeanDefinitions(configLocation);
}
}
}
loadBeanDefinitions(configLocation)解析xml配置文件加载bean
--AbstractBeanDefinitionReader
public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
//解析bean配置文件加载器
ResourceLoader resourceLoader = getResourceLoader();
//XmlWebApplicationContext实现了ResourcePatternResolver接口
//也就是以xml配置bean进行加载的，非xml配置就不会实现这个接口
if (resourceLoader instanceof ResourcePatternResolver) {
try {
//将配置文件的内容转化为Resource对象
//判断是否是classpath*:开头的通配符
Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
//获取Resource对象流进行解析，转化为bean进行封装
int loadCount = loadBeanDefinitions(resources);
if (actualResources != null) {
for (Resource resource : resources) {
actualResources.add(resource);
}
}
return loadCount;
}
}
...
}
loadBeanDefinitions(resources)
//EncodedResource对Resource封装了字符集编码
public int loadBeanDefinitions(Resource resource) {
return loadBeanDefinitions(new EncodedResource(resource));
}
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
//使用ThreadLocal防止资源文件循环加载
Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
//确认没有加载过当前的Resource
if (currentResources == null) {
currentResources = new HashSet<>(4);
this.resourcesCurrentlyBeingLoaded.set(currentResources);
}
try {
//获取Resource的流
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
//解析成DOM对象，进行Bean注册
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
...
}
}
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) {
//解析为Document对象
Document doc = doLoadDocument(inputSource, resource);
//根据Document对象注册Bean
return registerBeanDefinitions(doc, resource);
...
}
registerBeanDefinitions返回注册的Bean数量，Bean解析和注册的详情在后面目录
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
//构建读取Document的工具类
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
//获取已注册的bean数量，封装在BeanFactory中
//BeanFactory实现BeanDefinitionRegistry接口
int countBefore = getRegistry().getBeanDefinitionCount();
//注册本次需要加载的Bean
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
//返回本次注册的bean：总注册的bean减去之前注册的bean
return getRegistry().getBeanDefinitionCount() - countBefore;
}
填充一些特殊的bean和处理器等，暂时不深入分析每个处理器的作用和实现
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 设置beanFactory的classLoader
beanFactory.setBeanClassLoader(getClassLoader());
// 设置beanFactory的表达式语言处理器,默认可以使用#{xxx.xxx}的形式来调用相关属性值
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 添加默认的PropertyEditors，这些最后都注册到CustomEditorConfigurer中
//Set<PropertyEditorRegistrar> propertyEditorRegistrars
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
//在所有实现了Aware接口的bean在初始化之后可以通过processor获取初始化之后的内容
//ApplicationContextAwareProcessor是ApplicationContext负责回调的processor
//例如实现了aware的bean初始化之后可以通过awareProcessor获取其bean id
//List<BeanPostProcessor> beanPostProcessors
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 设置忽略bean 依赖于以下几个接口的实现类，Spring 会通过其他方式来处理这些依赖
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// 设置几个自动装配的特殊Bean
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
//注册事件监听器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
//如果存在bean名称为loadTimeWeaver的bean则注册一个BeanPostProcessor
// 增加对AspectJ的支持
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 注册默认的系统环境bean，environment，systemProperties，systemEnvironment
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
addPropertyEditorRegistrar添加PropertyEditorRegistrar，PropertyEditors的接口来实现对象和字符串之间的转换，比如在配置文件中添加一个属性值 myValue:xxx.xxx.Student，拿到这个值之后，通过实现PropertyEditorSupport 去进行类型转换
@Data
public class ExoticType {
private String myValue;
}
//这个value只是一个字符串，如果变成ExoticType对象?
@Value("${myValue}")
private ExoticType exoticType;
//实现PropertyEditorSupport接口的setAsText方法
public class ExoticTypeEditor extends PropertyEditorSupport {
@Override
public void setAsText(String text) {
setValue(new ExoticType(text.toUpperCase()));
}
}
//注册CustomPropertyEditorRegistrar
public class CustomPropertyEditorRegistrar implements PropertyEditorRegistrar {
@Override
public void registerCustomEditors(PropertyEditorRegistry propertyEditorRegistry) {
propertyEditorRegistry.registerCustomEditor(ExoticType.class, new ExoticTypeEditor());
}
}
//最后将customPropertyEditorRegistrar注册到CustomEditorConfigurer中
<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
<property name="propertyEditorRegistrars">
<list>
<ref bean="customPropertyEditorRegistrar"/>
</list>
</property>
</bean>
容器addBeanPostProcessor(new ApplicationContextAwareProcessor(this))添加了一个ApplicationContextAwareProcessor的处理器
有多个实现，也可以自定义实现，以ConfigurableListableBeanFactory容器为例，容器后处理
--AbstractRefreshableWebApplicationContext
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
//aware将ServletContext 传递给实现ServletContextAware接口的bean
beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
//忽略实现了以下2个接口的实现类的注册
beanFactory.ignoreDependencyInterface(ServletContextAware.class);
beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
//注册 WEB 应用特定的域(scope)，比如: request session response application等.
WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
//注册 WEB 应用特定的 Environment bean,比如contextAttributes等
//registerSingleton servletContext和servletConfig
WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
}
注册 WEB 应用特定的域(scope)和Environment bean
public static void registerWebApplicationScopes
(ConfigurableListableBeanFactory beanFactory, ServletContext sc) {
//scope.put
beanFactory.registerScope(WebApplicationContext.SCOPE_REQUEST, new RequestScope());
beanFactory.registerScope(WebApplicationContext.SCOPE_SESSION, new SessionScope(false));
beanFactory.registerScope(WebApplicationContext.SCOPE_GLOBAL_SESSION, new SessionScope(true));
//注册域的bean
beanFactory.registerResolvableDependency(ServletRequest.class, new RequestObjectFactory());
beanFactory.registerResolvableDependency(ServletResponse.class, new ResponseObjectFactory());
beanFactory.registerResolvableDependency(HttpSession.class, new SessionObjectFactory());
beanFactory.registerResolvableDependency(WebRequest.class, new WebRequestObjectFactory());
}
激活beanFactory的各种处理器，之前已经将所有的Processors添加到BeanFactory中的beanPostProcessors集合中
BeanDefinition就是Bean的定义信息，封装了每个bean的信息，对于spring框架来说操作bean就是操作BeanDefinition；BeanFactory封装了所有注册的BeanDefinition(beanDefinitionMap)
refresh()–>obtainFreshBeanFactory()–>registerBeanDefinitions()，经过一系列的解析之后，最终将dom解析成BeanDefinition并封装到BeanFactory中
protected void doRegisterBeanDefinitions(Element root) {
//委托BeanDefinitionParserDelegate作为解析的代理
BeanDefinitionParserDelegate parent = this.delegate;
this.delegate = createDelegate(getReaderContext(), root, parent);
//是否匹配："http://www.springframework.org/schema/beans"
if (this.delegate.isDefaultNamespace(root)) {
//profile:根节点属性，是否匹配当前环境，不匹配则不解析当前xml文件
//<beans xmlns="http://www.springframework.org/schema/beans" profile="test"...>
String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
if (StringUtils.hasText(profileSpec)) {
...
return;
}
}
//解析root节点之前的操作，空实现，留给子类实现
preProcessXml(root);
parseBeanDefinitions(root, this.delegate);
//解析root节点之后的操作，空实现
postProcessXml(root);
//通过这个方式还原初始化的BeanDefinitionParserDelegate
this.delegate = parent;
}
所以最终由parseBeanDefinitions方法来处理dom
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
//default namespace就四个标签<import/>、<alias/>、<bean/> 和 <beans/>
if (delegate.isDefaultNamespace(root)) {
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element ele = (Element) node;
if (delegate.isDefaultNamespace(ele)) {
// 解析 default namespace 下面的几个元素
parseDefaultElement(ele, delegate);
}
else {
// 解析其他 namespace 的元素
//例如：<context:component-scan/>、<aop:aspectj-autoproxy/>
delegate.parseCustomElement(ele);
}
}
}
}
else {
// 解析其他 namespace 的元素
delegate.parseCustomElement(root);
}
}
默认的命名空间只包含了import、alias、bean 和 beans四个标签，其中beans又是一个嵌套的dom继续递归调doRegisterBeanDefinitions
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
// import标签：解耦式的导入，将其他xml配置文件引入解析
//比如<import resource="classpath:app.xml" />
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
// alias标签:<alias name="test" alias="test1,test2"/>
//作用就是增加test1,test2作为bean名称指向bean
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
//解析bean标签，并注册beanDefinition
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
//beans标签：递归方法解析
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
doRegisterBeanDefinitions(ele);
}
}
processBeanDefinition核心在于解析bean标签并注册beanDefinition
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
//解析之后BeanDefinition,beanName以及aliases封装到BeanDefinitionHolder
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
//装饰BeanDefinition：可以添加自定义的属性
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
//执行注册，将BeanDefinition信息添加到beanFactory中
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
//接受在读取BeanDefinition进程中注册组件、别名、import时的回调接口
//自定义实现ReaderEventListener
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
BeanDefinitionHolder就是将dom标签的属性及子标签解析之后的信息进行封装
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
//解析bean的属性，id,name和<alias>配置的别名都可以作为bean的key值
String id = ele.getAttribute(ID_ATTRIBUTE);
// 获取name属性，缓存至别名List
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
List<String> aliases = new ArrayList<>();
if (StringUtils.hasLength(nameAttr)) {
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
aliases.addAll(Arrays.asList(nameArr));
}
// 如果bean的id为空，但是别名不为空的话，那么默认采用第一个别名作为beanName
// 例如：<bean class="com.xx.Dog" name="myDog1,myDog2"/>
String beanName = id;
if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
//使用myDog1作为beanName，并移除别名集合
beanName = aliases.remove(0);
}
//检查beanName和别名是否被使用
if (containingBean == null) {
checkNameUniqueness(beanName, aliases, ele);
}
//解析bean标签，将属性及子节点信息封装
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
....
}
进一步处理parseBeanDefinitionElement
public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, @Nullable BeanDefinition containingBean) {
//this.beanDefinitionName = beanName
this.parseState.push(new BeanEntry(beanName));
//解析class属性，类全限定名
String className = null;
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
//解析parent属性
String parent = null;
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
//创建AbstractBeanDefinition对象，将标签的信息进行封装
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
//解析bean标签属性
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
//解析bean标签下的子节点并封装到bd中
//包括<property/>，<constructor-arg />注入之类标签等等
bd.set....
}
parseBeanDefinitionAttributes解析bean属性
public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,BeanDefinition containingBean,AbstractBeanDefinition bd) {
// 1.设置bean作用域scope属性，不能设置为单例
// 未明确指定bean的作用域,且当前被解析bean是内部bean的话，
// 则默认使用outer bean的的作用域作为当前bean的作用域
// 例如:下面的配置，解析到inner属性时，inner未指定作用域，则使用outer的作用域，也就是prototype
/**
<bean id="outer" class="com.lyc.cn.v2.day01.inner.Outer" scope="prototype">
<property name="inner">
<bean id="inner" class="com.lyc.cn.v2.day01.inner.Inner"/>
</property>
</bean>
**/
bd.setScope(containingBean.getScope());
//2.设置abstract属性：abstract=true
// 3.设置lazy-init(延迟加载)属性；
// 如果该属性为true的话，ApplicationContext容器在初始化时不会加载该bean；
// 而是在第一次向容器索取该bean时才会被初始化
bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
//4.设置autowire属性，自动注入，有byName和byType方式，默认不开启
//byName，按照setXxx方法的Xxx名称去注入bean
//byTupe,按照set方法的入参属性类去注入bean
bd.setAutowireMode(getAutowireMode(autowire));
//5.设置depends-on属性，如果BeanA依赖于BeanB，可通过depends-on属性使BeanB在BeanA之前完初始化
//6.设置autowire-candidate属性，默认为true
//当设置为false时，不让其他类通过autowire注入当前bean
// 7、设置primary属性，当byType注入有多个类型时，
// 可以指定primary="true"，提高注入的优先级，避免抛出异常
// 8、设置init-method，bean初始化完成后回调该方法
// 9、设置destroy-method属性，bean销毁后回调该方法
// 10、设置factory-method属性，该属性可指定静态工厂或实例工厂方法实例化bean
// 11、设置factory-bean属性，一般和factory-method属性一起使用，
// 指定工厂bean和工厂bean的工厂方法
}
BeanDefinitionReaderUtils工具类方法去执行注册
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
// 1、注册BeanDefinition，一般为id
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// 2、注册aliases（别名），一般配置多个指向Bean的别名
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}
入参BeanDefinitionRegistry接口提供了多个beanfactory实现类，默认的实现是DefaultListableBeanFactory
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
if (beanDefinition instanceof AbstractBeanDefinition) {
//验证不能将静态工厂方法与方法重写相结合(factory-method的配置)
((AbstractBeanDefinition) beanDefinition).validate();
}
//优先从缓存中加载BeanDefinition，覆盖原先的bean
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
//添加到beanfactory的beanDefinitionMap中
this.beanDefinitionMap.put(beanName, beanDefinition);
}else {
// 如果beanDefinition已经被标记为创建(为了解决单例bean的循环依赖问题)
if (hasBeanCreationStarted()) {
synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
//将缓存的beanDefinitionNames和新解析的beanName加入集合
List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
// 将updatedDefinitions赋值给beanDefinitionNames
this.beanDefinitionNames = updatedDefinitions;
// 如果manualSingletonNames中包含新注册的beanName
if (this.manualSingletonNames.contains(beanName)) {
// 创建set集合并将manualSingletonNames加入到新创建的set集合
Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
// 移除新注册的beanName
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
}
else {
// 将beanDefinition信息维护至缓存
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
// manualSingletonNames缓存了手动注册的单例bean，所以需要remove
// 例如：xmlBeanFactory.registerSingleton("myDog", new Dog());
// 就可以向manualSingletonNames中注册单例bean
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
// 如果当前注册的bean的定义已经在beanDefinitionMap缓存中存在，
// 或者实例已经存在于单例bean的缓存中，将该beanName对应的缓存信息、单例对象清除
if (existingDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}
上面方法主要是将beanName和BeanDefinition形成映射
xmlns 属性可以在文档中定义一个或多个可供选择的命名空间，使用时在子标签内添加他的前缀作为标识：
比如：context,aop等
<beans xmlns="http://www.springframework.org/schema/beans" profile="test"
xmlns:context="http://www.springframework.org/schema/context"...
----context:----作为另外的一个命名空间标识
<context:component-scan base-package="cn.mytest.spring" />
构建NamespaceHandler
public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
// node.getNamespaceURI拿到节点的命名空间，例如常见的:
// <aop> 节点对应命名空间: http://www.springframework.org/schema/aop
String namespaceUri = getNamespaceURI(ele);
// 命名空间对应的的handler, 例如：contex 对应 ContextNameSpaceHandler
//namespaceHandlerResolver解析namespaceUri, 拿到NamespaceHandler
NamespaceHandler handler = this.readerContext
.getNamespaceHandlerResolver().resolve(namespaceUri);
if (handler == null) {
return null;
}
// handler解析节点（ParserContext用于存放解析需要的一些上下文信息）
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}
readerContext.getNamespaceHandlerResolver()获取了默认的命名空间处理器DefaultNamespaceHandlerResolver，其封装了所有包下的handler
每个包下MATA-INF/spring.handlers文件记录对应的hanlder，因此使用指定的 classLoader 从所有类路径资源（META-INF/spring.handlers）加载所有属性，并使用 Properties 来存放 spring.handlers 文件中的内容（命名空间和 handler 的键值对）
--MATA-INF/spring.handler
http\://www.springframework.org/schema/aop=org.springframework.aop.config.AopNamespaceHandler"
//使用给定的类加载器从指定的类路径资源加载所有属性
Properties mappings = PropertiesLoaderUtils
.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
//将Properties转换成Map, mappings -> handlerMappings
CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
每个命名空间处理都会封装不同标签的bean解析器，例如ContextNamespaceHandler中封装了诸如property-placeholder，annotation-config等标签解析器
<!-- 加载db.properties文件，属性占位 -->
<context:property-placeholder location="classpath:db.properties"
system-properties-mode="NEVER" />
<!-- DI的解析器 -->
<context:annotation-config />
<!-- IoC的解析器 -->
<context:component-scan base-package="cn.wolfcode.wms" />
public class ContextNamespaceHandler extends NamespaceHandlerSupport {
@Override
public void init() {
registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
}
}
先获取每个标签对应的BeanDefinitionParser解析器，再根据不同的解析器去实现parse方法，对于各个标签的解析功能暂不深入，主要是太多了，也可以进行自定义namespace
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
//拿到节点的localName，例如：<context:annotation-config />
String localName = parserContext.getDelegate().getLocalName(element);
//从parsers缓存中，拿到localName对应的解析器, 例如: component-scan -> ComponentScanBeanDefinitionParser
BeanDefinitionParser parser = this.parsers.get(localName);
return parser;
}
--parser.parse(element, parserContext);
refresh执行到finishBeanFactoryInitialization时才开始初始化非延迟加载的bean，符合框架的通用性原则，不断的加载配置文件和资源文件，不断的封装缓存和需要处理的内容，最后进行类加载处理，进行封装和处理
本文地址：https://blog.csdn.net/weixin_42829824/article/details/107455200
如对本文有疑问， 点击进行留言回复！！
利用python将Mysql信息以Excel文件并作为邮件附件发送
springmvc+mybaits+mysql上传表情Incorrect string value: ‘\xF0\x9F\xA4\xB4\xF0\x9F...‘ for
SpringCloud Greenwich集成Seata1.2.0详解说明(原创by ulwfcyvi)
mybatis generator生成代码库 与指定的库不一致 为其他库的同名表
网友评论