Las anotaciones en primavera se pueden dividir aproximadamente en dos categorías:
1) anotaciones relacionadas con contenedores de frijoles de primavera o fábricas de frijoles;
2) Anotaciones relacionadas con SpringMVC.
Las anotaciones relacionadas con el contenedor de frijoles de Spring incluyen: @Required, @AUTOWIRED, @PostConstruct, @Predestory, y las anotaciones en el Javax.inject estándar JSR-330.* Ese Spring 3.0 ha sido compatible (@Inject, @named, @Qualifier, @Provider, @cope, @singleton).
Las anotaciones relacionadas con SpringMVC incluyen: @Controller, @RequestMapping, @requestparam, @ResponseBody, etc.
Para comprender las anotaciones en primavera, primero debe comprender las anotaciones en Java.
1. Anotaciones en Java
Las anotaciones han comenzado a introducirse en Java 1.5. El que más estamos más familiarizados debería ser: @Override, que se define de la siguiente manera:
/** * Indica que una declaración de método está destinada a anular una declaración de método * en un supertipo. Si un método se anota con * Este tipo de anotación se requiere para generar un mensaje de error * a menos que al menos una de las siguientes condiciones se mantenga: * El método anula o implementa un método declarado en un * SuperType. * El método tiene una firma que es equivalente a la de * cualquier método público declarado en el objeto. * * @author Peter von der Ahé * @author Joshua Bloch * @JLS 9.6.1.4 @Override * @since 1.5 */ @Target (elementType.method) @Retention (retenciónPolicy.source) public @Interface anveride {}Desde la anotación, podemos ver que la función de @Override es solicitar al compilador que el método utilizado por @Override Annotation debe anular la clase principal o un método del mismo nombre en java.lang.object. Vemos que @Target y @Retention se usan en la definición de @Override. Son las llamadas "metaannotaciones": son las anotaciones que definen las anotaciones o las anotaciones que anotaciones (mareadas ...). Echemos un vistazo a @Retention
/** * Indica cuánto tiempo se retendrán las anotaciones con el tipo anotado *. Si no hay anotación de retención en * una declaración de tipo de anotación, la política de retención predetermina a * retentionPolicy.class. * /@Documented@retención (retenciónPolicy.Runtime) @Target (elementType.annotation_type) public @interface retención { /*** Devuelve la política de retención. * @return la política de retención */ RetententPolicy Value ();}@Retention se usa para solicitar cuánto tiempo se retiene la anotación. Hay tres valores:
El compilador debe divulgar las anotaciones de Public Enum RetententPolicy { /***. * / Source, / ** * Las anotaciones deben ser registradas en el archivo de clase por el compilador * pero la VM no necesita ser retenida en el tiempo de ejecución. Este es el comportamiento predeterminado *. * / Class, / ** * Las anotaciones deben ser registradas en el archivo de clase por el compilador y * retenidos por la VM en tiempo de ejecución, por lo que pueden leerse reflexivamente. * * @see java.lang.reflect.annotatedElement */ runtime} RetententPolicy.surce se retiene a nivel del código fuente y se abandona por el compilador (@Override es este tipo); RetententPolicy.Class se retiene a nivel de archivo de clase compilado por el compilador, pero descartado por la máquina virtual;
RetentionPolicy.Runtime se reserva hasta el tiempo de ejecución y puede ser leído por reflexión.
Mira @Target:
paquete java.lang.annotation;/*** Indica los contextos en los que es aplicable un tipo de anotación. Los * contextos de declaración y los contextos de tipo en los que se puede especificar un tipo de anotación * aplicable se especifica en JLS 9.6.4.1, y se denotan en el código fuente por enum * constantes de java.lang.annotation.ElementType * @since 1.5 * @JLS 9.6.4.1 @Target * @JLS 9.7.4 Donde las anotaciones pueden aparecer las anotaciones pueden aparecer. */@Documentado@retención (retenciónPolicy.runtime) @Target (elementType.annotation_type) public @interface Target {/** * Devuelve una matriz de los tipos de elementos a los que se puede aplicar un tipo de anotación *. * @return una matriz de los tipos de elementos un tipo de anotación * se puede aplicar a */elementType [] valor ();}@Target se usa para solicitar el uso de esta anotación, y los valores son:
public enum elementtype { /** clase, interfaz (incluido el tipo de anotación) o declaración enum* /type, /** Declaración de campo (incluye constantes enum)* /field, /** Declaración de método Declaración* /Método, /** Declaración formal de parámetros* /parámetro, /** Declaración de constructor* /construcción, /** Declaración de variable local* /local_variable, /*** Declaración de Tipo de constructor ** ** Constructor* Annotation_type, / ** Declaración del paquete * / paquete, / ** * Declaración de parámetros de tipo * @since 1.8 * / type_parameter, / ** * Uso de un tipo * @since 1.8 * / type_use}Indica dónde se puede usar esta anotación por separado: 1) clase, interfaz, anotación, enum; 2) dominio de atributo; 3) método; 4) parámetros; 5) constructor; 6) variables locales; 7) tipo de anotación; 8) Paquete
entonces:
@Target (elementType.method) @Retention (retentionPolicy.source) public @Interface Anverride {}Significa que @Override solo se puede usar en métodos, retenidos en el nivel del código fuente, procesado por el compilador y luego descartado.
También hay una meta anotación de uso frecuente @documented:
/** * Indica que las anotaciones con un tipo deben ser documentadas por Javadoc * y herramientas similares de forma predeterminada. Este tipo debe usarse para anotar las * declaraciones de tipos cuyas anotaciones afectan el uso de elementos anotados * por parte de sus clientes. Si una declaración de tipo se anota con * documentada, sus anotaciones se convierten en parte de la API pública * de los elementos anotados. */@Documented@retención (retenciónPolicy.Runtime) @Target (elementType.annotation_type) public @Interface documented {}Indica si Javadoc puede procesar las anotaciones y retenidas en el documento.
2. Personalizar y procesar anotaciones personalizadas con meta anotaciones
Con meta anotaciones, puedo usarlo para personalizar las anotaciones que necesitamos. Combinar anotaciones personalizadas y AOP o filtros es un arma muy poderosa. Por ejemplo, las anotaciones se pueden usar para lograr un control de grano fino de los permisos: use anotaciones de permiso en clases o métodos, e interceptarlos en AOP o filtros. Aquí hay una implementación de la anotación sobre los permisos de inicio de sesión:
/*** No se requiere anotación de inicio de sesión*/@Target ({elementType.method, elementType.type})@retención(CretentPolicy.runtime)@documentedpublic @interface nologin {}Tenemos anotación personalizada @nologin, que puede usarse en métodos y clases. La anotación se conserva hasta el tiempo de ejecución y puede leerse mediante reflexión. El significado de esta anotación es: se puede acceder a la clase o método anotado por @nologin incluso si el usuario no está conectado. El siguiente es el proceso de la anotación:
/*** Verifique el interceptor de inicio de sesión* Si no necesita verificar el inicio de sesión, puede agregar @nologin al método o controlador*/public class CheckLogInInterceptor implementa HandlerInterceptor {private static final logger = logger.getLogger (checkLoginInterceptor.classssssssssssssssssssssssssssson); @anveride public boolean -prehander (httpServletEnt, httpSerTpsEnt, htttTserveRest, httTtPeTtTTRETRETRE Handler) lanza la excepción {if (! (Handler InstanceOf Handlermethod)) {logger.warn ("El controlador de operación actual no es handlermethod =" + handler.getClass (). getName () + ", req =" + request.getQueryString (); return true;} handlermethod handlermethod = (handlermethod) handlermethod) handlerLer; string metoder; handlermethod.getMethod (). getName (); // Determinar si necesita verificar el inicio de sesión nologin = handlermethod.getMethod (). getAnnotation (nologin.class); if (null! = nologin) {if (logger.isdeBugeNabled ()) {logger.deBug ("actual de operación métodos de operación =" + MethodName + "No necesidad de verificar login");} return true;} nologin = handlermethod.getMethod (). getDeClaringClassss (). if (null! = nologin) {if (logger.isdeBugeNable ()) {logger.deBug ("actual de operación de operación MethodName =" + MethodName + "No necesidad de verificar login");} return n. "El usuario no inició sesión, ip =" + request.getRemoteaddr ()); respuesta.getwriter (). Write (JSONConConvertor.ConvertFailResult (ErrorCodeenum.not_login) .ToString ()); // return Mensaje de error return FALSE;} return;}@anveride public Handler, ModelAndView ModelAndView) lanza la excepción {} @Override public void AfterCompletion (HttpServletRequest solicitud, respuesta httpservletreSponse, manejador de objetos, excepción ex) lanza una excepción {}}Arriba definimos un interceptor de inicio de sesión, primero usando la reflexión para determinar si el método está anotado por @nologin:
Nologin nologin = handlermethod.getMethod (). GetAnnotation (nologin.class);
Luego determine si la clase está anotada por @nologin:
nologin = handlermethod.getMethod (). getDeclaringClass (). getAnnotation (nologin.class);
Si se anota, devuelve verdadero. Si no se anota, se determina si se ha iniciado sesión. Si no se registra, devuelve mensajes de error al primer plano y falso. Este es un ejemplo simple de usar anotaciones y filtros para el procesamiento de permisos. Si nos expandimos, podemos usar anotaciones para indicar que los usuarios solo pueden acceder a un cierto método o clase con un determinado rol o permisos, y luego juzgar en el filtro.
3. Anotaciones relacionadas con el contenedor de frijoles de primavera
1) @Autowired es la anotación que más usamos. De hecho, AutoWire = BYTYPE es una dependencia de inyección automática basada en el tipo (inyección de dependencia basada en anotaciones), que puede usarse en el dominio, el método y el constructor.
2) @Qualifier es AutoWire = byName. Cuando la anotación de @aUtowired determina que varios tipos de frijoles son los mismos, debe usar @Qualifier ("xxbean") para especificar la ID del frijol dependiente:
@Controlador @requestmapping ("/user") public class Hellocontroller {@aUtowired @qualifier ("UserService") UserService privado UserService;3) @Resource pertenece al estándar JSR250 y se usa en el dominio y los métodos. También es una inyección de dependencia del tipo de byname. Método de uso: @Resource (name = "xxbean"). @Resource sin parámetros El nombre de la clase de valor predeterminado tiene minúsculas.
4) Anotaciones en JSR-330 estándar javax.inject.* (@Inject, @named, @Qualifier, @provider, @scope, @singleton). @Inject es equivalente a @aUtowired, @named es equivalente a @Qualifier, y @named también se usa en la clase como @Component.
5) @Component, @Controller, @Service, @Repository, estas anotaciones son diferentes de las anotaciones anteriores. Las anotaciones anteriores se inyectan en los frijoles dependidos, y la función de estas anotaciones es producir frijoles. Estas anotaciones se anotan en la clase, anotando la clase en frijoles uno por uno en la fábrica de frijoles de primavera. @Controller, @Service, @Repository es básicamente @Component con semántica más refinada.
6) @PostConstruct y @Predestroy no se usan para la inyección de dependencia, sino para el ciclo de vida del bean. Similar al método de destino Init-Method (InitializeingBean) (DisposableBean)
4. Procesamiento de anotaciones en primavera
El procesamiento de anotaciones en primavera se realiza básicamente mediante la implementación de la interfaz beanpostprocessor:
Interfaz pública BeanPostProcessor {Object PostProcessBeForeinitialization (Object Bean, String BeanName) lanza BeanSexception; Object PostProcessAfterInitialization (objeto bean, string beanName) lanza Beansexception;}Las clases de procesamiento relacionadas son: autowiredAntationBeanPostProcessor, CommonAnnotationBeanPoanProcessor, PersistenceAnnotationBeanPostPossor, requerido AnnotationBeanPostProcessor
Estas clases de procesamiento se pueden configurar implícitamente en el contenedor Spring a través de <contexto: anotación-config/>. Todos estos son el procesamiento de la inyección de dependencia, así como el procesamiento de las anotaciones de frijoles de producción (@Component, @Controller, @Service, @Repository):
<context: componente-scan base-paquete = "net.aazj.service, net.aazj.aop" />
Estos se realizan especificando la ruta del paquete base escaneada, escanándolos en contenedores de frijoles de resorte. Tenga en cuenta que el contexto: Component-scan también configurará AutowiredAnnotationBeanPostProcessor y CommonAnnotationBeanPostProcessor de forma predeterminada. Por lo tanto <contexto: anotación-config/> se puede omitir. Además, Context: Component-scan también puede escanear la anotación de AOP de estilo @Aspect, pero es necesario agregar <aop: spectJ-autoproxy/> al archivo de configuración para la cooperación.
5. La diferencia entre las anotaciones de primavera y las anotaciones estándar JSR-330:
Resumir
Lo anterior se trata de comprender rápidamente las diversas anotaciones en la primavera. Espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!