Namespace personalizado do Spring

Explicação

Quando o Spring analisa as tags no arquivo xml, ele distingue se a tag atual tem quatro tags básicas (importação, alias, bean e beans) ou uma tag customizada.Se for uma tag customizada, ele analisará a corrente de acordo com a lógica da tag customizada De etiquetas.

A partir da versão 2.0, a estrutura Spring fornece um mecanismo de extensão para definir beans com base no formato XML Spring, no estilo do esquema. A introdução do XML baseado em esquema é simplificar o formulário de configuração XML tradicional.

Através da definição de Esquema, alguns formulários de configuração que originalmente precisam ser definidos pela definição de vários beans ou uma combinação de beans complexos são apresentados em outro formulário de configuração simples e legível.

O XML baseado em esquema consiste em três partes:

namespace - possui uma classificação lógica muito clara
elemento-tem semântica de processo muito clara
atributos - tem opções de configuração muito simples

Por exemplo:

<mvc:annotation-driven />

O significado dessa configuração é realizar a configuração orientada a anotações no espaço do mvc.

Entre eles,

mvcIndica o alcance efetivo da configuração,
annotation-drivenEle expressa um processo dinâmico, o significado lógico real é: a implementação de todo o SpringMVC é baseada no modo Anotação, registre o modo de comportamento relevante para mim.

Custom

A seguir, explicaremos como gravar a definição de bean XML personalizada e integrar essa análise no contêiner Spring IOC.

No conteúdo a seguir, mencionaremos que um conceito importante é a definição de bean. Na verdade, existe um conceito importante em Spring é o bean. E o objeto BeanDefinition é o rótulo correspondente após a análise do objeto.

Você pode criar uma nova extensão de configuração xml usando as seguintes etapas de resposta curta:

Criando um esquema XML para descrever seus elementos personalizados
Codificando uma implementação personalizada do NamespaceHandler (esta é uma etapa muito simples, não se preocupe)
Codificando uma ou mais implementação BeanDefinitionParse (essa é a mais importante)
Registrando-se ou registre-se acima no Spring (esta também é uma etapa de resposta curta)

Exemplos

Precisamos criar uma extensão XML (elemento xml personalizado) que permita configurar o objeto SimpleDateFormat (no pacote java.text) de uma maneira simples. Por fim, podemos definir uma definição de bean do tipo simpleDateFormat da seguinte maneira:

    <myns:dateformat id="dateFormat"
                     pattern="yyyy-MM-dd HH:mm"
                     lenient="true"/>

1. Crie uma configuração

Crie um arquivo nos recursos do projeto:

myns.xsd

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

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

    <xsd:element name="dateformat">
        <xsd:complexType>
            <xsd:complexContent>
                <xsd:extension base="beans:identifiedType">
                    <xsd:attribute name="lenient" type="xsd:boolean"/>
                    <xsd:attribute name="pattern" type="xsd:string" use="required"/>
                </xsd:extension>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>
</xsd:schema>

O esquema acima será usado para configurar o objeto SimpleDateFormat.

Usado diretamente em um arquivo de contexto de aplicativo xml <myns:dateformat />.

<myns:dateformat id="dateFormat"
    pattern="yyyy-MM-dd HH:mm"
    lenient="true"/>

Nota: O fragmento XML acima é essencialmente o mesmo que o fragmento XML abaixo.

<bean id="dateFormat" class="java.text.SimpleDateFormat">
    <constructor-arg value="yyyy-HH-dd HH:mm"/>
    <property name="lenient" value="true"/>
</bean>

2. Escreva um processador de espaço para nome

Para o esquema acima, precisamos NamespaceHandleranalisar todos os namespacearquivos de configuração específicos encontrados pelo Spring elements. Isso NamespaceHandlerse preocupará com os myns:dateformatelementos de análise .

A interface NamespaceHandler é relativamente simples e inclui três métodos importantes.

init() -NamespaceHandler será instanciado antes da primavera usar o manipulador
BeanDefinition parse(Element, ParseContext) -Quando o Spring encontrar o elemento de nível superior (isto é, myms) definido acima, ele será chamado. Este método pode registrar definições de bean e retornar uma definição de bean.
BeanDefinitionHolder decorate(Node, BeanDefinitionHolder, ParserContext) -Spring será chamado quando encontrar um atributo ou elemento incorporado no espaço para nome.

MyNamespaceHandler.java

package com.jeiker.namespace;

import org.springframework.beans.factory.xml.NamespaceHandlerSupport;

public class MyNamespaceHandler extends NamespaceHandlerSupport {

    @Override
    public void init() {
        registerBeanDefinitionParser("dateformat", new SimpleDateFormatBeanDefinitionParser());
    }

}

3. Analisar elementos xml personalizados

A responsabilidade do BeanDefinitionParser é analisar os elementos XML que definem o esquema no nível superior. Durante o processo de análise, devemos acessar os elementos XML para poder analisar nosso conteúdo XML personalizado.

SimpleDateFormatBeanDefinitionParser.java

package com.jeiker.namespace;

import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser;
import org.springframework.util.StringUtils;
import org.w3c.dom.Element;

import java.text.SimpleDateFormat;

public class SimpleDateFormatBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {

    @Override
    protected Class getBeanClass(Element element) {
        return SimpleDateFormat.class;
    }

    @Override
    protected void doParse(Element element, BeanDefinitionBuilder bean) {
        // this will never be null since the schema explicitly requires that a value be supplied
        String pattern = element.getAttribute("pattern");
        bean.addConstructorArgValue(pattern);

        // this however is an optional property
        String lenient = element.getAttribute("lenient");
        if (StringUtils.hasText(lenient)) {
            bean.addPropertyValue("lenient", Boolean.valueOf(lenient));
        }
    }

}

Nota:

Usamos AbstractSingleBeanDefinitionParser fornecido pela Spring para lidar com alguns trabalhos básicos de criação de uma única BeanDefinition.
Reescrevemos o método doParse da classe pai AbstractSingleBeanDefinitionParser para implementar nossa própria lógica para criar uma BeanDefinition de tipo único.

4. Registre o esquema e o manipulador no Spring

4.1 Esquema de registro

Criar recursos

META-INF / spring.schemas

http\://www.mycompany.com/schema/myns/myns.xsd=xml/myns.xsd

4.2 Manipulador de registro

Criar recursos

META-INF / spring.handlers

http\://www.mycompany.com/schema/myns=com.jeiker.namespace.MyNamespaceHandler

5. Teste

5.1 Configurar schema-beans.xml

<?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:myns="http://www.mycompany.com/schema/myns"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.mycompany.com/schema/myns http://www.mycompany.com/schema/myns/myns.xsd">

    <myns:dateformat id="dateFormat"
                     pattern="yyyy-MM-dd HH:mm"
                     lenient="true"/>

</beans>

5.2 Categoria de teste

package com.jeiker.namespace;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.text.SimpleDateFormat;
import java.util.Date;

public class SchemaBeanDefinitionTest {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("schema-beans.xml");
        SimpleDateFormat dateFormat = context.getBean("dateFormat", SimpleDateFormat.class);
        System.out.println("-------------------gain object--------------------");
        System.out.println(dateFormat);
        String dateStr = dateFormat.format(new Date());
        System.out.println(dateStr);
    }
}