Spring 源码解析

文章15 |   阅读 8473 |   点赞0

来源：https://github.com/senntyou/blogs

Spring 源码解析八：Xml 配置中默认的命名空间处理器

x33g5p2x  于2022-02-11 发布在 Spring  
字(42.8k)|赞(0)|评价(0)|浏览(471)

在 Spring 源码解析五：Bean 的配置、定义、注册 中，有一些 Xml 配置中默认的命名空间处理器还未解析

这里只解析常用的几个

  • SimpleConstructorNamespaceHandler
  • SimplePropertyNamespaceHandler
  • ContextNamespaceHandler
  • TaskNamespaceHandler
  • CacheNamespaceHandler
  • MvcNamespaceHandler

其他的有兴趣可以自行探索

1. SimpleConstructorNamespaceHandler

SimpleConstructorNamespaceHandler
的主要功能是在实例化如下配置的 bean

  1. <bean id="author" class="..TestBean" c:name="Enescu" c:work-ref="compositions"/>

将 name="Enescu", work=bean[compositions] 作为构造函数的参数实例化 bean

  1. public class SimpleConstructorNamespaceHandler implements NamespaceHandler {
  2.     @Override
  3.     public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definition, ParserContext parserContext) {
  4.         if (node instanceof Attr) {
  5.             Attr attr = (Attr) node;
  6.             // 去除两边空白
  7.             String argName = StringUtils.trimWhitespace(parserContext.getDelegate().getLocalName(attr));
  8.             // 去除两边空白
  9.             String argValue = StringUtils.trimWhitespace(attr.getValue());
  11.             // 构造函数参数集合
  12.             ConstructorArgumentValues cvs = definition.getBeanDefinition().getConstructorArgumentValues();
  13.             boolean ref = false;
  15.             // 如果字段名以"-ref"结果，则表示在运行时对其他bean的引用
  16.             if (argName.endsWith(REF_SUFFIX)) {
  17.                 ref = true;
  18.                 argName = argName.substring(0, argName.length() - REF_SUFFIX.length());
  19.             }
  21.             // 用ValueHolder封装值
  22.             ValueHolder valueHolder = new ValueHolder(ref ? new RuntimeBeanReference(argValue) : argValue);
  23.             valueHolder.setSource(parserContext.getReaderContext().extractSource(attr));
  25.             // 以"_"开头的，表示是没有名字的参数，按照顺序传入就可以了
  26.             if (argName.startsWith(DELIMITER_PREFIX)) {
  27.                 String arg = argName.substring(1).trim();
  29.                 // 如果没有指定顺序，直接添加
  30.                 if (!StringUtils.hasText(arg)) {
  31.                     cvs.addGenericArgumentValue(valueHolder);
  32.                 }
  33.                 // 如果有指定顺序，指定顺序添加
  34.                 else {
  35.                     int index = -1;
  36.                     try {
  37.                         index = Integer.parseInt(arg);
  38.                     }
  39.                     catch (NumberFormatException ex) {
  40.                         // ... 代码省略
  41.                     }
  43.                     // ... 代码省略
  45.                     // 添加进cvs
  46.                     cvs.addIndexedArgumentValue(index, valueHolder);
  47.                 }
  48.             }
  49.             // 有名字的参数
  50.             else {
  51.                 // ... 代码省略
  53.                 // 添加进cvs
  54.                 valueHolder.setName(Conventions.attributeNameToPropertyName(argName));
  55.                 cvs.addGenericArgumentValue(valueHolder);
  56.             }
  57.         }
  58.         return definition;
  59.     }
  60. }

2. SimplePropertyNamespaceHandler

SimplePropertyNamespaceHandler
的主要功能是在实例化如下配置的 bean

  1. <bean id="rob" class="..TestBean" p:name="Rob Harrop" p:spouse-ref="sally"/>

将 name="Rob Harrop", spouse=bean[sally] 作为属性注入到 bean 中

  1. public class SimplePropertyNamespaceHandler implements NamespaceHandler {
  2.     @Override
  3.     public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definition, ParserContext parserContext) {
  4.         if (node instanceof Attr) {
  5.             Attr attr = (Attr) node;
  6.             // 属性名
  7.             String propertyName = parserContext.getDelegate().getLocalName(attr);
  8.             // 属性值
  9.             String propertyValue = attr.getValue();
  10.             // 属性集合
  11.             MutablePropertyValues pvs = definition.getBeanDefinition().getPropertyValues();
  13.             // 如果字段名以"-ref"结果，则表示在运行时对其他bean的引用
  14.             if (propertyName.endsWith(REF_SUFFIX)) {
  15.                 propertyName = propertyName.substring(0, propertyName.length() - REF_SUFFIX.length());
  16.                 // 把字段名从短横线-或下划线_式的，转化为驼峰式的
  17.                 pvs.add(Conventions.attributeNameToPropertyName(propertyName), new RuntimeBeanReference(propertyValue));
  18.             }
  19.             else {
  20.                 // 把字段名从短横线-或下划线_式的，转化为驼峰式的
  21.                 pvs.add(Conventions.attributeNameToPropertyName(propertyName), propertyValue);
  22.             }
  23.         }
  24.         return definition;
  25.     }
  26. }

3. ContextNamespaceHandler

  1. public class ContextNamespaceHandler extends NamespaceHandlerSupport {
  2.     @Override
  3.     public void init() {
  4.         registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
  5.         registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
  6.         registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
  7.         registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
  8.         registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
  9.         registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
  10.         registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
  11.         registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
  12.     }
  13. }

3.1. context:property-placeholder

PropertyPlaceholderBeanDefinitionParser
的主要功能是解析<context:property-placeholder/>元素，在 bean 定义时，使用 ${} 引用外部来源的属性

先看看继承关系

  1. - AbstractBeanDefinitionParser
  2.   - AbstractSingleBeanDefinitionParser
  3.     - AbstractPropertyLoadingBeanDefinitionParser
  4.       - PropertyPlaceholderBeanDefinitionParser

3.1.1. AbstractBeanDefinitionParser

AbstractBeanDefinitionParser
的主要功能是实现了 BeanDefinitionParser
接口的 parse 方法，提供了基本的由配置解析为对象的功能

  1. public abstract class AbstractBeanDefinitionParser implements BeanDefinitionParser {
  2.     @Override
  3.     public final BeanDefinition parse(Element element, ParserContext parserContext) {
  4.         // 解析元素
  5.         AbstractBeanDefinition definition = parseInternal(element, parserContext);
  7.         try {
  8.             // 获取bean的id
  9.             String id = resolveId(element, definition, parserContext);
  11.             String[] aliases = null;
  12.             // 获取name属性，用逗号分隔为多个别名
  13.             if (shouldParseNameAsAliases()) {
  14.                 String name = element.getAttribute(NAME_ATTRIBUTE);
  15.                 if (StringUtils.hasLength(name)) {
  16.                     aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
  17.                 }
  18.             }
  20.             // 封装为BeanDefinitionHolder
  21.             BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);
  22.             // 注册到registry中
  23.             registerBeanDefinition(holder, parserContext.getRegistry());
  25.             // ... 代码省略
  26.         }
  27.         catch (BeanDefinitionStoreException ex) {
  28.             // ... 代码省略
  29.         }
  30.         return definition;
  31.     }
  33.     // 解析元素，由子类实现
  34.     protected abstract AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext);
  36.     // 获取bean的id，先获取id属性，其次name属性，都没有，生成默认的名字
  37.     protected String resolveId(Element element, AbstractBeanDefinition definition, ParserContext parserContext)
  38.             throws BeanDefinitionStoreException {
  39.         // ... 代码省略
  40.     }
  41. }

3.1.2. AbstractSingleBeanDefinitionParser

AbstractSingleBeanDefinitionParser
的主要功能是支持解析为单例的 bean

  1. public abstract class AbstractSingleBeanDefinitionParser extends AbstractBeanDefinitionParser {
  2.     @Override
  3.     protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
  4.         // 创建一个构造器
  5.         BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
  6.         // 父元素
  7.         String parentName = getParentName(element);
  8.         if (parentName != null) {
  9.             builder.getRawBeanDefinition().setParentName(parentName);
  10.         }
  11.         // beanClass
  12.         Class<?> beanClass = getBeanClass(element);
  13.         if (beanClass != null) {
  14.             builder.getRawBeanDefinition().setBeanClass(beanClass);
  15.         }
  16.         // beanClassName
  17.         else {
  18.             String beanClassName = getBeanClassName(element);
  19.             if (beanClassName != null) {
  20.                 builder.getRawBeanDefinition().setBeanClassName(beanClassName);
  21.             }
  22.         }
  24.         // ... 代码省略
  26.         // 解析到构造器
  27.         doParse(element, parserContext, builder);
  28.         return builder.getBeanDefinition();
  29.     }
  31.     // 解析到构造器，由子类实现
  32.     protected void doParse(Element element, BeanDefinitionBuilder builder) {}
  33. }

3.1.3. AbstractPropertyLoadingBeanDefinitionParser

AbstractPropertyLoadingBeanDefinitionParser
的主要功能是解析context:property-...元素

  1. abstract class AbstractPropertyLoadingBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {
  2.     @Override
  3.     protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
  4.         // location属性
  5.         String location = element.getAttribute("location");
  6.         if (StringUtils.hasLength(location)) {
  7.             location = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(location);
  8.             String[] locations = StringUtils.commaDelimitedListToStringArray(location);
  9.             builder.addPropertyValue("locations", locations);
  10.         }
  12.         // properties-ref属性
  13.         String propertiesRef = element.getAttribute("properties-ref");
  14.         if (StringUtils.hasLength(propertiesRef)) {
  15.             builder.addPropertyReference("properties", propertiesRef);
  16.         }
  18.         // file-encoding属性
  19.         String fileEncoding = element.getAttribute("file-encoding");
  20.         if (StringUtils.hasLength(fileEncoding)) {
  21.             builder.addPropertyValue("fileEncoding", fileEncoding);
  22.         }
  24.         // order属性
  25.         String order = element.getAttribute("order");
  26.         if (StringUtils.hasLength(order)) {
  27.             builder.addPropertyValue("order", Integer.valueOf(order));
  28.         }
  30.         // ignore-resource-not-found属性
  31.         builder.addPropertyValue("ignoreResourceNotFound",
  32.                 Boolean.valueOf(element.getAttribute("ignore-resource-not-found")));
  34.         // local-override属性
  35.         builder.addPropertyValue("localOverride",
  36.                 Boolean.valueOf(element.getAttribute("local-override")));
  37.     }
  38. }

3.1.4. PropertyPlaceholderBeanDefinitionParser

PropertyPlaceholderBeanDefinitionParser
的主要功能是解析context:property-placeholder元素

  1. class PropertyPlaceholderBeanDefinitionParser extends AbstractPropertyLoadingBeanDefinitionParser {
  2.     @Override
  3.     protected Class<?> getBeanClass(Element element) {
  4.         // 使用这个类来实现bean
  5.         return org.springframework.beans.factory.config.PropertyPlaceholderConfigurer.class;
  6.     }
  8.     @Override
  9.     protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
  10.         super.doParse(element, parserContext, builder);
  12.         // ignore-unresolvable属性
  13.         builder.addPropertyValue("ignoreUnresolvablePlaceholders",
  14.                 Boolean.valueOf(element.getAttribute("ignore-unresolvable")));
  16.         // system-properties-mode属性
  17.         String systemPropertiesModeName = element.getAttribute(SYSTEM_PROPERTIES_MODE_ATTRIBUTE);
  18.         if (StringUtils.hasLength(systemPropertiesModeName) &&
  19.                 !systemPropertiesModeName.equals(SYSTEM_PROPERTIES_MODE_DEFAULT)) {
  20.             builder.addPropertyValue("systemPropertiesModeName", "SYSTEM_PROPERTIES_MODE_" + systemPropertiesModeName);
  21.         }
  23.         // value-separator属性
  24.         if (element.hasAttribute("value-separator")) {
  25.             builder.addPropertyValue("valueSeparator", element.getAttribute("value-separator"));
  26.         }
  27.         // trim-values属性
  28.         if (element.hasAttribute("trim-values")) {
  29.             builder.addPropertyValue("trimValues", element.getAttribute("trim-values"));
  30.         }
  31.         // null-value属性
  32.         if (element.hasAttribute("null-value")) {
  33.             builder.addPropertyValue("nullValue", element.getAttribute("null-value"));
  34.         }
  35.     }
  36. }

3.2. context:property-override

PropertyOverrideBeanDefinitionParser
的主要功能是解析<context:property-override/>元素，为 xml 配置文件中的 bean 的属性指定最终结果

  1. class PropertyOverrideBeanDefinitionParser extends AbstractPropertyLoadingBeanDefinitionParser {
  2.     @Override
  3.     protected Class<?> getBeanClass(Element element) {
  4.         // 使用这个类来实现bean
  5.         return PropertyOverrideConfigurer.class;
  6.     }
  8.     @Override
  9.     protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
  10.         super.doParse(element, parserContext, builder);
  12.         // ignore-unresolvable属性
  13.         builder.addPropertyValue("ignoreInvalidKeys",
  14.                 Boolean.valueOf(element.getAttribute("ignore-unresolvable")));
  16.     }
  17. }

3.3. context:annotation-config

AnnotationConfigBeanDefinitionParser
的主要功能是解析<context:annotation-config/>元素，使用 @Autowired 自动装配 bean

  1. public class AnnotationConfigBeanDefinitionParser implements BeanDefinitionParser {
  2.     @Override
  3.     public BeanDefinition parse(Element element, ParserContext parserContext) {
  4.         Object source = parserContext.extractSource(element);
  6.         // 获取registry所有相关的bean定义
  7.         Set<BeanDefinitionHolder> processorDefinitions =
  8.                 AnnotationConfigUtils.registerAnnotationConfigProcessors(parserContext.getRegistry(), source);
  10.         // ... 代码省略
  12.         // 注册bean定义
  13.         for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
  14.             parserContext.registerComponent(new BeanComponentDefinition(processorDefinition));
  15.         }
  17.         // ... 代码省略
  19.         return null;
  20.     }
  21. }

3.4. context:component-scan

ComponentScanBeanDefinitionParser
的主要功能是解析<context:component-scan/>元素，自动扫描指定包下的注解 bean

  1. public class ComponentScanBeanDefinitionParser implements BeanDefinitionParser {
  2.     @Override
  3.     public BeanDefinition parse(Element element, ParserContext parserContext) {
  4.         // base-package属性
  5.         String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
  6.         basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
  7.         // 分隔多个包
  8.         String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
  9.                 ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
  11.         // 创建并配置扫描对象
  12.         ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
  13.         // 扫描包中的组件
  14.         Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
  15.         // 注册组件到上下文中
  16.         registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
  18.         return null;
  19.     }
  20. }

关于 context: 命令空间的解析就到这里了，其他的有兴趣可以自行探索

4. TaskNamespaceHandler

  1. public class TaskNamespaceHandler extends NamespaceHandlerSupport {
  2.     @Override
  3.     public void init() {
  4.         this.registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
  5.         this.registerBeanDefinitionParser("executor", new ExecutorBeanDefinitionParser());
  6.         this.registerBeanDefinitionParser("scheduled-tasks", new ScheduledTasksBeanDefinitionParser());
  7.         this.registerBeanDefinitionParser("scheduler", new SchedulerBeanDefinitionParser());
  8.     }
  9. }

4.1. task:annotation-driven

AnnotationDrivenBeanDefinitionParser
的主要功能是解析<task:annotation-driven/>元素，开启定时器开关，自动扫描程序中带注解的定时器

  1. public class AnnotationDrivenBeanDefinitionParser implements BeanDefinitionParser {
  2.     @Override
  3.     public BeanDefinition parse(Element element, ParserContext parserContext) {
  4.         Object source = parserContext.extractSource(element);
  6.         // ... 代码省略
  8.         // 获取registry
  9.         BeanDefinitionRegistry registry = parserContext.getRegistry();
  11.         // mode属性
  12.         String mode = element.getAttribute("mode");
  13.         // 使用aspectj来执行异步任务
  14.         if ("aspectj".equals(mode)) {
  15.             // mode="aspectj"
  16.             registerAsyncExecutionAspect(element, parserContext);
  17.         }
  18.         // 使用内置的功能来执行异步任务
  19.         else {
  20.             // bean "org.springframework.context.annotation.internalAsyncAnnotationProcessor" 已经存在
  21.             if (registry.containsBeanDefinition(TaskManagementConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  22.                 // ... 代码省略
  23.             }
  24.             else {
  25.                 // 使用类 "org.springframework.scheduling.annotation.AsyncAnnotationBeanPostProcessor"
  26.                 // 来配置bean "org.springframework.context.annotation.internalAsyncAnnotationProcessor"
  27.                 BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(
  28.                         "org.springframework.scheduling.annotation.AsyncAnnotationBeanPostProcessor");
  29.                 builder.getRawBeanDefinition().setSource(source);
  30.                 // executor属性
  31.                 String executor = element.getAttribute("executor");
  32.                 if (StringUtils.hasText(executor)) {
  33.                     builder.addPropertyReference("executor", executor);
  34.                 }
  35.                 // exception-handler属性
  36.                 String exceptionHandler = element.getAttribute("exception-handler");
  37.                 if (StringUtils.hasText(exceptionHandler)) {
  38.                     builder.addPropertyReference("exceptionHandler", exceptionHandler);
  39.                 }
  40.                 // proxy-target-class属性
  41.                 if (Boolean.parseBoolean(element.getAttribute(AopNamespaceUtils.PROXY_TARGET_CLASS_ATTRIBUTE))) {
  42.                     builder.addPropertyValue("proxyTargetClass", true);
  43.                 }
  44.                 // 注册组件到registry与上下文
  45.                 registerPostProcessor(parserContext, builder, TaskManagementConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME);
  46.             }
  47.         }
  49.         // bean "org.springframework.context.annotation.internalScheduledAnnotationProcessor" 已经存在
  50.         if (registry.containsBeanDefinition(TaskManagementConfigUtils.SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  51.             // ... 代码省略
  52.         }
  53.         else {
  54.             // 使用类 "org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor"
  55.             // 来配置bean "org.springframework.context.annotation.internalScheduledAnnotationProcessor"
  56.             BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(
  57.                     "org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor");
  58.             builder.getRawBeanDefinition().setSource(source);
  59.             // scheduler属性
  60.             String scheduler = element.getAttribute("scheduler");
  61.             if (StringUtils.hasText(scheduler)) {
  62.                 builder.addPropertyReference("scheduler", scheduler);
  63.             }
  64.             // 注册组件到registry与上下文
  65.             registerPostProcessor(parserContext, builder, TaskManagementConfigUtils.SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME);
  66.         }
  68.         // ... 代码省略
  70.         return null;
  71.     }
  73.     // 使用aspectj来执行异步任务
  74.     private void registerAsyncExecutionAspect(Element element, ParserContext parserContext) {
  75.         // bean "org.springframework.scheduling.config.internalAsyncExecutionAspect" 不存在
  76.         if (!parserContext.getRegistry().containsBeanDefinition(TaskManagementConfigUtils.ASYNC_EXECUTION_ASPECT_BEAN_NAME)) {
  77.             // 使用类 "org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect"
  78.             // 来配置bean "org.springframework.scheduling.config.internalAsyncExecutionAspect"
  79.             BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(ASYNC_EXECUTION_ASPECT_CLASS_NAME);
  80.             // 使用FactoryMethod来初始化bean
  81.             builder.setFactoryMethod("aspectOf");
  82.             // executor属性
  83.             String executor = element.getAttribute("executor");
  84.             if (StringUtils.hasText(executor)) {
  85.                 builder.addPropertyReference("executor", executor);
  86.             }
  87.             // exception-handler属性
  88.             String exceptionHandler = element.getAttribute("exception-handler");
  89.             if (StringUtils.hasText(exceptionHandler)) {
  90.                 builder.addPropertyReference("exceptionHandler", exceptionHandler);
  91.             }
  92.             // 注册bean
  93.             parserContext.registerBeanComponent(new BeanComponentDefinition(builder.getBeanDefinition(),
  94.                     TaskManagementConfigUtils.ASYNC_EXECUTION_ASPECT_BEAN_NAME));
  95.         }
  96.     }
  97. }

4.2. task:executor

ExecutorBeanDefinitionParser
的主要功能是解析<task:executor/>元素，用于配置任务执行器

  1. public class ExecutorBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {
  2.     @Override
  3.     protected String getBeanClassName(Element element) {
  4.         // 使用这个类来实现bean
  5.         return "org.springframework.scheduling.config.TaskExecutorFactoryBean";
  6.     }
  8.     @Override
  9.     protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
  10.         // keep-alive属性
  11.         String keepAliveSeconds = element.getAttribute("keep-alive");
  12.         if (StringUtils.hasText(keepAliveSeconds)) {
  13.             builder.addPropertyValue("keepAliveSeconds", keepAliveSeconds);
  14.         }
  15.         // queue-capacity属性
  16.         String queueCapacity = element.getAttribute("queue-capacity");
  17.         if (StringUtils.hasText(queueCapacity)) {
  18.             builder.addPropertyValue("queueCapacity", queueCapacity);
  19.         }
  20.         // 配置策略
  21.         configureRejectionPolicy(element, builder);
  22.         // pool-size属性
  23.         String poolSize = element.getAttribute("pool-size");
  24.         if (StringUtils.hasText(poolSize)) {
  25.             builder.addPropertyValue("poolSize", poolSize);
  26.         }
  27.     }
  29.     // 配置策略
  30.     private void configureRejectionPolicy(Element element, BeanDefinitionBuilder builder) {
  31.         // rejection-policy属性
  32.         String rejectionPolicy = element.getAttribute("rejection-policy");
  33.         if (!StringUtils.hasText(rejectionPolicy)) {
  34.             return;
  35.         }
  36.         String prefix = "java.util.concurrent.ThreadPoolExecutor.";
  37.         String policyClassName;
  38.         if (rejectionPolicy.equals("ABORT")) {
  39.             policyClassName = prefix + "AbortPolicy";
  40.         }
  41.         else if (rejectionPolicy.equals("CALLER_RUNS")) {
  42.             policyClassName = prefix + "CallerRunsPolicy";
  43.         }
  44.         else if (rejectionPolicy.equals("DISCARD")) {
  45.             policyClassName = prefix + "DiscardPolicy";
  46.         }
  47.         else if (rejectionPolicy.equals("DISCARD_OLDEST")) {
  48.             policyClassName = prefix + "DiscardOldestPolicy";
  49.         }
  50.         else {
  51.             policyClassName = rejectionPolicy;
  52.         }
  53.         builder.addPropertyValue("rejectedExecutionHandler", new RootBeanDefinition(policyClassName));
  54.     }
  56. }

4.3. task:scheduled-tasks

ScheduledTasksBeanDefinitionParser
的主要功能是解析<task:scheduled-tasks/>元素，执行定时器任务

  1. public class ScheduledTasksBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {
  2.     @Override
  3.     protected String getBeanClassName(Element element) {
  4.         // 使用这个类来实现bean
  5.         return "org.springframework.scheduling.config.ContextLifecycleScheduledTaskRegistrar";
  6.     }
  8.     @Override
  9.     protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
  10.         // cron任务
  11.         ManagedList<RuntimeBeanReference> cronTaskList = new ManagedList<>();
  12.         // 固定延迟任务
  13.         ManagedList<RuntimeBeanReference> fixedDelayTaskList = new ManagedList<>();
  14.         // 固定频率任务
  15.         ManagedList<RuntimeBeanReference> fixedRateTaskList = new ManagedList<>();
  16.         // 触发任务
  17.         ManagedList<RuntimeBeanReference> triggerTaskList = new ManagedList<>();
  19.         // 遍历子元素
  20.         NodeList childNodes = element.getChildNodes();
  21.         for (int i = 0; i < childNodes.getLength(); i++) {
  22.             Node child = childNodes.item(i);
  24.             Element taskElement = (Element) child;
  25.             // ref属性
  26.             String ref = taskElement.getAttribute("ref");
  27.             // method属性
  28.             String method = taskElement.getAttribute("method");
  30.             // ... 代码省略
  32.             // cron属性
  33.             String cronAttribute = taskElement.getAttribute("cron");
  34.             // fixed-delay属性
  35.             String fixedDelayAttribute = taskElement.getAttribute("fixed-delay");
  36.             // fixed-rate属性
  37.             String fixedRateAttribute = taskElement.getAttribute("fixed-rate");
  38.             // trigger属性
  39.             String triggerAttribute = taskElement.getAttribute("trigger");
  40.             // initial-delay属性
  41.             String initialDelayAttribute = taskElement.getAttribute("initial-delay");
  43.             boolean hasCronAttribute = StringUtils.hasText(cronAttribute);
  44.             boolean hasFixedDelayAttribute = StringUtils.hasText(fixedDelayAttribute);
  45.             boolean hasFixedRateAttribute = StringUtils.hasText(fixedRateAttribute);
  46.             boolean hasTriggerAttribute = StringUtils.hasText(triggerAttribute);
  47.             boolean hasInitialDelayAttribute = StringUtils.hasText(initialDelayAttribute);
  49.             // ... 代码省略
  51.             // 使用类 "org.springframework.scheduling.support.ScheduledMethodRunnable"
  52.             // 实例化定时器bean
  53.             String runnableName =
  54.                     runnableReference(ref, method, taskElement, parserContext).getBeanName();
  56.             if (hasFixedDelayAttribute) {
  57.                 // 使用类 "org.springframework.scheduling.config.IntervalTask"
  58.                 // 实例化固定延迟执行器bean
  59.                 fixedDelayTaskList.add(intervalTaskReference(runnableName,
  60.                         initialDelayAttribute, fixedDelayAttribute, taskElement, parserContext));
  61.             }
  62.             if (hasFixedRateAttribute) {
  63.                 // 使用类 "org.springframework.scheduling.config.IntervalTask"
  64.                 // 实例化固定频率执行器bean
  65.                 fixedRateTaskList.add(intervalTaskReference(runnableName,
  66.                         initialDelayAttribute, fixedRateAttribute, taskElement, parserContext));
  67.             }
  68.             if (hasCronAttribute) {
  69.                 // 使用类 "org.springframework.scheduling.config.CronTask"
  70.                 // 实例化cron执行器bean
  71.                 cronTaskList.add(cronTaskReference(runnableName, cronAttribute,
  72.                         taskElement, parserContext));
  73.             }
  74.             if (hasTriggerAttribute) {
  75.                 // 使用类 "org.springframework.scheduling.config.TriggerTask"
  76.                 // 实例化触发执行器bean
  77.                 String triggerName = new RuntimeBeanReference(triggerAttribute).getBeanName();
  78.                 triggerTaskList.add(triggerTaskReference(runnableName, triggerName,
  79.                         taskElement, parserContext));
  80.             }
  81.         }
  82.         // scheduler属性
  83.         String schedulerRef = element.getAttribute("scheduler");
  84.         if (StringUtils.hasText(schedulerRef)) {
  85.             builder.addPropertyReference("taskScheduler", schedulerRef);
  86.         }
  87.         builder.addPropertyValue("cronTasksList", cronTaskList);
  88.         builder.addPropertyValue("fixedDelayTasksList", fixedDelayTaskList);
  89.         builder.addPropertyValue("fixedRateTasksList", fixedRateTaskList);
  90.         builder.addPropertyValue("triggerTasksList", triggerTaskList);
  91.     }
  92. }

4.4. task:scheduler

SchedulerBeanDefinitionParser
的主要功能是解析<task:scheduler/>元素，配置调度线程池

  1. public class SchedulerBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {
  2.     @Override
  3.     protected String getBeanClassName(Element element) {
  4.         // 使用这个类来实现bean
  5.         return "org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler";
  6.     }
  8.     @Override
  9.     protected void doParse(Element element, BeanDefinitionBuilder builder) {
  10.         // pool-size属性
  11.         String poolSize = element.getAttribute("pool-size");
  12.         if (StringUtils.hasText(poolSize)) {
  13.             builder.addPropertyValue("poolSize", poolSize);
  14.         }
  15.     }
  16. }

5. CacheNamespaceHandler

  1. public class CacheNamespaceHandler extends NamespaceHandlerSupport {
  2.     @Override
  3.     public void init() {
  4.         registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenCacheBeanDefinitionParser());
  5.         registerBeanDefinitionParser("advice", new CacheAdviceParser());
  6.     }
  7. }

5.1. cache:annotation-driven

AnnotationDrivenCacheBeanDefinitionParser
的主要功能是解析<cache:annotation-driven/>元素，支持注解注 @Cacheable、@CacheEvict、@CacheUpdate

  1. class AnnotationDrivenCacheBeanDefinitionParser implements BeanDefinitionParser {
  2.     @Override
  3.     public BeanDefinition parse(Element element, ParserContext parserContext) {
  4.         // mode属性
  5.         String mode = element.getAttribute("mode");
  6.         // 使用aspectj来执行
  7.         if ("aspectj".equals(mode)) {
  8.             registerCacheAspect(element, parserContext);
  9.         }
  10.         // 使用内置的功能来执行
  11.         else {
  12.             registerCacheAdvisor(element, parserContext);
  13.         }
  15.         return null;
  16.     }
  18.     // 使用aspectj来执行
  19.     private void registerCacheAspect(Element element, ParserContext parserContext) {
  20.         SpringCachingConfigurer.registerCacheAspect(element, parserContext);
  21.     }
  23.     // 使用内置的功能来执行
  24.     private void registerCacheAdvisor(Element element, ParserContext parserContext) {
  25.         AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);
  26.         SpringCachingConfigurer.registerCacheAdvisor(element, parserContext);
  27.     }
  29.     // 解析cache-resolver属性
  30.     private static void parseCacheResolution(Element element, BeanDefinition def, boolean setBoth) {
  31.         String name = element.getAttribute("cache-resolver");
  32.         boolean hasText = StringUtils.hasText(name);
  33.         if (hasText) {
  34.             def.getPropertyValues().add("cacheResolver", new RuntimeBeanReference(name.trim()));
  35.         }
  36.         if (!hasText || setBoth) {
  37.             def.getPropertyValues().add("cacheManager",
  38.                     new RuntimeBeanReference(CacheNamespaceHandler.extractCacheManager(element)));
  39.         }
  40.     }
  41. }

内部类 JCacheCachingConfigurer

  1. private static class JCacheCachingConfigurer {
  2.     // 使用内置的功能来执行
  3.     private static void registerCacheAdvisor(Element element, ParserContext parserContext) {
  4.         // bean "org.springframework.cache.config.internalJCacheAdvisor" 不存在
  5.         if (!parserContext.getRegistry().containsBeanDefinition(CacheManagementConfigUtils.JCACHE_ADVISOR_BEAN_NAME)) {
  6.             Object source = parserContext.extractSource(element);
  8.             // 创建一个JCache执行的bean
  9.             BeanDefinition sourceDef = createJCacheOperationSourceBeanDefinition(element, source);
  10.             // 获取bean名字
  11.             String sourceName = parserContext.getReaderContext().registerWithGeneratedName(sourceDef);
  13.             // 使用 "org.springframework.cache.jcache.interceptor.JCacheInterceptor"
  14.             // 创建CacheInterceptor的bean定义
  15.             RootBeanDefinition interceptorDef =
  16.                     new RootBeanDefinition("org.springframework.cache.jcache.interceptor.JCacheInterceptor");
  18.             // ... 代码省略
  20.             // 获取bean名字
  21.             String interceptorName = parserContext.getReaderContext().registerWithGeneratedName(interceptorDef);
  23.             // 使用 "org.springframework.cache.jcache.interceptor.BeanFactoryJCacheOperationSourceAdvisor"
  24.             // 创建CacheAdvisor定义
  25.             RootBeanDefinition advisorDef = new RootBeanDefinition(
  26.                     "org.springframework.cache.jcache.interceptor.BeanFactoryJCacheOperationSourceAdvisor");
  28.             // ... 代码省略
  30.             // 注册bean "org.springframework.cache.config.internalJCacheAdvisor"
  31.             parserContext.getRegistry().registerBeanDefinition(CacheManagementConfigUtils.JCACHE_ADVISOR_BEAN_NAME, advisorDef);
  33.             // 注册复合bean sourceDef+interceptorDef+advisorDef
  34.             CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), source);
  35.             compositeDef.addNestedComponent(new BeanComponentDefinition(sourceDef, sourceName));
  36.             compositeDef.addNestedComponent(new BeanComponentDefinition(interceptorDef, interceptorName));
  37.             compositeDef.addNestedComponent(new BeanComponentDefinition(advisorDef, CacheManagementConfigUtils.JCACHE_ADVISOR_BEAN_NAME));
  38.             parserContext.registerComponent(compositeDef);
  39.         }
  40.     }
  42.     // 使用aspectj来执行
  43.     private static void registerCacheAspect(Element element, ParserContext parserContext) {
  44.         // bean "org.springframework.cache.config.internalJCacheAspect" 不存在
  45.         if (!parserContext.getRegistry().containsBeanDefinition(CacheManagementConfigUtils.JCACHE_ASPECT_BEAN_NAME)) {
  46.             Object eleSource = parserContext.extractSource(element);
  47.             RootBeanDefinition def = new RootBeanDefinition();
  49.             // 使用 "org.springframework.cache.aspectj.JCacheCacheAspect"
  50.             // 来创建bean
  51.             def.setBeanClassName(JCACHE_ASPECT_CLASS_NAME);
  52.             // 使用FactoryMethod来初始化bean
  53.             def.setFactoryMethodName("aspectOf");
  54.             // 创建一个JCache执行的bean
  55.             BeanDefinition sourceDef = createJCacheOperationSourceBeanDefinition(element, eleSource);
  56.             String sourceName =
  57.                     parserContext.getReaderContext().registerWithGeneratedName(sourceDef);
  59.             // 注册bean "org.springframework.cache.jcache.interceptor.DefaultJCacheOperationSource"
  60.             parserContext.registerBeanComponent(new BeanComponentDefinition(sourceDef, sourceName));
  61.             // 注册bean "org.springframework.cache.config.internalJCacheAspect"
  62.             parserContext.registerBeanComponent(new BeanComponentDefinition(def, CacheManagementConfigUtils.JCACHE_ASPECT_BEAN_NAME));
  63.         }
  64.     }
  66.     // 创建一个JCache执行的bean
  67.     private static RootBeanDefinition createJCacheOperationSourceBeanDefinition(Element element, @Nullable Object eleSource) {
  68.         // 使用 "org.springframework.cache.jcache.interceptor.DefaultJCacheOperationSource""
  69.         // 来创建bean
  70.         RootBeanDefinition sourceDef =
  71.                 new RootBeanDefinition("org.springframework.cache.jcache.interceptor.DefaultJCacheOperationSource");
  73.         // ... 代码省略
  75.         // 解析cache-resolver属性
  76.         CacheNamespaceHandler.parseKeyGenerator(element, sourceDef);
  77.         return sourceDef;
  78.     }
  79. }

5.2. cache:advice

CacheAdviceParser
的主要功能是解析<cache:advice/>元素，配置缓存

  1. class CacheAdviceParser extends AbstractSingleBeanDefinitionParser {
  2.     @Override
  3.     protected Class<?> getBeanClass(Element element) {
  4.         // 使用这个类来实现bean
  5.         return CacheInterceptor.class;
  6.     }
  8.     @Override
  9.     protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
  10.         // cache-manager属性
  11.         builder.addPropertyReference("cacheManager", CacheNamespaceHandler.extractCacheManager(element));
  13.         // caching元素
  14.         List<Element> cacheDefs = DomUtils.getChildElementsByTagName(element, DEFS_ELEMENT);
  15.         // 有caching元素
  16.         if (!cacheDefs.isEmpty()) {
  17.             // 把caching元素转化成bean
  18.             List<RootBeanDefinition> attributeSourceDefinitions = parseDefinitionsSources(cacheDefs, parserContext);
  19.             builder.addPropertyValue("cacheOperationSources", attributeSourceDefinitions);
  20.         }
  21.         else {
  22.             // 没有caching元素，用 "org.springframework.cache.annotation.AnnotationCacheOperationSource"
  23.             // 创建一个默认的bean
  24.             builder.addPropertyValue("cacheOperationSources",
  25.                     new RootBeanDefinition("org.springframework.cache.annotation.AnnotationCacheOperationSource"));
  26.         }
  27.     }
  29.     // 把caching元素转化成bean
  30.     private List<RootBeanDefinition> parseDefinitionsSources(List<Element> definitions, ParserContext parserContext) {
  31.         ManagedList<RootBeanDefinition> defs = new ManagedList<>(definitions.size());
  33.         // 遍历
  34.         for (Element element : definitions) {
  35.             defs.add(parseDefinitionSource(element, parserContext));
  36.         }
  38.         return defs;
  39.     }
  41.     // 把caching元素转化成bean
  42.     private RootBeanDefinition parseDefinitionSource(Element definition, ParserContext parserContext) {
  43.         // ... 代码省略
  44.     }
  45. }

6. MvcNamespaceHandler

  1. public class MvcNamespaceHandler extends NamespaceHandlerSupport {
  2.     @Override
  3.     public void init() {
  4.         registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
  5.         registerBeanDefinitionParser("default-servlet-handler", new DefaultServletHandlerBeanDefinitionParser());
  6.         registerBeanDefinitionParser("interceptors", new InterceptorsBeanDefinitionParser());
  7.         registerBeanDefinitionParser("resources", new ResourcesBeanDefinitionParser());
  8.         registerBeanDefinitionParser("view-controller", new ViewControllerBeanDefinitionParser());
  9.         registerBeanDefinitionParser("redirect-view-controller", new ViewControllerBeanDefinitionParser());
  10.         registerBeanDefinitionParser("status-controller", new ViewControllerBeanDefinitionParser());
  11.         registerBeanDefinitionParser("view-resolvers", new ViewResolversBeanDefinitionParser());
  12.         registerBeanDefinitionParser("tiles-configurer", new TilesConfigurerBeanDefinitionParser());
  13.         registerBeanDefinitionParser("freemarker-configurer", new FreeMarkerConfigurerBeanDefinitionParser());
  14.         registerBeanDefinitionParser("groovy-configurer", new GroovyMarkupConfigurerBeanDefinitionParser());
  15.         registerBeanDefinitionParser("script-template-configurer", new ScriptTemplateConfigurerBeanDefinitionParser());
  16.         registerBeanDefinitionParser("cors", new CorsBeanDefinitionParser());
  17.     }
  18. }

mvc 命名空间的处理器内容较多，这里只解析第一个 mvc:annotation-driven，其他的有兴趣可以自行探索

AnnotationDrivenBeanDefinitionParser
的主要功能是解析<mvc:annotation-driven/>元素，启用注解驱动，通过context:component-scan标签的配置，自动扫描
@Component，@Controller，@Service，@Repository等注解标记的组件注册到工厂中，来处理请求

  1. class AnnotationDrivenBeanDefinitionParser implements BeanDefinitionParser {
  2.     @Override
  3.     public BeanDefinition parse(Element element, ParserContext context) {
  4.         // 元素元信息
  5.         Object source = context.extractSource(element);
  6.         XmlReaderContext readerContext = context.getReaderContext();
  8.         // ... 代码省略
  10.         // 请求映射处理器bean
  11.         RootBeanDefinition handlerMappingDef = new RootBeanDefinition(RequestMappingHandlerMapping.class);
  13.         // ... 代码省略
  15.         // enable-matrix-variables属性
  16.         if (element.hasAttribute("enable-matrix-variables")) {
  17.             boolean enableMatrixVariables = Boolean.parseBoolean(element.getAttribute("enable-matrix-variables"));
  18.             handlerMappingDef.getPropertyValues().add("removeSemicolonContent", !enableMatrixVariables);
  19.         }
  21.         // 配置路径映射
  22.         configurePathMatchingProperties(handlerMappingDef, element, context);
  23.         // 注册RequestMappingHandlerMapping.class bean
  24.         readerContext.getRegistry().registerBeanDefinition(HANDLER_MAPPING_BEAN_NAME, handlerMappingDef);
  26.         // ... 代码省略
  28.         // 获取数据转换服务
  29.         RuntimeBeanReference conversionService = getConversionService(element, source, context);
  30.         // 获取验证器
  31.         RuntimeBeanReference validator = getValidator(element, source, context);
  32.         // 获取文本解析器
  33.         RuntimeBeanReference messageCodesResolver = getMessageCodesResolver(element);
  35.         // 注册ConfigurableWebBindingInitializer.class bean
  36.         RootBeanDefinition bindingDef = new RootBeanDefinition(ConfigurableWebBindingInitializer.class);
  38.         // ... 代码省略
  40.         // 载入conversionService、validator、messageCodesResolver
  41.         bindingDef.getPropertyValues().add("conversionService", conversionService);
  42.         bindingDef.getPropertyValues().add("validator", validator);
  43.         bindingDef.getPropertyValues().add("messageCodesResolver", messageCodesResolver);
  45.         // 配置消息转换器
  46.         ManagedList<?> messageConverters = getMessageConverters(element, source, context);
  47.         // argument-resolvers子元素配置的自定义参数解析器
  48.         ManagedList<?> argumentResolvers = getArgumentResolvers(element, context);
  49.         // return-value-handlers子元素配置的自定义响应解析器
  50.         ManagedList<?> returnValueHandlers = getReturnValueHandlers(element, context);
  51.         // async-support子元素配置的异步任务超时时间
  52.         String asyncTimeout = getAsyncTimeout(element);
  53.         // async-support子元素配置的异步任务执行器
  54.         RuntimeBeanReference asyncExecutor = getAsyncExecutor(element);
  55.         // async-support子元素配置的callable-interceptors请求拦截器
  56.         ManagedList<?> callableInterceptors = getInterceptors(element, source, context, "callable-interceptors");
  57.         // async-support子元素配置的deferred-result-interceptors响应拦截器
  58.         ManagedList<?> deferredResultInterceptors = getInterceptors(element, source, context, "deferred-result-interceptors");
  60.         // 注册RequestMappingHandlerAdapter.class bean
  61.         RootBeanDefinition handlerAdapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
  62.         // 载入contentNegotiationManager、bindingDef、messageConverters
  63.         handlerAdapterDef.getPropertyValues().add("contentNegotiationManager", contentNegotiationManager);
  64.         handlerAdapterDef.getPropertyValues().add("webBindingInitializer", bindingDef);
  65.         handlerAdapterDef.getPropertyValues().add("messageConverters", messageConverters);
  66.         // 载入jackson请求处理
  67.         addRequestBodyAdvice(handlerAdapterDef);
  68.         // 载入jackson响应处理
  69.         addResponseBodyAdvice(handlerAdapterDef);
  71.         // ignore-default-model-on-redirect属性
  72.         if (element.hasAttribute("ignore-default-model-on-redirect")) {
  73.             Boolean ignoreDefaultModel = Boolean.valueOf(element.getAttribute("ignore-default-model-on-redirect"));
  74.             handlerAdapterDef.getPropertyValues().add("ignoreDefaultModelOnRedirect", ignoreDefaultModel);
  75.         }
  76.         if (argumentResolvers != null) {
  77.             handlerAdapterDef.getPropertyValues().add("customArgumentResolvers", argumentResolvers);
  78.         }
  79.         if (returnValueHandlers != null) {
  80.             handlerAdapterDef.getPropertyValues().add("customReturnValueHandlers", returnValueHandlers);
  81.         }
  82.         if (asyncTimeout != null) {
  83.             handlerAdapterDef.getPropertyValues().add("asyncRequestTimeout", asyncTimeout);
  84.         }
  85.         if (asyncExecutor != null) {
  86.             handlerAdapterDef.getPropertyValues().add("taskExecutor", asyncExecutor);
  87.         }
  89.         handlerAdapterDef.getPropertyValues().add("callableInterceptors", callableInterceptors);
  90.         handlerAdapterDef.getPropertyValues().add("deferredResultInterceptors", deferredResultInterceptors);
  92.         // 注册RequestMappingHandlerAdapter.class bean
  93.         readerContext.getRegistry().registerBeanDefinition(HANDLER_ADAPTER_BEAN_NAME, handlerAdapterDef);
  95.         // 注册CompositeUriComponentsContributorFactoryBean.class bean
  96.         RootBeanDefinition uriContributorDef =
  97.                 new RootBeanDefinition(CompositeUriComponentsContributorFactoryBean.class);
  98.         uriContributorDef.setSource(source);
  99.         uriContributorDef.getPropertyValues().addPropertyValue("handlerAdapter", handlerAdapterDef);
  100.         uriContributorDef.getPropertyValues().addPropertyValue("conversionService", conversionService);
  102.         // 注册mvcUriComponentsContributor bean
  103.         String uriContributorName = MvcUriComponentsBuilder.MVC_URI_COMPONENTS_CONTRIBUTOR_BEAN_NAME;
  104.         readerContext.getRegistry().registerBeanDefinition(uriContributorName, uriContributorDef);
  106.         // 注册ConversionServiceExposingInterceptor.class bean
  107.         RootBeanDefinition csInterceptorDef = new RootBeanDefinition(ConversionServiceExposingInterceptor.class);
  108.         csInterceptorDef.setSource(source);
  109.         csInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(0, conversionService);
  111.         // 注册MappedInterceptor.class bean
  112.         RootBeanDefinition mappedInterceptorDef = new RootBeanDefinition(MappedInterceptor.class);
  114.         // ... 代码省略
  116.         // 注册ExceptionHandlerExceptionResolver.class bean
  117.         RootBeanDefinition methodExceptionResolver = new RootBeanDefinition(ExceptionHandlerExceptionResolver.class);
  119.         // ... 代码省略
  121.         // 注册ResponseStatusExceptionResolver.class bean
  122.         RootBeanDefinition statusExceptionResolver = new RootBeanDefinition(ResponseStatusExceptionResolver.class);
  124.         // ... 代码省略
  126.         // 注册DefaultHandlerExceptionResolver.class bean
  127.         RootBeanDefinition defaultExceptionResolver = new RootBeanDefinition(DefaultHandlerExceptionResolver.class);
  129.         // ... 代码省略
  131.         // 注册一系列bean
  132.         context.registerComponent(new BeanComponentDefinition(handlerMappingDef, HANDLER_MAPPING_BEAN_NAME));
  133.         context.registerComponent(new BeanComponentDefinition(handlerAdapterDef, HANDLER_ADAPTER_BEAN_NAME));
  134.         context.registerComponent(new BeanComponentDefinition(uriContributorDef, uriContributorName));
  135.         context.registerComponent(new BeanComponentDefinition(mappedInterceptorDef, mappedInterceptorName));
  136.         context.registerComponent(new BeanComponentDefinition(methodExceptionResolver, methodExResolverName));
  137.         context.registerComponent(new BeanComponentDefinition(statusExceptionResolver, statusExResolverName));
  138.         context.registerComponent(new BeanComponentDefinition(defaultExceptionResolver, defaultExResolverName));
  140.         // ... 代码省略
  142.         context.popAndRegisterContainingComponent();
  144.         return null;
  145.     }
  146. }
  1. class AnnotationDrivenBeanDefinitionParser implements BeanDefinitionParser {
  2.     // 配置路径映射
  3.     private void configurePathMatchingProperties(
  4.             RootBeanDefinition handlerMappingDef, Element element, ParserContext context) {
  5.         // 获取path-matching子元素
  6.         Element pathMatchingElement = DomUtils.getChildElementByTagName(element, "path-matching");
  7.         if (pathMatchingElement != null) {
  8.             Object source = context.extractSource(element);
  10.             // suffix-pattern属性
  11.             if (pathMatchingElement.hasAttribute("suffix-pattern")) {
  12.                 Boolean useSuffixPatternMatch = Boolean.valueOf(pathMatchingElement.getAttribute("suffix-pattern"));
  13.                 handlerMappingDef.getPropertyValues().add("useSuffixPatternMatch", useSuffixPatternMatch);
  14.             }
  15.             // trailing-slash属性
  16.             if (pathMatchingElement.hasAttribute("trailing-slash")) {
  17.                 Boolean useTrailingSlashMatch = Boolean.valueOf(pathMatchingElement.getAttribute("trailing-slash"));
  18.                 handlerMappingDef.getPropertyValues().add("useTrailingSlashMatch", useTrailingSlashMatch);
  19.             }
  20.             // registered-suffixes-only属性
  21.             if (pathMatchingElement.hasAttribute("registered-suffixes-only")) {
  22.                 Boolean useRegisteredSuffixPatternMatch = Boolean.valueOf(pathMatchingElement.getAttribute("registered-suffixes-only"));
  23.                 handlerMappingDef.getPropertyValues().add("useRegisteredSuffixPatternMatch", useRegisteredSuffixPatternMatch);
  24.             }
  26.             RuntimeBeanReference pathHelperRef = null;
  27.             // path-helper属性
  28.             if (pathMatchingElement.hasAttribute("path-helper")) {
  29.                 pathHelperRef = new RuntimeBeanReference(pathMatchingElement.getAttribute("path-helper"));
  30.             }
  31.             pathHelperRef = MvcNamespaceUtils.registerUrlPathHelper(pathHelperRef, context, source);
  32.             handlerMappingDef.getPropertyValues().add("urlPathHelper", pathHelperRef);
  34.             RuntimeBeanReference pathMatcherRef = null;
  35.             // path-matcher属性
  36.             if (pathMatchingElement.hasAttribute("path-matcher")) {
  37.                 pathMatcherRef = new RuntimeBeanReference(pathMatchingElement.getAttribute("path-matcher"));
  38.             }
  39.             pathMatcherRef = MvcNamespaceUtils.registerPathMatcher(pathMatcherRef, context, source);
  40.             handlerMappingDef.getPropertyValues().add("pathMatcher", pathMatcherRef);
  41.         }
  42.     }
  44.     // 获取数据转换服务
  45.     private RuntimeBeanReference getConversionService(Element element, @Nullable Object source, ParserContext context) {
  46.         RuntimeBeanReference conversionServiceRef;
  47.         // 有配置conversion-service属性
  48.         if (element.hasAttribute("conversion-service")) {
  49.             conversionServiceRef = new RuntimeBeanReference(element.getAttribute("conversion-service"));
  50.         }
  51.         else {
  52.             // 没有就用FormattingConversionServiceFactoryBean创建一个默认的
  53.             RootBeanDefinition conversionDef = new RootBeanDefinition(FormattingConversionServiceFactoryBean.class);
  55.             // ... 代码省略
  57.             conversionServiceRef = new RuntimeBeanReference(conversionName);
  58.         }
  59.         return conversionServiceRef;
  60.     }
  62.     // 获取验证器
  63.     private RuntimeBeanReference getValidator(Element element, @Nullable Object source, ParserContext context) {
  64.         // 有配置validator属性
  65.         if (element.hasAttribute("validator")) {
  66.             return new RuntimeBeanReference(element.getAttribute("validator"));
  67.         }
  68.         else if (javaxValidationPresent) {
  69.             // 没有就用OptionalValidatorFactoryBean创建一个默认的
  70.             RootBeanDefinition validatorDef = new RootBeanDefinition(
  71.                     "org.springframework.validation.beanvalidation.OptionalValidatorFactoryBean");
  73.             // ... 代码省略
  75.             return new RuntimeBeanReference(validatorName);
  76.         }
  77.         else {
  78.             return null;
  79.         }
  80.     }
  82.     // 获取文本解析器
  83.     private RuntimeBeanReference getMessageCodesResolver(Element element) {
  84.         // 有配置message-codes-resolver属性
  85.         if (element.hasAttribute("message-codes-resolver")) {
  86.             return new RuntimeBeanReference(element.getAttribute("message-codes-resolver"));
  87.         }
  88.         else {
  89.             return null;
  90.         }
  91.     }
  92. }
  1. class AnnotationDrivenBeanDefinitionParser implements BeanDefinitionParser {
  2.     // 配置消息转换器
  3.     private ManagedList<?> getMessageConverters(Element element, @Nullable Object source, ParserContext context) {
  4.         // message-converters子元素
  5.         Element convertersElement = DomUtils.getChildElementByTagName(element, "message-converters");
  6.         // 结果集
  7.         ManagedList<Object> messageConverters = new ManagedList<>();
  9.         // 有message-converters子元素
  10.         if (convertersElement != null) {
  11.             // 把bean、ref子元素转换为bean，加入结果集
  12.             for (Element beanElement : DomUtils.getChildElementsByTagName(convertersElement, "bean", "ref")) {
  13.                 Object object = context.getDelegate().parsePropertySubElement(beanElement, null);
  14.                 messageConverters.add(object);
  15.             }
  16.         }
  18.         // 有message-converters子元素，但有register-defaults属性
  19.         if (convertersElement == null || Boolean.parseBoolean(convertersElement.getAttribute("register-defaults"))) {
  20.             // 添加ByteArrayHttpMessageConverter.class bean到结果集
  21.             // 字节数组转换器
  22.             messageConverters.add(createConverterDefinition(ByteArrayHttpMessageConverter.class, source));
  24.             // 添加StringHttpMessageConverter.class bean到结果集
  25.             // 字符转换器
  26.             RootBeanDefinition stringConverterDef = createConverterDefinition(StringHttpMessageConverter.class, source);
  27.             stringConverterDef.getPropertyValues().add("writeAcceptCharset", false);
  28.             messageConverters.add(stringConverterDef);
  30.             // 添加ResourceHttpMessageConverter.class bean到结果集
  31.             // 资源转换器
  32.             messageConverters.add(createConverterDefinition(ResourceHttpMessageConverter.class, source));
  33.             // 添加ResourceRegionHttpMessageConverter.class bean到结果集
  34.             // 资源区域转换器
  35.             messageConverters.add(createConverterDefinition(ResourceRegionHttpMessageConverter.class, source));
  36.             // 添加SourceHttpMessageConverter.class bean到结果集
  37.             // javax.xml.transform.Source转换器
  38.             messageConverters.add(createConverterDefinition(SourceHttpMessageConverter.class, source));
  39.             // 添加AllEncompassingFormHttpMessageConverter.class bean到结果集
  40.             // form-data转换器
  41.             messageConverters.add(createConverterDefinition(AllEncompassingFormHttpMessageConverter.class, source));
  43.             // ... 代码省略
  45.             if (jackson2XmlPresent) {
  46.                 // 添加jackson2Xml转换器
  47.             }
  49.             // ... 代码省略
  51.             if (jackson2Present) {
  52.                 // 添加jackson2转换器
  53.             }
  54.             else if (gsonPresent) {
  55.                 // 添加gson转换器
  56.             }
  58.             // ... 代码省略
  59.         }
  60.         return messageConverters;
  61.     }
  62. }

后续

更多博客，查看 https://github.com/senntyou/blogs

作者：深予之 (@senntyou)

版权声明：自由转载-非商用-非衍生-保持署名（创意共享 3.0 许可证）

内容来源于网络，如有侵权，请联系作者删除！

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com