Spring IOC源码分析-自定义标签加载

最新推荐文章于 2021-11-12 17:39:56 发布

进击的大叔

最新推荐文章于 2021-11-12 17:39:56 发布

阅读量375

点赞数 1

分类专栏： spring 源码分析文章标签： spring 源码分析源码

本文链接：https://blog.csdn.net/c_unclezhang/article/details/78579225

版权

spring 源码分析专栏收录该内容

4 篇文章 1 订阅

订阅专栏

前言

Spring里有默认标签和自定义标签的处理，前边我们分析了默认标签的处理(bean标签)，下边我们重点开始分析自定义标签处理

类继承关系图

处理之前，先看下自定义处理过程中涉及到的类关系图
处理器继承关系图

命名空间类继承关系图

自定义标签的使用

一般而言，扩展spring标签大概需要下边的几个步骤

创建一个扩展组件
定义个组件的描述文件XSD
创建一个解析XSD的组件(需要实现BeanDefinitionParser接口)
创建一个组件注册文件(扩展NamespaceHandlerSupport)
编写Spring.handlers和Spring.schemas文件

根据上边的步骤，首先我们创建一个扩展组件

public class User {
    private String userName;
    private String email;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

定义一个XSD文件来描述组件

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://www.zhangxiaosheng.org/schema/user"
            xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            targetNamespace="http://www.zhangxiaosheng.org/schema/user"
            elementFormDefault="qualified"
            attributeFormDefault="unqualified">

    <xsd:element name="user" type="user" />

    <xsd:complexType name="user">
            <xsd:attribute name="id" type="xsd:string" />
            <xsd:attribute name="userName" type="xsd:string"/>
            <xsd:attribute name="email" type="xsd:string" />
    </xsd:complexType>

</xsd:schema>

上边可以看到，我们启用了一个新的名词空间http: //www.zhangxiaosheng.org/schema/user，并且定义了user组件的属性，创建一个实现BeanDefinitionParser接口的类，用来解析XSD中组件的定义

public class UserBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {

protectedClass getBeanClass(Element element) {

returnUser.class;

}

protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {

String userName = element.getAttribute("userName");

builder.addPropertyValue("userName",userName);

String email = element.getAttribute("email");

builder.addPropertyValue("email",email);

}

}

创建一个Handler类，扩展NamespaceHandlerSupport,用来注册组件

public class UserNamespaceHandler extends NamespaceHandlerSupport {

public void init() {

registerBeanDefinitionParser("user",new UserBeanDefinitionParser());

}

}

最后编写Spring.handlers和Spring.schemas文件两个文件

Spring.hander

http\://www.zhangxiaosheng.org/schema/user=xml.custom.UserNamespaceHandler

Spring.schemas

 http\://www.zhangxiaosheng.org/schema/user/user.xsd=META-INF/spring-user.xsd

注意这两个文件需要在resources目录下新建META-INF文件夹，然后新建这两个文件

最后在配置文件中使用自定义标签

<myname:user id="user" userName ="ua" \email="xiaosheng@126.com" />

7.测试输出

public class BookMain {

    public static void main(String[] args) {

        ClassPathXmlApplicationContext f=new ClassPathXmlApplicationContext("beanFactory.xml");
        User user = (User) f.getBean("user");
        System.out.println(user.getEmail());


    }
}

打印出

xiaosheng@126.com

上边就是整个使用流程，那么spring是如何进行加载和处理整个流程的？

自定义标签的解析过程

分支入口

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
   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)) {
               parseDefaultElement(ele, delegate);
            }
            else {
               //自定义标签处理逻辑入口
               delegate.parseCustomElement(ele);
            }
         }
      }
   }
   else {
      delegate.parseCustomElement(root);
   }
}

进入自定义标签主流程

public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
//获取自定义标签的命名空间  
 String namespaceUri = getNamespaceURI(ele);
   if (namespaceUri == null) {
      return null;
   }

//获取自定义标签处理器
   NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
   if (handler == null) {
      error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
      return null;
   }
//解析自定义标签
   return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

这里就是正式解析自定义标签的流程整个过程分成三个部分

获取自定义标签的命名空间
获取自定义标签处理器
解析自定义标签
获取命名空间

String namespaceUri = getNamespaceURI(ele);

直接使用java自带的dom解析类node的方法直接获取
获取标签处理器

NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);

这里的 namespaceHandlerResolver就是在readerContext初始化的时候注入的DefaultNamespaceHandlerResolver，其实就是调用的DefaultNamespaceHandlerResolver的resolve方法，进入resolve方法

public NamespaceHandler resolve(String namespaceUri) {

//根据Spring.handlers文件配置，找到所有的已经配置的handlers映射
   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
         Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
         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);
//调用handler接口方法
         namespaceHandler.init();
//缓存
         handlerMappings.put(namespaceUri, namespaceHandler);
         return namespaceHandler;
      }
      catch (ClassNotFoundException ex) {
         throw new FatalBeanException("NamespaceHandler class [" + className + "] for namespace [" +
               namespaceUri + "] not found", ex);
      }
      catch (LinkageError err) {
         throw new FatalBeanException("Invalid NamespaceHandler class [" + className + "] for namespace [" +
               namespaceUri + "]: problem with handler class file or dependent class", err);
      }
   }
}

这里getHandlerMappings() 这个方法功能就是读取META-INF下的Spring.handlers配置文件，并且把其中的配置信息缓存在map中

handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));parse方法，默认调用的是父类NamespaceHandlerSupport中的parse方法

public BeanDefinition parse(Element element, ParserContext parserContext) {
//找到元素的对应解析器
   BeanDefinitionParser parser = findParserForElement(element, parserContext);
   return (parser != null ? parser.parse(element, parserContext) : null);
}

这里就会找到我们注册的解析器UserBeanDefinitionParser，然后调用的parse方法是父类AbstractSingleBeanDefinitionParser的parse方法

public final BeanDefinition parse(Element element, ParserContext parserContext) {
   //真正调用自定义解析器方法
   AbstractBeanDefinition definition = parseInternal(element, parserContext);
   if (definition != null && !parserContext.isNested()) {
      try {
         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);
         }
         String[] aliases = null;
         if (shouldParseNameAsAliases()) {
            String name = element.getAttribute(NAME_ATTRIBUTE);
            if (StringUtils.hasLength(name)) {
               aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
            }
         }
         BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);
         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;
}

进入parseInternal

protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
   BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
   String parentName = getParentName(element);
   if (parentName != null) {
      builder.getRawBeanDefinition().setParentName(parentName);
   }
   Class<?> beanClass = getBeanClass(element);
   if (beanClass != null) {
      builder.getRawBeanDefinition().setBeanClass(beanClass);
   }
   else {
      String beanClassName = getBeanClassName(element);
      if (beanClassName != null) {
         builder.getRawBeanDefinition().setBeanClassName(beanClassName);
      }
   }
   builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));
   BeanDefinition containingBd = parserContext.getContainingBeanDefinition();
   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);
   return builder.getBeanDefinition();
}

首先spring会处理一些bean的基本信息和默认信息，最终调用自定义解析器中的doParse方法

后语

整个过程，我们只需要自定义自己需要处理的业务流程部分，然后根据spring提供的框架配置到spring中就可以了，这里其实是使用了模板模式，对于装配的一些常规处理(非业务部分)spring替我们做好，并且对外提供出接口来进行自定义业务扩展，简单说就是spring来提供骨架，具体特定的业务方法子类自定义处理。