1. Notas
La anotación es un mecanismo similar a la anotación. Agregar anotaciones en el código puede usar esta información en algún momento posterior. A diferencia de los comentarios, los comentarios son para que lo veamos. La máquina virtual Java no puede compilar, y las anotaciones no se compilan, pero podemos leer la información en las anotaciones a través del mecanismo de reflexión. La anotación usa la palabra clave @Interface, hereda java.lang.annotition.annotation
1. Anotaciones en Javase
Déjame darte un ejemplo para revisar qué anotación es en Javase. La clave son dos puntos: la definición de anotación y cómo obtener la información por encima de la anotación a través de la reflexión.
1. Primero defina dos anotaciones. Uno está anotado classInfo en la clase, y el otro está anotado MethodInfo en el método.
Classinfo
paquete com.itheima10.annotation; import java.lang.annotation.documented; import java.lang.annotation.elementType; import java.lang.annotation.retention; import java.lang.annotation.retentionPolicy; import java.lllang.annotation.target; @target (elementtype.type.tyty.ty / / / /importación; ser utilizado en la clase @Retention (retenciónPolicy.Runtime) // en Java, archivos de clase y anotaciones de tiempo de ejecución @Documented // se puede generar en el documento de ayuda public @Interface classInfo { /** * Esta anotación tiene dos propiedades de tipo de cadena * @return * /name de cadena () predeterminado ""; Valor de cadena () predeterminado "";}MethodInfo
paquete com.itheima10.Annotation; import java.lang.annotation.documented; import java.lang.annotation.ElementType; import java.lang.annotation.retention; import java.lang.annotation.retentionPolicy; import java.lllang.annotation.target; @Target (elementtype.meth.meth) ser utilizado en métodos @Retention (retenciónPolicy.Runtime) // en Java, archivos de clase y anotaciones de tiempo de ejecución @Documented // se puede generar en Ayuda documentar public @Interface MethodInfo { /*** Esta anotación tiene dos propiedades del tipo de cadena* /String Name () predeterminado ""; Valor de cadena () predeterminado "";}2. Escribe una clase anotationuse para usar la anotación definida anteriormente
paquete com.itheima10.annotation; @classinfo (name = "xiaopingguo118", valor = "niu") public class annotationUse {@methodinfo (name = "java", valor = "marco de primavera es importante") public void java ()}}3. Escriba la clase de anotación de la clase de prueba y analice las propiedades por encima de las dos anotaciones
paquete com.itheima10.annotation; import java.lang.reflect.method; import org.junit.test; public class AnnotationTest {public static void test () { / ** * Si parse la anotación de la clase, obtenga clase * si la anotación del método, obtenga el método primero * / class class1 = itheima10; // juzga si hay una anotación de classInfo en la clase if (class1.isannotationPresent (classInfo.class)) {// Obtenga la anotación en classClassInfo classInfo = (classInfo) class1.getAnnotation (classInfo.class); System.out.println (classInfo.Value ()); System.out.println (classinfo.name ()); } Método [] métodos = class1.getMethods (); para (método Método: métodos) {// ¿Existe una anotación de MethodInfo en el método que está atravesado if (Method.IsannotationPresent (MethodInfo.Class)) {MethodInfo MethodInfo = Method.getAnnotation (MethodInfo.class); System.out.println (MethodInfo.name ()); System.out.println (MethodInfo.Value ()); }}} @Test public void test () {annotationTest.test (); }}2. Anotaciones en primavera
El marco de primavera nos proporciona funciones de anotación.
El uso de la programación de anotaciones es principalmente para reemplazar los archivos XML y hacer que el desarrollo sea más rápido. Sin embargo, el uso de archivos XML es resolver el problema de modificar el código fuente del programa. Ahora que no uso archivos XML, ¿no violaría el principio de apertura y cierre? Es cierto. Sin embargo, las anotaciones también son buenas, por lo que no necesita configurar tantos archivos XML al usar anotaciones. Lo más importante es que tienen una alta eficiencia de desarrollo. .
Cuando no se utilizan anotaciones, se deben configurar muchas etiquetas <Bean> en el archivo de configuración ApplicationContext.xml del marco Spring para declarar objetos de clase. Usando anotaciones, no necesita agregar la extracción de etiquetas en el archivo de configuración, y la descripción correspondiente es agregar instrucciones en la posición "Comentario" de la clase correspondiente. La introducción específica es la siguiente:
• 1. La combinación de relaciones entre los objetos @Resource , el valor predeterminado es ensamblar por nombre. Si el objeto asociado no se puede encontrar en función del nombre, la búsqueda por tipo continuará. Si no se especifica el atributo de nombre,
• Cuando la anotación está marcada en un campo, el valor predeterminado es tomar el nombre del campo como el nombre del bean para encontrar el objeto de dependencia
• Cuando la anotación está marcada en el método Setter del atributo, el nombre de atributo predeterminado se toma como el nombre del bean para encontrar el objeto de dependencia.
• Nota: si no se especifica el atributo de nombre y el objeto de dependencia no se puede encontrar de forma predeterminada, la anotación @Resource vuelve al ensamblaje por tipo. Pero una vez que se especifica el atributo de nombre, solo se puede ensamblar por nombre.
• 2. @Autowired
@AUtowired se ensambla por tipo de forma predeterminada, @Resource se ensambla por nombre de forma predeterminada, y solo cuando no se encuentre un bean que no se encuentre el nombre se ensamblará por tipo. La solución es ensamblar objetos dependientes por tipo. Por defecto, requiere objetos dependientes para existir. Si se permiten valores nulos, se puede establecer en falso.
• 3. @Índice
Si queremos usar el ensamblaje por su nombre, podemos usarlo junto con la anotación @Qualifier.
1. Para usar anotaciones, debe agregar el espacio de nombres y los pasos del archivo de restricción al archivo de configuración:
Introducir el espacio de nombres de contexto
<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"
...
http://www.springframework.org/schema/context/spring-context-2.5.xsd ">
2. Agregar contexto: etiqueta anotación-config al archivo de configuración
<contexto: anotación-config> </contexto: anotación-config>
Ejemplo de demostración:
Escriba una clase de persona con un atributo de estudiante y un método Say (). El código es el siguiente
paquete com.itheima10.spring.di.annotation; import javax.annotation.resource; import org.springframework.beans.factory.annotation.aUtowired; import org.springframework.beanss.factory.annotation.qualifier;/*** @autowired // match por tipo** @autowired // type @califier ("estudiante") * */public class Person {@Resource (name = "estudiante") estudiante privado; public void dice () {this.student.say (); }}El código de clase de los estudiantes es el siguiente
paquete com.itheima10.spring.di.annotation; public class Student {public void say () {System.out.println ("Student"); }}Configurar el archivo ApplicationContext.xml
<? xml versión = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: context = "http://www.springframework.org/schema/context" " xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.-2.-2.-2. Estudiante en Spring Container-> <Bean id = "Person"> </bean> <bean id = "estudiante"> </lebe> <!-Introducir el espacio de nombres de contexto xmlns: context = "http://www.springframework.org/schema/context" http://www.springframework.org/schema/contextExtExt. http://www.springframework.org/schema/context/spring-context-2.5.xsd "-> <!-El remidor de anotaciones que se ha inyectado desde que se inició-> <context: annotation-config> </context: annotation-config> </arras>
Escriba la clase de anotación de la clase de prueba
paquete com.itheima10.spring.di.annotation; import org.junit.test; import org.springframework.context.applicationContext; import org.springframework.context.support.classpathxmlapplicationContext;/*** Principle:* 1. Inicio el contenedor de primavera* 2. Instantáneo y el estudiante. Cuando el contenedor de primavera se analiza a* <contexto: anotación-config> </context: annotation-config>*, el analizador de anotaciones para la inyección de dependencia se iniciará* 4. El contenedor de primavera buscará dentro del alcance de los frijoles incluidos en la administración de primavera para ver qué propiedades de estas clases se agrega con @Resource annotation* 5. El valor del atributo de nombre de la anotación es "" * si es "", coincidirá con el nombre del atributo donde se encuentra la anotación y el valor de la ID en el contenedor de resorte. Si la coincidencia es exitosa, la asignación * Si la coincidencia no tiene éxito, la asignación se realizará de acuerdo con el tipo. Si la coincidencia es exitosa, la asignación se asignará * Si la coincidencia no tiene éxito, la asignación se informará * Si la coincidencia no tiene éxito, la asignación se informará directamente * Si la coincidencia no es exitosa, la asignación se informará * Si la coincidencia no es exitosa, la asignación se informará directamente * si la asignación no se informará, la asignación se informará * si la coincidencia no será exitosa, la asignación se informará directamente a la actualización * que solo se informará * anhotations, lo que solo se informará. Compare el tipo de referencia XML y las anotaciones. La eficiencia es relativamente alta. Escribir es más problemático. Las anotaciones de escritura son relativamente simples y menos eficientes * */public class AnnotationTest {@test public void testAnnotation () {applicationContext context = new ClassPathXMLApPlicationContext ("ApplicationContext.xml"); Persona persona = (persona) context.getBean ("persona"); persona.say (); }}Si usa anotaciones, no necesita cargar a la persona y al estudiante en el archivo de configuración, lo que puede simplificar la redacción del archivo de configuración.
3. Escanear
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 la definición de frijol XML, obviamente aumentará el tamaño del archivo de configuración, lo que hace que no sea muy conveniente encontrar y mantener. Spring2.5 presenta un mecanismo automático de escaneo de componentes para nosotros, que puede encontrar clases anotadas con @Component, @Service, @Controller y @Repository Anotations en el 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 un archivo XML. Para usar el mecanismo de escaneo automático, necesitamos abrir la siguiente información de configuración:
1. Introducir el espacio de nombres de contexto
Agregar contexto: etiqueta componente-scan en el archivo de configuración XML
Donde el paquete base es el paquete (subpackaje) que debe escanear.
Ejemplo:
El ejemplo anterior se escribe en el modo de escaneo de la siguiente manera
@ComponentPublic Class Person {@Resource (name = "estudiante") Estudiante privado; public void dice () {this.student.say (); }}@ComponentPublic Class Student {public void say () {system.out.println ("estudiante"); }}ApplicationContext.xml solo debe configurarse en una oración
<
Escriba la clase de anotación de la clase de prueba
/*** Principio* 1. Inicie el contenedor de primavera* 2. Parsing de contenedor de primavera* <context: component-scan base-paquete = "com.itheima10.spring.scan"> </context: component-scan> 3. Escanear en los paquetes y subpackages especificados por base de base para ver qué clases contienen @Component Annotation 4. == equivalente a <bean id = "persona"> @Component ("aa") Persona de clase pública {} == equivalente a <bean id = "aa"> 5. Siga los pasos de análisis de @resource: todo el proceso se escanea dos veces, la eficiencia se está volviendo cada vez más baja, y la escritura se está volviendo más fácil y más fácil y más fácil de clases públicas { @@Test Void testEntation (Aplication). context = new ClassPathXMLApPlicationContext ("ApplicationContext.xml"); Persona persona = (persona) context.getBean ("persona"); persona.say (); }}Reaparición de instancias
Cambiaremos el último sistema de gestión de documentos en item51 en anotación. La interfaz del documento permanece sin cambios, con métodos de lectura y escritura. Las clases de implementación son las siguientes ExcelDocument, PDFDocument y WordDocument.
@Component ("ExcelDocument") public class ExcelDocument Documents {public void read () {System.out.println ("Excel Read"); } public void write () {System.out.println ("Excel Write"); }}@Componente ("PDFDocument") Public Class PDFDocument Document {public void Read () {System.out.println ("PDF Read"); } public void write () {System.out.println ("PDF Write"); }}@Componente ("WordDocument") public class WordDocument Documents {public void read () {System.out.println ("Word Read"); } public void write () {System.out.println ("Word Write"); }}DocumentManager
@Component ("DocumentManager") Public Class DocumentManager {@Resource (name = "ExcelDocument") Documento de documento privado; public void read () {this.document.read (); } public void write () {this.document.write (); }}Archivo de configuración
<context: componente-scan base-paquete = "com.itheima10.spring.iocdi.document">
</context: componente-scan>
Escribe una clase de documento de clase de prueba
public class DocumentTest {@Test public void testDocument () {ApplicationContext context = new ClassPathXMLApPlicationContext ("ApplicationContext.xml"); DocumentManager documentManager = (documentManager) context.getBean ("DocumentManager"); documentManager.read (); documentManager.write (); }} 2. Introducción a otras funciones de anotación
@Service se utiliza para anotar los componentes de la capa comercial y las anotaciones de la capa de servicio
@Controller se usa para anotar los componentes de la capa de control (como la acción en los puntales) y la anotación de la capa de control
@Repository se usa para anotar componentes de acceso a datos, es decir, componentes DAO. Anotación de la capa de persistencia
@Component se refiere a los componentes. Cuando los componentes no son fáciles de clasificar, podemos usar esta anotación para anotar.
Ejemplos reproducir el caso MVC
Revisamos los casos de MVC en item51 nuevamente, agregando las capas DAO, servicio y acción de PERSONDAOMPL, PersonAction y PersonsServiceImpl respectivamente para agregar anotaciones al DAO, el servicio y las capas de acción de PERSONDAOMPL.
@Repository ("Personondao") Public Class PersondaoImpl implementa Personondao {@Override public void Saveperson () {System.out.println ("Save Person"); }} @Service ("Personservice") Public Class PersonserviceImpl implementa Personservice {@Resource (name = "Personondao") PERSONDAUNA PERSONDARA PERSONDAUNA; public void setPersondao (PERSONDAOO PERSONDARA) {this.persondao = perseDaoo; } @Override public void saveperson () {this.persondao.saveperson (); }} @Controlador ("PersonAction") Public Class PersonAction {@Resource (name = "Personservice") PERSONES PRIVADO Servicio de personas. public void setPersonService (Personservice Personservice) {this.personService = Personservice; } public void saveperson () {this.personService.saveperson (); }}Escribir prueba mvctest
clase pública mvctest {@Test public void testMvc () {applicationContext context = new ClassPathXMLApPlicationContext ("ApplicationContext.xml"); PersonAction PersonAction = (PersonAction) context.getBean ("PersonAction"); PersonAction.saveperson (); }}4. Herencia en primavera
La primavera admite la herencia, que se puede dividir en herencia de clase y herencia de atributos.
1. Herencia de clase
Propiedades de primavera:
(1) Resumen: si se establece en verdadero, significa que el frijol definido es abstracto, dígale a Spring que no instancie el frijol;
Pregunta: ¿Debe ser una clase abstracta? ¿Podría ser una clase abstracta?
(2) PADRE: indica la función de la identificación del bean en el bean, que es equivalente a la función de extensiones en la clase Java;
Escena: hay tres frijoles:
<bean id = "bean1" class = "... testbean"> <propiedad name = "sex" value = "masculino"/> </bean> <bean id = "bean2" class = "... testBean"> <propiedad name = "sex" value = "masculino"/> </bean> <bean id = "bean3" class = "... testbean"> <name de propiedad = "valor" valor = "mujer"/> <</> <</"bean>
Modificar: Defina el frijol principal de primavera
<bean id = "basebean" class = "... testbean"> <propiedad name = "sex" value = "masculino"/> </bean>
Definir subbeans
<bean id ="bean1" parent = "BaseBean"/> Inherit the properties of the parent bean<bean id ="bean2" parent = "BaseBean"/> <bean id ="bean3" parent = "BaseBean"> Overwrite the properties of the parent bean<property name="sex" value="female"/> </bean>
Los frijoles infantiles pueden heredar las propiedades del grano principal o anular las propiedades del frijol principal.
2. Herencia de atributos
Hay los mismos atributos entre varios frijoles diferentes, y la escena se puede extraer:
<bean id = "bean1" class = "... atestbean"> <propiedad name = "sex" value = "masculino"/> <propiedad name = "tarea" ref = "tarea"/> </bean> <bean id = "bean2" class = "... btestBean"> <Property = "Sex" Value = "masculino"/> <//> </> </> </> </> </> </> </> </> </> </> </> </rem
Modificar: (1) Extraer atributos públicos
<bean id = "basesex" abstract = "true"> <propiedad name = "sex" value = "masculino"/> </bean>
(2) Modificación de frijoles
<bean id = "bean1" class = "... atestbean" parent = "basesex"> <propiedad name = "tarea" ref = "tarea"/> </bean> <bean id = "bean2" class = "... btestBean" parent = "basesex"/>
Aquí el bean tiene atributos de padres y clase, y el Basesex señaló por el padre es permitir que diferentes frijoles compartan el mismo valor de atributo; Cuando la transacción DeproxyFactoryBean declara el servicio, la herencia del atributo de frijol puede reducir significativamente la configuración XML redundante.
La herencia basada en la anotación no requiere atributos principales.
Tengamos una pequeña imagen de resumen el último
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.