自定义 Schema 解析 Spring Bean

1.写在前面的废话

从 Spring 2.0 以后 Spring 就支持了客户端自定义 Schema 来表示 Bean 定义。同时也提供了通用的支持类来帮助完成复杂的解析工作。至于他的优点，个人感觉是当需要复杂的构造对象时，自定义 Schema 来定义 Bean 是有优势的。他在可读性，可以配置性可以有很大的提高。至于其他的，需要读者去体会了。

网上有很多这样的例子，当时有很多我感觉过于简单，和实际项目中用到的东西有一点儿脱节。下面就用日常项目中可能使用到任务处理方式来说明自定义 Schema 来定义自己的 Bean 定义是如何来实现的，当然也是简化之后的版本。

2. 任务处理的需求以及一般处理逻辑和处理方式

常见的任务场景是当某一事件完成后，异步的处理的任务触发，可能是一个，也可能是多个。例如：当车从车库开出后，车库门需要关闭，车库的灯需要关掉。

对应上面场景，我们可以分解一下详细的描述：

当车开出车库时，释放一个信号，就发送一条消息，告知汽车已经离开的车库了
消息的关注者可以处理这个消息。例如车库灯关注这个消息，他创建一条关灯的任务，然后在规定时间内把灯关掉；车库门关注这个消息，他创建一条关闭车库门的任务，然后在规定的时间内把车库门关闭。
任务的执行。上一步中关注者创建了任务，下面就可以让任务调度器来扫描任务，执行任务。例如没秒扫描一次，判断是否需要执行关闭车库门，是否需要关闭车库灯。

3. 自定义 schema 做自己的 Spring Bean 定义的步骤

3.1整体部署描述

自定义 schema，解析 Bean 定义整体流程是下面几步：

自定义 schema，表述 Bean 定义需要遵循的配置规范
定义自己的命名空间处理器（NamespaceHandler）
定义自己的设定的 schema 相关的 Bean 解析器（BeanDefinitionParser）
配置 spring.handlers，让 Spring 容器知道对应的命名空间的处理器
配置 spring.schemas，让 Spring 容器知道对应解析 document 的检查依据
实现自己的业务
配置 Bean 定义文件，串联所有的业务

3.2具体事例

3.2.1根据上述的场景，进行业务实现方式抽象

EventSource：事件源，把车库当成事件的载体，当汽车开出车库时，触发释放车离开车库的事件。同时他应该具体注册监听事件的监听者的能力，使各个监听者可以顺利的注册到时间源上。当某种事件发生后，通知对应的监听者。
EventListener：监听者，监听事件，例如车库门是一个监听者，他监听到车开出车库的消息时，进行自己的处理。这里是创建一条车库门关闭的任务。
Task：任务，描述的任务本身的信息，例如任务的标识，任务的类型，执行计划，执行状态等。例如关闭车库门的场景：任务标识可自动生成，任务类型是车库门关闭，执行计划是车开出车库1分钟后关闭车库门，执行状态是等待执行。
TaskProcessor：任务处理器，真实的处理过程。例如关闭车库门的操作。

3.2.2自定义 schema 描述

定义一个事件的描述，他包含了一个事件源，多个事件监听者，和多个事件监听的执行器。位于 classpath:META-INF 下面的 event.xsd

<?xml version="1.0"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            targetNamespace="http://www.lh.experiment.com/schema/event"
            xmlns="http://www.lh.experiment.com/schema/event"
            elementFormDefault="qualified">
    <xsd:element name="event">
        <xsd:complexType>
            <xsd:sequence>
                <xsd:element name="source" type="EventSourceType" minOccurs="1" maxOccurs="1"/>
                <xsd:element name="listener" type="EventListenerType" minOccurs="0" maxOccurs="unbounded"/>
                <xsd:element name="task" type="TaskType" minOccurs="0" maxOccurs="unbounded" />
            </xsd:sequence>
            <xsd:attribute name="id" type="xsd:string" use="required" />
        </xsd:complexType>
    </xsd:element>

    <xsd:complexType name="EventSourceType">
        <xsd:attribute name="value" type="xsd:string" use="required" />
    </xsd:complexType>

    <xsd:complexType name="EventListenerType">
        <xsd:attribute name="id" type="xsd:string" use="required" />
        <xsd:attribute name="concern" type="xsd:string" use="required" />
        <xsd:attribute name="value" type="xsd:string" use="required" />
    </xsd:complexType>

    <xsd:complexType name="TaskType">
        <xsd:all>
            <xsd:element name="type" type="DefaultRequiredValueType" />
            <xsd:element name="processor" type="DefaultRequiredValueType" />
        </xsd:all>
        <xsd:attribute name="id" type="xsd:string" use="required" />
    </xsd:complexType>

    <xsd:complexType name="DefaultRequiredValueType">
        <xsd:attribute name="value" type="xsd:string" use="required" />
    </xsd:complexType>

</xsd:schema>

3.2.3命名空间处理器

定义支持“event”命名空间的处理器。一般情况下我们选择 spring 提供的支持类即可，但是如果你愿意，你也可以实现原始的 NamespaceHandler 接口，完全实现。这里我们选择继承org.springframework.beans.factory.xml.NamespaceHandlerSupport完成。

public class EventNamespaceHandler extends NamespaceHandlerSupport {
    @Override
    public void init() {
        super.registerBeanDefinitionParser("event", new EventBeanDefinitionParser());
    }
}

3.2.4 Bean 定义解析器

在做命名空间处理器时，需要我们指定 Bean 定义解析器。同样我们可以选择 Spring 提供支持类作为基类来实现。只要实现 BeanDefinitionPaser 就好。这个解析类承载了真正的 Bean 解析工作：对各个节点、元素、属性的解析，已经需要生成对应的 BeanDefinitionHolder，注册到容器中。

public class EventBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {
    private static final Set<String> CHILD_NODE_SET = new HashSet<String>(Arrays.asList(
            "source", "listener", "task"
    ));

    @Override
    protected Class<?> getBeanClass(Element element) {
        return EventMetadata.class;
    }

    @Override
    protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
        MutablePropertyValues propertyValues = builder.getBeanDefinition().getPropertyValues();

        String source = parseSourceNode(element);
        propertyValues.addPropertyValue("source", new RuntimeBeanReference(source));

        ManagedList listenerList = new ManagedList();
        ManagedList taskList = new ManagedList();
        NodeList childNodes = element.getChildNodes();
        for (int i = 0; i < childNodes.getLength(); i++) {
            Node child = childNodes.item(i);
            String nodeName = child.getLocalName();
            if (!CHILD_NODE_SET.contains(nodeName)) continue;

            if ("listener".equals(nodeName)) {
                parseListenerNode((Element) child, source, listenerList);
            }
            else if ("task".equals(nodeName)) {
                parseTaskNode((Element) child, taskList);
            }
        }
        if (!listenerList.isEmpty()) {
            propertyValues.addPropertyValue("listenerMetadata", listenerList);
        }
        if (!taskList.isEmpty()) {
            propertyValues.addPropertyValue("taskMetadata", taskList);
        }
    }

    private String parseSourceNode(Element element) {
        NodeList childNodes = element.getChildNodes();
        for (int i = 0; i < childNodes.getLength(); i++) {
            Node child = childNodes.item(i);
            String nodeName = child.getLocalName();
            if ("source".equals(nodeName)) {
                return ((Element) child).getAttribute("value");
            }
        }
        return null;
    }

    private void parseListenerNode(Element listenerNode, String sourceName, ManagedList listenerList) {
        String id = listenerNode.getAttribute("id");
        String concern = listenerNode.getAttribute("concern");
        String listenerName = listenerNode.getAttribute("value");

        BeanDefinitionBuilder listenerBdb = BeanDefinitionBuilder.genericBeanDefinition();
        listenerBdb.getRawBeanDefinition().setBeanClass(ListenerMetadata.class);
        MutablePropertyValues propertyValues = listenerBdb.getBeanDefinition().getPropertyValues();
        propertyValues.addPropertyValue("concernId", concern);
        propertyValues.addPropertyValue("listener", new RuntimeBeanReference(listenerName));
        propertyValues.addPropertyValue("source", new RuntimeBeanReference(sourceName));
        BeanDefinitionHolder holder = new BeanDefinitionHolder(listenerBdb.getBeanDefinition(), id);
        listenerList.add(holder);
    }

    private void parseTaskNode(Element taskNode, ManagedList taskList) {
        BeanDefinitionBuilder taskBdb = BeanDefinitionBuilder.genericBeanDefinition();
        taskBdb.getRawBeanDefinition().setBeanClass(TaskMetadata.class);

        MutablePropertyValues propertyValues = taskBdb.getBeanDefinition().getPropertyValues();

        String id = taskNode.getAttribute("id");
        NodeList childNodes = taskNode.getChildNodes();
        for (int i = 0; i < childNodes.getLength(); i++) {
            Node child = childNodes.item(i);
            String nodeName = child.getLocalName();
            if ("type".equals(nodeName)) {
                String taskType = ((Element)child).getAttribute("value");
                propertyValues.addPropertyValue("taskType", taskType);
            }
            else if ("processor".equals(nodeName)) {
                String taskProcessor = ((Element)child).getAttribute("value");
                propertyValues.addPropertyValue("taskProcessor", new RuntimeBeanReference(taskProcessor));
            }
        }
        propertyValues.addPropertyValue("taskSPI", new RuntimeBeanReference("taskSPI"));

        BeanDefinitionHolder holder = new BeanDefinitionHolder(taskBdb.getBeanDefinition(), id);
        taskList.add(holder);
    }
}

3.2.5 spring.handlers 配置

自己定义在类路径 META-INF/spring.handlers 文件，写下如下配置：

http\://www.lh.experiment.com/schema/event=com.lh.a.t.spring.ioc.framework.EventNamespaceHandler

3.2.6 spring.schemas 配置

自定义在类路径 META-INF/spring.schemas 文件，写下如下配置：

http\://www.lh.experiment.com/schema/event/event.xsd=META-INF/event.xsd

3.2.7 Bean 配置，串联业务

业务代码实现这里不做说明，可以查看源码在附件中，

下面我们配置我们需要 bean 定义文件，我定义在类路径 spring/spring-bean-schema.xml 中，配置如下：

<?xml version="1.0" encoding="GBK"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:event="http://www.lh.experiment.com/schema/event"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
       http://www.lh.experiment.com/schema/event http://www.lh.experiment.com/schema/event/event.xsd"
        default-autowire="byName">

    <event:event id="garageEventConfig">
        <event:source value="garage"/>

        <event:listener id="lightOffListener" concern="car-drive-off" value="lightOffProcessor"/>
        <event:listener id="gateCloseListener" concern="car-drive-off" value="gateCloseProcessor"/>

        <event:task id="lightOffTask">
            <event:type value="task-light-off"/>
            <event:processor value="lightOffProcessor"/>
        </event:task>
        <event:task id="gateCloseTask">
            <event:type value="task-gate-close"/>
            <event:processor value="gateCloseProcessor"/>
        </event:task>
    </event:event>

    <bean id="garage" class="com.lh.a.t.spring.ioc.biz.support.Garage"/>
    <bean id="lightOffProcessor" class="com.lh.a.t.spring.ioc.biz.support.LightOffProcessor"/>
    <bean id="gateCloseProcessor" class="com.lh.a.t.spring.ioc.biz.support.GateCloseProcessor"/>
    <bean id="taskSPI" class="com.lh.a.t.spring.ioc.biz.support.TaskServiceProvider"/>

</beans>

3.2.8测试执行

写一个简单的测试类来运行一下：

public class GarageIocTest {
    private static ApplicationContext applicationContext;

    private Garage garage;
    private TaskSPI taskSPI;

    @BeforeClass
    public static void beforeClass() {
        applicationContext = new ClassPathXmlApplicationContext(new String[] {
                "spring/spring-bean-schema.xml"
        });
    }

    @Before
    public void before() {
        garage = (Garage) applicationContext.getBean("garage");
        taskSPI = (TaskSPI) applicationContext.getBean("taskSPI");
    }

    @Test
    public void testCarDriveOff() throws Exception {
        garage.carDriveOff();

        List<Task> executableTaskList = mockExecutableList();
        for (Task executableTask : executableTaskList) {
            new Thread(new TaskRunnable(taskSPI, executableTask)).start();
        }
    }

    private List<Task> mockExecutableList() {
        List<Task> executableTaskList = new ArrayList<Task>();

        Task executableLightOffTask = new Task();
        executableLightOffTask.setTaskType(Task.TaskType.LIGHT_OFF.get());
        executableLightOffTask.setTaskId("light-off-0001");
        executableTaskList.add(executableLightOffTask);

        Task executableGateCloseTask = new Task();
        executableGateCloseTask.setTaskType(Task.TaskType.GATE_CLOSE.get());
        executableGateCloseTask.setTaskId("gate-close-0001");
        executableTaskList.add(executableGateCloseTask);

        return executableTaskList;
    }

    private class TaskRunnable implements Runnable {
        private TaskSPI taskSPI;
        private Task executableTask;

        private TaskRunnable(TaskSPI taskSPI, Task executableTask) {
            this.taskSPI = taskSPI;
            this.executableTask = executableTask;
        }

        @Override
        public void run() {
            StringBuilder context = new StringBuilder();
            context.append(executableTask.getTaskId()).append("@").append(executableTask.getTaskType());
            taskSPI.execute(executableTask, context.toString());
        }
    }
}

运行结果如下：

2014-10-11 22:40:24,490 main [GateCloseProcessor.java:18] INFO : Gate close processor incept message:Car No A99999 get out the garage

2014-10-11 22:40:24,491 main [LightOffProcessor.java:18] INFO : Light off processor incept message:Car No A99999 get out the garage

2014-10-11 22:40:24,493 Thread-0 [LightOffProcessor.java:29] INFO : Light off processor execute, taskId:light-off-0001, context:light-off-0001@task-light-off

4. 总结

Spring 自定义schema 方式支持客户自定义 Bean 定义的方式，在可读性上有很大的提高。同时代码的方式我们可以为我们的业务量身定做配置，可以简化配置工作，同时根据业务来验证约束我们配置，减少配置出错的几率，在一定程度上可以提高开发效率。

5.附件源码

下载源码，希望对你有所帮助。

自定义 Schema 解析 Spring Bean

猜你喜欢