Archivo de configuración
En los ejemplos anteriores, utilizamos la definición de frijol XML para configurar componentes. En un proyecto ligeramente más grande, generalmente hay cientos de componentes. Si estos componentes se configuran utilizando definiciones de frijol XML, obviamente aumentará el tamaño del archivo de configuración, lo que hace que no sea muy conveniente encontrar y mantener.
Spring 2.5 presenta un mecanismo de escaneo de componentes automáticos para nosotros. Puede encontrar clases anotadas con anotaciones @Component, @Service, @Controller y @Repository en ClassPath, e incorporar estas clases en el contenedor Spring para administrar.
Su función es la misma que usar componentes de configuración del nodo de frijoles en archivos XML. Para usar el mecanismo de escaneo automático, necesitamos abrir la siguiente información de configuración:
<? 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: context = "http://www.springframework.org/schema/context" xsi: schemalocation = "http://www.springframework.org/schema/beans http:/www.springframework.org/schema/scoans/spring-ste http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd "> <context: component-scan base-package =" cn.itcast "/> </grans>
El <context:component-scan base-package="cn.itcast" /> La configuración registra implícitamente múltiples procesadores que analizan las anotaciones, incluido el procesador <context: annotation-config /> registrado con la configuración, es decir, si <context:component-scan base-package="cn.itcast" /> configuración está escrita, no hay necesidad de no necesitar <context:annotation-config/> necesidad de ser necesario. Además, el paquete base es un paquete (subpackaje) que debe escanear.
anotación
@Service se utiliza para anotar los componentes de la capa de negocio, @Controller se usa para anotar los componentes de la capa de control (como la acción en Struts2), y @Repository se usa para anotar el componente de acceso a datos, es decir, el componente DAO. @Component se refiere a los componentes. Cuando los componentes no son fáciles de clasificar, podemos usar esta anotación para anotar.
Este artículo se basa en el caso de la anotación de @Autowire y el ensamblaje automático.
Primero cambiamos el archivo de configuración de Spring a:
<? 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: context = "http://www.springframework.org/schema/context" xsi: schemalocation = "http://www.springframework.org/schema/beans http:/www.springframework.org/schema/scoans/spring-ste http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd "> <context: component-scan base-package =" cn.itcast "/> </grans>
Un ejemplo
Luego use la anotación de @Service para anotar la clase PersonserviceBean, de la siguiente manera:
@ServicePublic Class PersonserviceBean Implementa el servicio de personas {PERSONDARA DE PERSONDACIÓN PRIVADA; public void setPersondao (PERSONDAOO PERSONDARA) {this.persondao = perseDaoo; } @Override public void save () {perseDaoo.add (); }}Anotar la clase PersononAbean usando la anotación @Repository, como sigue:
@RepositoryPublic Class PersonondaObean implementa PERSONDAOO {@Override public void add () {System.out.println ("Ejecutar el método add () en PERSONDAOBEAN"); }}Finalmente, modificamos el código de la clase SpringTest a:
Public Class SpringTest {@Test public void instancespring () {AbstractApplicationContext ctx = new ClassPathXMLAplaPlicationContext ("Beans.xml"); Personservice Personservice = (Personservice) ctx.getBean ("PersonserviceBean"); PERSONDAOO PERSONDAOO = (PERSONDAO) CTX.GETBEAN ("PERSONDAOBEAN"); System.out.println (Personservice); System.out.println (Personondao); ctx.close (); }}Pruebe el método InstancesPring () y puede ver que la consola Eclipse imprime:
Si queremos usar el nombre especificado para obtenerlo, podemos modificar el código de la clase PersonserviceBean a:
@Service ("Personservice") Pública Clase Persona Servicio de servicios de personas IMPRESOS {PERSONDARA PERRADO PERSONDAUNA; public void setPersondao (PERSONDAOO PERSONDARA) {this.persondao = perseDaoo; } @Override public void save () {perseDaoo.add (); }}De esta manera, el código de la clase SpringTest debe cambiarse a:
Public Class SpringTest {@Test public void instancespring () {AbstractApplicationContext ctx = new ClassPathXMLAplaPlicationContext ("Beans.xml"); Personservice Personservice = (Personservice) ctx.getBean ("Personservice"); System.out.println (Personservice); ctx.close (); }}Pruebe el método InstancesPring () y puede ver que la consola Eclipse imprime:
Hemos aprendido el alcance de los frijoles administrados por la primavera antes, y podemos saber que el alcance de los dos frijoles administrados por la primavera arriba es singleton por defecto. Por supuesto, también podemos cambiar el alcance de los frijoles administrados por la primavera, como cambiar el código de la clase del servicio de personas a:
@Service ("Personservice") @scope ("prototipo") clase pública PersonserviceBean Implementa el servicio de personas {PERSONDAUNA PERSONDACIÓN PRIVADA PERSONDARA; public void setPersondao (PERSONDAOO PERSONDARA) {this.persondao = perseDaoo; } @Override public void save () {perseDaoo.add (); }}Esto significa que el alcance del servicio de servicio de personas administrado por la primavera se ha convertido en un prototipo. En este momento, modificamos el código de la clase SpringTest a:
Public Class SpringTest {@Test public void instancespring () {AbstractApplicationContext ctx = new ClassPathXMLAplaPlicationContext ("Beans.xml"); Personservice Personservice1 = (Personservice) ctx.getBean ("Personservice"); Personservice Personservice2 = (Personservice) ctx.getBean ("Personservice"); System.out.println (Personservice1 == Personservice2); ctx.close (); }}Pruebe el método InstancesPring () y puede ver que la consola Eclipse imprime:
El alcance del prototipo significa que cada vez que obtienes un frijol de un contenedor de resorte, es un objeto nuevo.
Si los componentes se incluyen en el contenedor de resorte escaneando automáticamente en la ruta ClassPath, ¿cómo especificar el método de inicialización y el método de destrucción del bean? En este momento, necesitamos usar dos anotaciones: @PostConstruct y @Predestroy. Para la experimentación, modificamos el Código de la Clase del Servicio de Personas a:
@Service ("Personservice") Pública Clase Persona Servicio de servicios de personas IMPRESOS {PERSONDARA PERRADO PERSONDAUNA; @PostConstruct public void init () {System.out.println ("Inicializar el recurso"); } @Predestroy public void destruye () {System.out.println ("destruir, cerrar recurso"); } public void setPersondao (Personondao Personondao) {this.persondao = Personondao; } @Override public void save () {perseDaoo.add (); }}A continuación, necesitamos modificar el código de la clase SpringTest a:
Public Class SpringTest {@Test public void instancespring () {AbstractApplicationContext ctx = new ClassPathXMLAplaPlicationContext ("Beans.xml"); Personservice Personservice = (Personservice) ctx.getBean ("Personservice"); ctx.close (); }}De esta manera, pruebe el método InstancesPring () y la consola Eclipse imprimirán:
Para ver el código fuente, haga clic para dejar que Spring escanee automáticamente y administre los frijoles para descargar.
Resumir
Lo anterior es el paquete automático de escaneo de primavera introducido por el editor. Espero que sea útil para todos. Si tiene alguna pregunta, déjame un mensaje y el editor responderá a todos a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!