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

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

spring在解析doc的时候,会创建一个ReaderContext对象


ReaderContext对象创建的时候,会创建NamespaceHandlerResolver对象

在进行对象解析的时候,会分别解析默认命名空间和自定义的解析,也就是beans标签和非beans标签的解析

	/*
	获取所有已经配置的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;
	}

然后根据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的时候,通过提早暴露一个工厂对象
这样后续填充属性的时候,如果遇到循环依赖会从工厂中获取对象,而因为工厂对象的初始地址是一样的,也就解决了循环依赖问题

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类,

这个类继承BeanPostProcessor,也就是说会在每次加载bean的时候会执行后置方法postProcessAfterInitialization

进行切点表达式匹配并进行相应增强.

增强的过程中会选择动态代理还是cglib

然后接着就是执行动态代理增强器链或者cglib增强器链

cglib和动态代理区别

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

spring选择

实现接口,本身是接口,Proxy子类,则默认动态代理
否则cglib,可强制设置使用cglib

mybatis如何和spring整合?