La relación entre el frijol y el contenedor de primavera
La información de configuración de frijoles define la implementación y las dependencias de los frijoles. El contenedor de primavera establece el registro de definición de frijoles dentro del contenedor basado en diversas formas de información de configuración de frijoles, luego carga e instancia los frijoles de acuerdo con el registro y establece dependencias entre frijoles y frijoles. Finalmente, estos frijoles listos se colocan en el grupo de caché de frijoles para que las aplicaciones externas llamen.
Este artículo le presentará en detalle sobre el uso de métodos de codificación para configurar dinámicamente los frijoles en la primavera. Los compartiremos para su referencia y aprendizaje. No diré mucho a continuación, echemos un vistazo a la introducción detallada juntos.
1 defaultListableBeanFactory
DefaultListableBeanFactory implementa la interfaz ConfigureableListableBeanFactory, que puede inyectar dinámicamente frijoles a través de esta clase. Para garantizar que el frijol inyectado también pueda ser mejorado por AOP, necesitamos implementar la interfaz de fábrica de fábrica de Bean, BeanFactoryPostPossor.
Frijoles que requieren inyección dinámica:
Bookservice de clase pública {bookdao bookdao; public void setbookdao (bookdao bookdao) {this.bookdao = bookdao; } public bookdao getBookDao () {return bookdao; }}Implementación de la interfaz postprocesador de fábrica del bean:
@ComponentPublic BookServiceFactoryBean implementos BeanFactoryPostProcessor {public void PostProcessBeanFactory (configuableBeanFactory BeanFactory) lanza BeanSexCeption {defaultListableBeanFactory factory = (defaultBeanFactory) beanFactory; // Definición de bean BeandefinitionBuilder Builder = BeandefinitionBuilder.GenericBeanDefinition (bookservice.class); // establecer el builder de propiedades.addpropertyreference ("bookdao", "bookdao"); // Registre la definición de bean factory.RegisterBeanDefinition ("bookservice1", builder.getrawBeanDefinition ()); // Registre la instancia de Bean factory.Registersingleton ("bookservice2", new net.deniro.spring4.dynamic.bookservice ()); }}Aquí se supone que Bookdao ha sido inyectado en el contenedor (XML o método de anotación).
Aquí, podemos registrar la definición de un frijol o registrar directamente la instancia de un bean.
Configuración:
<context: componente-scan base-paquete = "net.deniro.spring4.dynamic" />
Pruebas unitarias:
Bookservice bookservice1 = (bookservice) context.getBean ("bookservice1"); afirmarnotnull (bookservice1); afirnNotnull (bookservice1.getBookDao ()); bookservice bookservice2 = (bookservice) context.getBean ("bookervice2"); afirmarnotnotnull (bookservice2);2 etiquetas personalizadas
Para encapsular mejor los componentes y mejorar su facilidad de uso, definimos los componentes como etiquetas.
Los pasos para personalizar la etiqueta son:
Crear bookservice.xsd en la carpeta de esquema en recursos
<? xml versión = "1.0" encoding = "utf-8"?> <xsd: schema xmlns = "http://www.deniro.net/schema/service" xmlns: xsd = "http://www.w3.org/2001/xmlschema" "" "" "" "" ". xmlns: beans = "http://www.springframework.org/schema/Beans" TargetNamSpace = "http://www.deniro.net/schema/Service" elementFormDefault = "calificado" ATRIFIMSEFORSDEFAUL namespace = "http://www.springframework.org/schema/beans"/> <!-Define la etiqueta de servicio de libros-> <xsd: elemento name = "book-service"> <xsd: complextype> <xsd: complejcontent> <xsd: extension base = "frijoles: identificados" <!-de define-daoS-DaoS-DaoS-DaoS-DaoS-DaoS--Define-DaO <xsd: attribute name = "dao" type = "xsd: string" use = "required"/> </xsd: extension> </xsd: complejContent> </xsd: complextype> </xsd: elemento> </xsd: esquema>
Luego defina el analizador de la etiqueta de servicio:
Public Class BookservateFinitionParser implementa BeandefinitionParser {public Beandefinition Parse (elemento de elemento, parsercontext Parsercontext) {// Crear definición de beanBeanDefinitionBuilder Builder = beandefinitionBuilder.GenericBeanDefinition (bookservice.class); // inyectar la cadena de atributo de etiqueta personalizada dao = element.getAttribute ("dao"); builder.addpropertyreference ("bookdao", dao); // registrar bean define parsercontext.registerBeanComponent (nuevo BeanComponentDefinition (Builder .getrawBeanDefinition (), "Bookservice")); regresar nulo; }}Luego registre el analizador que acaba de definir en el espacio de nombres:
Public Class BookserviceNamespaceHandler extiende NamespaceHandLersUpport {public void init () {RegistroBeanDefinitionParser ("Servicio de libros", nuevo bookservateFinitionParser ()); }}Luego cree la carpeta Meta-INF en recursos y cree Spring.Schemas y Spring.Handlers, que se utilizan para configurar la ruta del archivo de estructura del documento de la etiqueta personalizada y el analizador que analiza el espacio de nombres personalizado.
Ruta de archivo
Spring.Handlers:
http/: //www.deniro.net/schema/service=net.deniro.spring4.dynamic.bookserviceNamespaceHandler
Spring.Schemas:
http/: //www.deniro.net/schema/service.xsd=schema/bookservice.xsd
Nota: El archivo XSD debe colocarse en el Directorio de Recursos de Descendientes.
Citando etiquetas personalizadas:
<? xml versión = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" "" "" xmlns: me = "http://www.deniro.net/schema/service" xsi: schemalocation = "http://www.springframework.org/schema/Beans http://www.springframework.org/schema/beans/spring-beanss. http://www.deniro.net/schema/service http://www.deniro.net/schema/service.xsd "> <bean id =" bookdao "/> <me: book-service dao =" bookdao "/> </beachs>
Aquí, hicimos referencia a la etiqueta personalizada en la cabeza y la llamamos "yo", y luego podemos usarla o (∩_∩) o ~
Resumir
Lo anterior es todo el contenido de este artículo. Espero que el contenido de este artículo tenga cierto valor de referencia para el estudio o el trabajo de todos. Si tiene alguna pregunta, puede dejar un mensaje para comunicarse. Gracias por su apoyo a Wulin.com.