转载

想要理解 Spring IoC，先要知道如何扩展 Spring 自定义 Bean

我是风筝，公众号「古时的风筝」，一个不只有技术的技术公众号，一个在程序圈混迹多年，主业 Java，另外 Python、React 也玩儿的 6 的斜杠开发者。 Spring Cloud 系列文章已经完成，可以到 我的 github 上查看系列完整内容。也可以在公众号内回复「pdf」获取我精心制作的 pdf 版完整教程。

今天这篇文章算是为下一篇 Spring IoC 实现的文章做个预热，Spring 最核心的部分就是控制反转，而要被控制的对象就是各种各样的 Bean。

虽然现在大部分团队都直接用 Spring Boot 了，很少有人用 Spring MVC 了，但是基础还是 Spring,只不过更多的是把 XML 配置改成了注解形式。

如果你用过 XML 配置的形式，那你知道 <context:component-scan> 、 <bean> 、 <aop:aspectj-autoproxy> 这些标签配置是怎么实现的吗，了解了这些，相信对你进一步认识 Spring 会有很大帮助。

来吧，开始了！

Spring mvc 提供了扩展 xml 的机制，用来编写自定义的 xml bean ，例如 dubbo 框架，就利用这个机制实现了好多的 dubbo bean，比如 <dubbo:application> 、 <dubbo:registry> 等等，只要安装这个标准的扩展方式实现配置即可。

扩展自定义 bean 的意义何在

假设我们要使用一个开源框架或者一套 API，我们肯定希望以下两点：

  1. 易用性，即配置简单，要配置的地方越少越好

  2. 封装性，调用简单，也就是越高层封装越好，少暴露底层实现

基于以上两点，假设我们要实现一个自定义功能，用现有的 Spring 配置项也可以实现，但可能要配置的内容较多，而且还有可能要加入代码辅助。导致逻辑分散，不便于维护。

所以我们用扩展 Spring 配置的方式，将一些自定义的复杂功能封装，实现配置最小化。

实现自定义扩展的步骤

本例只做简单示范，功能简单，即实现一个可配置参数的 Hacker bean，然后提供一个toString() 方法，输入参数信息。 我们最终实现的 bean 配置如下：

<kite:hacker id="hacker" name="moon" language="english" age="18" isHide="true"/>
复制代码

用 Spring 自带的配置做个比较，例如：

<context:component-scan base-package="com.ebanghu"></context:component-scan>
复制代码

1、实现自定义 bean 类，命名为 Hacker ，并在方法中重载toString()方法，输入属性名称，代码如下：

package kite.lab.spring.config;

/**
 * Hacker
 * @author fengzheng
 */
public class Hacker {
    private String name;
    private String age;
    private String language;
    private boolean isHide;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public String getLanguage() {
        return language;
    }

    public void setLanguage(String language) {
        this.language = language;
    }

    public boolean isHide() {
        return isHide;
    }

    public void setHide(boolean hide) {
        isHide = hide;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("======================/n");
        builder.append(String.format("hacker's name is :%s /n", this.getName()));
        builder.append(String.format("hacker's age is :%s /n", this.getAge()));
        builder.append(String.format("hacker's language is :%s /n", this.getLanguage()));
        builder.append(String.format("hacker's status is :%s /n", this.isHide()));
        builder.append("======================/n");
        return builder.toString();
    }
}
复制代码

2、编写 xsd schema 属性描述文件，命名为 hacker.xsd ，这里把它放到项目 resources 目录下的 META-INF 目录中（位置可以自己决定），可以理解为：这个文件就是对应刚刚创建的实体类作一个 xml 结构描述，内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://code.fengzheng.com/schema/kite"
            xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            xmlns:beans="http://www.springframework.org/schema/beans"
            targetNamespace="http://code.fengzheng.com/schema/kite"
            elementFormDefault="qualified"
            attributeFormDefault="unqualified">

    <xsd:import namespace="http://www.springframework.org/schema/beans"/>

    <xsd:complexType name="hackType">
        <xsd:complexContent>
            <xsd:extension base="beans:identifiedType">
                <xsd:attribute name="name" type="xsd:string" use="required">
                    <xsd:annotation>
                        <xsd:documentation>
                            <![CDATA[ The name of hacker ]]>
                        </xsd:documentation>
                    </xsd:annotation>
                </xsd:attribute>
                <xsd:attribute name="age" type="xsd:int" use="optional" default="0">
                    <xsd:annotation>
                        <xsd:documentation><![CDATA[ The age of hacker. ]]></xsd:documentation>
                    </xsd:annotation>
                </xsd:attribute>

                <xsd:attribute name="language" type="xsd:string" use="optional">
                    <xsd:annotation>
                        <xsd:documentation><![CDATA[ The language of hacker. ]]></xsd:documentation>
                    </xsd:annotation>
                </xsd:attribute>

                <xsd:attribute name="isHide" type="xsd:boolean" use="optional">
                    <xsd:annotation>
                        <xsd:documentation><![CDATA[ The status of hacker. ]]></xsd:documentation>
                    </xsd:annotation>
                </xsd:attribute>
            </xsd:extension>
        </xsd:complexContent>
    </xsd:complexType>


    <xsd:element name="hacker" type="hackType">
        <xsd:annotation>
            <xsd:documentation><![CDATA[ The hacker config ]]></xsd:documentation>
        </xsd:annotation>
    </xsd:element>
</xsd:schema>
复制代码

注意上面的

xmlns="http://code.fengzheng.com/schema/kite
复制代码

和

targetNamespace="http://code.fengzheng.com/schema/kite"
复制代码

一会儿有地方要用到。

3、实现 NamespaceHandler 类，代码如下：

package kite.lab.spring.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.xml.NamespaceHandlerSupport;

/**
 * HackNamespaceHandler
 * @author fengzheng
 */
public class HackNamespaceHandler extends NamespaceHandlerSupport {

    private static final Logger logger = LoggerFactory.getLogger(HackNamespaceHandler.class);

    @Override
    public void init() {
        logger.info("执行 HackNamespaceHandler 的 init 方法");
        registerBeanDefinitionParser("hacker",new HackBeanDefinitionParser(Hacker.class));
        logger.info("注册 「hacker」 定义转换器成功");
    }
}
复制代码

此类功能非常简单，就是继承 NamespaceHandlerSupport 类，并重载 init 方法，调用 registerBeanDefinitionParser 方法，其中第一个参数 hacker 即是我们之后在 spring 配置文件中要使用的名称，即 kite:hacker 这里的hacker； 第二个参数是下一步要说的。

4、实现 BeanDefinitionParser 类，这个类的作用简单来说就是将第一步实现的类和 Spring xml中声明的 bean 做关联，实现属性的注入，来看代码：

package kite.lab.spring.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.beans.factory.xml.BeanDefinitionParser;
import org.springframework.beans.factory.xml.ParserContext;
import org.w3c.dom.Element;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;

/**
 * HackBeanDefinitionParser 
 *
 * @author fengzheng
 */
public class HackBeanDefinitionParser implements BeanDefinitionParser {

    private static final Logger logger = LoggerFactory.getLogger(HackBeanDefinitionParser.class);

    private final Class<?> beanClass;

    public HackBeanDefinitionParser(Class<?> beanClass) {
        this.beanClass = beanClass;
    }

    @Override
    public BeanDefinition parse(Element element, ParserContext parserContext) {
        logger.info("进入 HckBeanDefinitionParser 的 parse 方法");
        try {
            String id = element.getAttribute("id");
            RootBeanDefinition rootBeanDefinition = new RootBeanDefinition();
            rootBeanDefinition.setBeanClass(beanClass);
            rootBeanDefinition.setLazyInit(false);

            //必须注册才可以实现注入
            parserContext.getRegistry().registerBeanDefinition(id, rootBeanDefinition);

            String name = element.getAttribute("name");
            String age = element.getAttribute("age");
            String language = element.getAttribute("language");
            String isHide = element.getAttribute("isHide");
            MutablePropertyValues pvs = rootBeanDefinition.getPropertyValues();
            pvs.add("name", name);
            pvs.add("age", Integer.valueOf(age));
            pvs.add("language", language);
            pvs.add("hide", isHide.equals(null) ? false : Boolean.valueOf(isHide));

            return rootBeanDefinition;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}
复制代码

此类实现自 BeanDefinitionParser，并且重载 parse 方法，parse 方法有两个参数，第一个Element可以理解为 Spring xml 配置的 bean 的实体对应，通过 element.getAttribute 方法可以获取 配置的参数值，第二个参数 ParserContext ，可以理解为 Spring 提供的接口对象，通过它实现注册 bean 的注入。 通过 RootBeanDefinition 实体对象的 getPropertyValues 方法可获取自定义bean的属性 kv 集合，然后像其中添加属性值。 注意：kv 集合中的 key 并不是实体类中的属性名称，而是属性对应的 setter 方法的参数名称，例如布尔型参数如果命名为 is 开头的，使用编辑器自动生成 setter 方法时，对应的 setter 方法的参数就会去掉 is ，并把后面的字符串做驼峰命名规则处理。当然了如果要规避的话，可以自己写 setter 方法。

5、注册 handler 和 xsd schema Spring 规定了两个 xml 注册文件，并且规定这两个文件必须项目资源目录下的 META-INF 目录中，并且文件名称和格式要固定。

spring.handlers 用于注册第三步实现的 Handler 类

内容如下：

http/://code.fengzheng.com/schema/kite=kite.lab.spring.config.HackNamespaceHandler
复制代码

这是一个键值对形式，等号前面为命名空间，第一步已经提到，这里就用到了，等号后面是 Handler 类的完全类名称。注意冒号前面加转义符

spring.schemas 用于注册第二步中的 xsd 文件

内容如下：

http/://code.fengzheng.com/schema/kite/kite.xsd=META-INF/hacker.xsd
复制代码

等号前面是声明的 xsd 路径，后面是实际的 xsd 路径。

6、 在 Spring 配置文件中使用

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:kite="http://code.fengzheng.com/schema/kite"
       xsi:schemaLocation="
         http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
            http://code.fengzheng.com/schema/kite
            http://code.fengzheng.com/schema/kite/kite.xsd">

    <kite:hacker id="hacker" name="moon" language="english" age="18" isHide="true"/>
</beans>
复制代码

注意前面引入了命名空间

xmlns:kite="http://code.fengzheng.com/schema/kite"
复制代码

后面指定了 xsd 文件位置

http://code.fengzheng.com/schema/kite  
http://code.fengzheng.com/schema/kite/kite.xsd
复制代码

7、测试

直接获取配置文件的方式测试

public static void main(String[] args){
        ApplicationContext ac = new ClassPathXmlApplicationContext("application.xml");
         Hacker hacker = (Hacker) ac.getBean("hacker");
         System.out.println(hacker.toString());
    }
复制代码

使用 SpringJUnit4ClassRunner 测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:application.xml" })
public class HackTest {
    @Resource(name = "hacker")
    private Hacker hacker;

    @Test
    public void propertyTest() {
        System.out.println(hacker.toString());
    }
}
复制代码

测试结果如图：

想要理解 Spring IoC，先要知道如何扩展 Spring 自定义 Bean

本文只是简要说明实现步骤，具体负责操作可参考 dubbo ，代码在 dubbo-config-spring 模块中，当然也可以阅读 Spring 源码，例如 查看 context:component-scan 的实现，在 spring-context-版本号 模块中。

创作不易，小小的赞，大大的暖，快来温暖我。不用客气了，赞我！

我是风筝，公众号「古时的风筝」，一个在程序圈混迹多年，主业 Java，另外 Python、React 也玩儿的很 6 的斜杠开发者。可以在公众号中加我好友，进群里小伙伴交流学习，好多大厂的同学也在群内呦。

想要理解 Spring IoC，先要知道如何扩展 Spring 自定义 Bean
原文  https://juejin.im/post/5ea8dfa6e51d454db11f6e31
正文到此结束
所属分类： Spring

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 java-demo Maven教程 springcloud-demo hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 ANTLR教程 SpringCloud Ant教程 java实例教程 Hazelcast教程 XStream教程 Elastic-Job-Lite 深入浅出MyBatis ibaties教程 SVN教程 rabittmq教程 Hadoop教程 solr教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 使用 Docker 打包和运行 Vue 应用
  2. 2 Dependency Check命令行方式扫描jar包的安全漏洞
  3. 3 maven使用Dependency-Check来扫描安全漏洞
  4. 4 使用sonarqube分析代码质量
  5. 5 使用screw来对比数据库表和字段差异
  6. 6 Spring Boot 实现防盗链功能
  7. 7 在Spring Boot中的实现国际化（i18n）
  8. 8 一个用于 SMB/CIFS 网络的 Java 库-JCIFS
  9. 9 Spring Boot 3.x嵌入MongoDB 进行测试
  10. 10 java如何解析和生成yaml文件？
网站信息
  • 文章总数：82,737 篇
  • 文件总数：284,312 个
  • 标签总数：2,416 个
  • 分类总数：85 个
  • 留言数量：2,559 条
  • 在线人数：610 人
  • 运行天数：4,439天
  • 最后更新：2024年12月22日19点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG