spring5.1.x源码解析之十三(常见问题)

淩亂°似流年 2023-02-21 06:39 5阅读 0赞

### 文章目录 ###

*  spring如何实现标签功能扩展的?
 *  spring如何解决循环依赖?
 *  BeanFactoryPostProcessors和BeanPostProcessors区别
 *  spring加载xml过程
 *  spring获取对象过程
 *  spring-aop执行过程(重点)
 *  cglib和动态代理区别
 *   *  spring选择
 *  mybatis如何和spring整合?

# spring如何实现标签功能扩展的? #

spring在解析doc的时候,会创建一个ReaderContext对象  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 1]  
ReaderContext对象创建的时候,会创建NamespaceHandlerResolver对象  
![在这里插入图片描述][20200629145826349.png]  
在进行对象解析的时候,会分别解析默认命名空间和自定义的解析,也就是beans标签和非beans标签的解析  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 3]

/*
    	获取所有已经配置的handler映射,读取配置文件
    	根据命名空间找到对应的信息
    	当是类的时候说明,已经做过解析直接缓存读取,直接返回
    	没有做过解析,返回类路径
    		判断handlerClass是否是NamespaceHandler子类
    		初始化类
    		调用自定义的namespaceHandler的初始化方法,这个时候注入了解析器
    		记录在缓存
    		返回
    	 */
    	public NamespaceHandler resolve(String namespaceUri) {
        
    		//获取所有已经配置的handler映射,读取配置文件
    		//和类org.springframework.beans.factory.xml.PluggableSchemaResolver.getSchemaMappings一样,不在阐述
    		Map<String, Object> handlerMappings = getHandlerMappings();
    		//根据命名空间找到对应的信息
    		Object handlerOrClassName = handlerMappings.get(namespaceUri);
    		if (handlerOrClassName == null) {
        
    			return null;
    		}
    		//这个时候还是字符串
    		else if (handlerOrClassName instanceof NamespaceHandler) {
        
    			//已经做过解析,直接缓存读取
    			return (NamespaceHandler) handlerOrClassName;
    		}
    		else {
        
    			//没有做过解析,返回类路径
    			String className = (String) handlerOrClassName;
    			try {
        
    				Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
    				//判断handlerClass是否是NamespaceHandler子类
    				if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
        
    					throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
    							"] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
    				}
    				//初始化类
    				NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
    				//调用自定义的namespaceHandler的初始化方法,这个时候注入了解析器
    				namespaceHandler.init();
    				//记录在缓存
    				handlerMappings.put(namespaceUri, namespaceHandler);
    				return namespaceHandler;
    			}
    			catch (ClassNotFoundException ex) {
        
    				throw new FatalBeanException("Could not find NamespaceHandler class [" + className +
    						"] for namespace [" + namespaceUri + "]", ex);
    			}
    			catch (LinkageError err) {
        
    				throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" +
    						className + "] for namespace [" + namespaceUri + "]", err);
    			}
    		}
    	}

注册命名空间能解析的elementName

public class AopNamespaceHandler extends NamespaceHandlerSupport {
        
    
    	/**
    	 * Register the {@link BeanDefinitionParser BeanDefinitionParsers} for the
    	 * '{@code config}', '{@code spring-configured}', '{@code aspectj-autoproxy}'
    	 * and '{@code scoped-proxy}' tags.
    	 */
    	@Override
    	public void init() {
        
    		// In 2.0 XSD as well as in 2.1 XSD.
    		registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
    		registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
    		registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());
    
    		// Only in 2.0 XSD: moved to context namespace as of 2.1
    		registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    	}
    
    }

接着会读取**META-INF/spring.handlers**文件配置的命名空间解析器

private Map<String, Object> getHandlerMappings() {
        
    		Map<String, Object> handlerMappings = this.handlerMappings;
    		if (handlerMappings == null) {
        
    			synchronized (this) {
        
    				handlerMappings = this.handlerMappings;
    				if (handlerMappings == null) {
        
    					if (logger.isTraceEnabled()) {
        
    						logger.trace("Loading NamespaceHandler mappings from [" + this.handlerMappingsLocation + "]");
    					}
    					try {
        
    						Properties mappings =
    								PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
    						if (logger.isTraceEnabled()) {
        
    							logger.trace("Loaded NamespaceHandler mappings: " + mappings);
    						}
    						handlerMappings = new ConcurrentHashMap<>(mappings.size());
    						CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
    						this.handlerMappings = handlerMappings;
    					}
    					catch (IOException ex) {
        
    						throw new IllegalStateException(
    								"Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex);
    					}
    				}
    			}
    		}
    		return handlerMappings;
    	}

![在这里插入图片描述][20200629150252649.png]  
然后根据url获取对应的解析器,然后解析

public BeanDefinition parse(Element element, ParserContext parserContext) {
        
    		//寻找解析器并进行解析操作
    		BeanDefinitionParser parser = findParserForElement(element, parserContext);
    		//AbstractBeanDefinitionParser.parse
    		return (parser != null ? parser.parse(element, parserContext) : null);
    	}

/*
    	调用自定义的解析器类
    	对id的支持
    	对name别名注册的支持
    	将AbstractBeanDefinition转换为BeanDefinitionHolder并注册
    	注册别名
    	子类后续处理
    	通知监听器,注册完成
    	 */
    	public final BeanDefinition parse(Element element, ParserContext parserContext) {
        
    		//内部调用了自定义的解析器类
    		AbstractBeanDefinition definition = parseInternal(element, parserContext);
    		if (definition != null && !parserContext.isNested()) {
        
    			try {
        
    				//对id的支持,当没id的时候,使用内部构造名字
    				String id = resolveId(element, definition, parserContext);
    				if (!StringUtils.hasText(id)) {
        
    					parserContext.getReaderContext().error(
    							"Id is required for element '" + parserContext.getDelegate().getLocalName(element)
    									+ "' when used as a top-level tag", element);
    				}
    				//对name别名注册的支持
    				String[] aliases = null;
    				if (shouldParseNameAsAliases()) {
        
    					String name = element.getAttribute(NAME_ATTRIBUTE);
    					if (StringUtils.hasLength(name)) {
        
    						aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
    					}
    				}
    				//将AbstractBeanDefinition转换为BeanDefinitionHolder并注册
    				BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);
    				//注册别名以及名字,还有BeanDefinition
    				registerBeanDefinition(holder, parserContext.getRegistry());
    				if (shouldFireEvents()) {
        
    					//需要通知监听器则进行处理
    					BeanComponentDefinition componentDefinition = new BeanComponentDefinition(holder);
    					//子类后续处理
    					postProcessComponentDefinition(componentDefinition);
    					//通知监听器,注册完成
    					parserContext.registerComponent(componentDefinition);
    				}
    			}
    			catch (BeanDefinitionStoreException ex) {
        
    				String msg = ex.getMessage();
    				parserContext.getReaderContext().error((msg != null ? msg : ex.toString()), element);
    				return null;
    			}
    		}
    		return definition;
    	}

/*
    	获取自定义标签解析器中的class
    	若没有获取class,则获取beanClassName
    	继承父类scope
    	配置延迟加载
    	调用自定义的解析方法
    	 */
    	protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
        
    		//内部构造了GenericBeanDefinition
    		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
    		String parentName = getParentName(element);
    		if (parentName != null) {
        
    			builder.getRawBeanDefinition().setParentName(parentName);
    		}
    		//获取自定义标签解析器中的class,此时会调用UserBeanDefinitionParser.getBeanClass
    		/*
    		org.example.custom.dtd.UserBeanDefinitionParser.getBeanClass
    		 */
    		//调用自定义类获取class对象
    		Class<?> beanClass = getBeanClass(element);
    		if (beanClass != null) {
        
    			builder.getRawBeanDefinition().setBeanClass(beanClass);
    		} else {
        
    			//若子类没有重写,则尝试子类是否重写了getBeanClassName方法
    			String beanClassName = getBeanClassName(element);
    			if (beanClassName != null) {
        
    				builder.getRawBeanDefinition().setBeanClassName(beanClassName);
    			}
    		}
    		builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));
    		BeanDefinition containingBd = parserContext.getContainingBeanDefinition();
    		//继承父类scope
    		if (containingBd != null) {
        
    			// Inner bean definition must receive same scope as containing bean.
    			builder.setScope(containingBd.getScope());
    		}
    		//配置延迟加载
    		if (parserContext.isDefaultLazyInit()) {
        
    			// Default-lazy-init applies to custom bean definitions as well.
    			builder.setLazyInit(true);
    		}
    		//调用子类重写的方法解析,这里调用了自定义的解析方法
    		doParse(element, parserContext, builder);
    		//内部做了loopup-method,replace-method,factory-method覆盖方法的校验
    		return builder.getBeanDefinition();
    	}

# spring如何解决循环依赖? #

创建bean的时候,通过提早暴露一个工厂对象  
这样后续填充属性的时候,如果遇到循环依赖会从工厂中获取对象,而因为工厂对象的初始地址是一样的,也就解决了循环依赖问题  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 6]

# BeanFactoryPostProcessors和BeanPostProcessors区别 #

BeanPostProcessors并不需要马上调用,所以不需要考虑硬编码方式  
BeanPostProcessor可以修改实际的bean实例

而BeanFactoryPostProcessors之所以考虑硬编码是因为不仅要实现注册功能，还要实现对后处理器的激活操作，所以需要载入配置中的定义,并进行激活  
BeanFactoryPostProcessor作用域容器级,仅仅对容器中的bean进行后置处理,如propertyPlaceholderConfig,继承order可实现排序调用功能

# spring加载xml过程 #

spring加载xml时,2个步骤  
第一步  
首先验证xml是否正确,会从网络或者本地获取xsd配置文件,也就是META-INF/spring.schemas  
第二步解析document获取Definitions  
解析默认命名空间和自定义命名空间  
自定义的命名空间,会从META-INF/spring.handlers获取命名空间解析器进行解析,这里也是对aop等标签的支持.

# spring获取对象过程 #

这里只有一个重要点就是循环依赖的问题,上述已有解答

# spring-aop执行过程(重点) #

在xml配置文件中扫描到aop标签的时候,会执行命名空间解析器,对应的根据aop标签注入AnnotationAwareAspectJAutoProxyCreator类,  
![在这里插入图片描述][20200716110510310.png]  
这个类继承BeanPostProcessor,也就是说会在每次加载bean的时候会执行后置方法postProcessAfterInitialization  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 7]  
进行切点表达式匹配并进行相应增强.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 8]  
增强的过程中会选择动态代理还是cglib  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 9]  
然后接着就是执行动态代理增强器链或者cglib增强器链

# cglib和动态代理区别 #

动态代理  
必须某接口实现,运行期间创建一个接口的实现类  
cglib  
运行期间生成的代理对象是针对目标类的扩展的子类,底层依赖ASM操作字节码实现,性能比jdk强,不能对声明为final的方法进行代理

## spring选择 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 10]  
实现接口,本身是接口,Proxy子类,则默认动态代理  
否则cglib,可强制设置使用cglib

# mybatis如何和spring整合? #

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200629145556571.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200629145804322.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70
[20200629145826349.png]: https://img-blog.csdnimg.cn/20200629145826349.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200629150002642.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200629150117840.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70
[20200629150252649.png]: https://img-blog.csdnimg.cn/20200629150252649.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200629143332522.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200629143459271.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200629143430509.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70
[20200716110510310.png]: https://img-blog.csdnimg.cn/20200716110510310.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/2020071611141876.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200716111445326.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200716111614549.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20200722221835114.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw==,size_16,color_FFFFFF,t_70