1: Introducción a las anotaciones de Java
Las anotaciones a menudo se usan en el desarrollo, y ocasionalmente veo anotaciones personalizadas en proyectos. Hoy, discutamos cuál es la anotación, así como los escenarios de aplicación de la anotación y cómo personalizar la anotación.
Las siguientes enumeras anotaciones comunes en el desarrollo
@Override: se usa para identificar que el método hereda de la superclase. Cuando el método de la clase principal se elimina o modifica, el compilador indicará un mensaje de error (siempre puede ver esto en el método toString () que vemos con más frecuencia)
@Depreced: significa que esta clase o método está en desuso y ha expirado. Si el usuario aún quiere usarlo, se generará una advertencia de compilación.
@SupessWarnings: mensaje de advertencia del compilador para ignorar
Prueba de Junit: @test
Algunas anotaciones de Spring: @Controller, @RequestMapping, @RequestParam, @ResponseBody, @Service, @Component, @Repository, @Resource, @AUTOWIRE
Anotaciones para la verificación de Java: @notnull, @email
Echemos un vistazo a la verdadera cara del Monte Lu en la anulación de anotación. Java
@Target (elementType.method) @Retention (retentionPolicy.source) public @Interface Anverride {} 2: Conocimiento básico de la anotación de Java
1. Tipo de datos de anotación Java
Las anotaciones se escriben en archivos .java y usan @Interface como palabra clave, por lo que las anotaciones también son un tipo de datos de Java. De una definición amplia, clase, interfaz, enum y anotación son todos los tipos de clases.
2. Meta anotación de Java
Al crear anotaciones, debe usar algunas anotaciones para describir las anotaciones que creó, es decir, las anotaciones escritas en @Interface. Estas anotaciones se llaman meta anotaciones, como @Target, @Tretention, etc. Se ven en anulación. Aquí hay algunas meta anotaciones
@Documented: se usa para marcar si la anotación se incluye al generar Javadoc. Puede ver que esta anotación es la misma que @Override, la anotación está vacía y no hay nada.
@Documented@retención (retenciónPolicy.Runtime) @Target (elementType.annotation_type) public @Interface documented {}@Target: se usa para definir dónde se pueden usar anotaciones. Por defecto, se puede usar en cualquier lugar, o puede especificar el alcance de uso. En el desarrollo, es más común usar anotaciones en clases (como @Controller), campos (como @autowire), métodos (como @RequestMapping), parámetros de métodos (como @requestparam), etc.
Tipo: Clase, Interfaz o Declaración de Enum
Declaración de campo: dominio (atributo)
Método: Declaración del método
Parámetro: Declaración de parámetros
Constructor: Declaración del método del constructor
Local_variable: declaración de variable local
Anotación_type: declaración de tipo de comentarios
Paquete: declaración de paquete
Target.java
@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 ();} 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* / type_parameter, / ** Uso de un tipo* / type_use}@Inherited: permite que las subclases hereden las anotaciones en la clase principal, y pueden obtener las anotaciones de la clase principal a través de la reflexión.
@Documentado@retención (retenciónPolicy.Runtime) @Target (elementType.annotation_type) public @Interface Herherited {}@Constraint: se usa para verificar si el valor del atributo es legal
@Documented@target ({elementtype.annotation_type})@retención (retenciónPolicy.runtime) public @interface restrict {class <? extiende restrictValidator <?,? >> [] validado por ();}@Retention: el ciclo de la anotación de la declaración se utiliza para definir la etapa de supervivencia de la anotación. Puede sobrevivir a nivel de código fuente, nivel de compilación (nivel de código de byte) y nivel de tiempo de ejecución.
Fuente: Nivel de código fuente, las anotaciones solo están presentes en el código fuente, y generalmente se usan para interactuar con el compilador y se utilizan para detectar el código. Como @Override, @SupessWarings.
Clase: Nivel de Bytecode, existen anotaciones en el código fuente y los archivos de Bytecode. Se utilizan principalmente para generar archivos adicionales durante la compilación, como XML, archivos Java, etc., pero no se pueden obtener durante el tiempo de ejecución. Por ejemplo, MyBatis genera archivos de entidad y mapeo. En este nivel, es necesario agregar un proxy (javaagent) cuando se carga JVM, y usar un proxy para modificar dinámicamente el archivo bytecode.
Tiempo de ejecución: nivel de tiempo de ejecución, anotaciones existen en el código fuente, el bytecode y las máquinas virtuales Java. Se usan principalmente para el tiempo de ejecución, y la reflexión se puede usar para obtener información relevante.
@Documentado@retención (retenciónPolicy.Runtime) @Target (elementType.annotation_type) public @Interface Retention { /*** Devuelve la política de retención. * @return la política de retención */ RetententPolicy Value ();} 3. Contenido de las anotaciones de Java
En el código fuente de anotación anterior, puede ver que algunas anotaciones no tienen contenido, y algunas anotaciones tienen contenido, lo que parece ser como un método.
Formato de sintaxis del Contenido anotado: Nombre del atributo de tipo de datos () Valor predeterminado predeterminado, el tipo de datos se usa para describir el tipo de datos del atributo. El valor predeterminado significa que cuando no se asigna ningún atributo, se usa el valor predeterminado. En general, String usa una cadena vacía "" como valor predeterminado, y las matrices generalmente usan una matriz vacía {} como el valor predeterminado.
Echemos un vistazo a la declaración de la anotación de solicitudes de solicitud en SpringMVC
@Target ({elementType.method, elementtype.type})@retención (retenciónPolicy.runtime)@documented@mappingpublic @interface requestMapping {String name () default ""; @Aliasfor ("ruta") cadena [] valor () predeterminado {}; @Aliasfor ("value") string [] path () predeterminado {}; RequestMethod [] método () predeterminado {}; String [] params () default {}; String [] encabezados () predeterminado {}; Cadena [] consumidores () predeterminado {}; String [] produce () predeterminado {};}Uso de la anotación de SolicMapping en SpringMVC
@RequestMapping (valor = "/list", método = requestmethod.post, produce = {"aplicación/json; charset = utf-8;"}) public String list () {} 4. Use escenarios de anotaciones
Puede analizar los escenarios de uso de las anotaciones a través del período de declaración de anotaciones:
Nivel de código fuente: para compiladores, como @Override, @depreced, etc., no hay muchos escenarios que los desarrolladores deben usar.
Clase: Nivel de código de byto, esta parte rara vez se ve
Tiempo de ejecución: nivel de tiempo de ejecución, este es el más común, y casi todas las anotaciones utilizadas por los desarrolladores son el nivel de tiempo de ejecución. Las anotaciones de tiempo de ejecución se usan comúnmente en las siguientes situaciones
Anotación sin ningún atributo en la anotación. Esta parte de la anotación generalmente juega un papel como anotación, como @test, @before, @after. Al obtener estas anotaciones de etiquetas, se realiza un procesamiento lógico.
Puede usar la anotación de restricción @Constraint para verificar el valor del atributo, como @email, @notnull, etc.
Puede configurar algunos parámetros utilizando propiedades en la anotación, y luego puede usar la reflexión para obtener estos parámetros. Estas anotaciones no tienen otras funciones especiales, simplemente configuran algunos parámetros en lugar de la configuración XML. Uso de anotaciones para configurar parámetros Esto es popular en el arranque de primavera, como @Configuration
Con respecto al método de configuración XML vs anotación, generalmente use XML para configurar algunas configuraciones que no están muy cerca de la relación comercial y use anotaciones para configurar algunos parámetros que están estrechamente relacionados con el negocio.
Tres: Java Annotation and Reflection API básico
// Obtener la anotación de cierto tipo público de tipo <a extiende la anotación> una getAnotation (clase <a> anotaciónclass); // Obtener todas las anotaciones (incluidas las anotaciones modificadas por heredadas en la clase principal) anotación pública [] getNotations (); // Obtenga las anotaciones declaradas (pero no incluye las anotaciones modificadas por heredadas en la clase principal) anotación pública [] getDeclaredAnnotations (); // prueba si un objeto es anotado por una anotación de anotación pública booleana isannotationPresent (class <? Extensa anotación> anotación -class) // get thip thip todos los campos declarados por una cierta clase de campo público [] SecurityException; // Obtenga un método determinado Método público getMethod (nombre de cadena, clase <?> ... Parametertypes);
Cuatro: anotaciones personalizadas
Use anotaciones personalizadas + interceptores o AOP para controlar los permisos.
El siguiente ejemplo se utiliza para definir una anotación para restringir la debe iniciar sesión del usuario al acceder a una interfaz.
Paso 1: Defina la anotación
RequiereLogin.java
@Documentado@target ({elementtype.method})@retención (retenciónPolicy.Runtime) public @Interface Requieslogin {}Paso 2: Use anotaciones
@Controlador @requestmapping ("/user") clase pública Usercontroller {@RequiresLogin @RequestMapping (valor = "/list", produce = {"aplicación/json; charset = utf-8;"}) cadena pública getUserList () {System.out.println ("--------------------------"); return "[{'id': 1, 'nombre de usuario': 'zhangsan'}]"; }}Paso 3: Use AOP para interceptar y analizar las anotaciones
Public Class LoginAdVices {public void antes (unión de unión de unión) lanza la excepción {object Target = unkenPoint.getTarget (); String MethodName = JoinPoint.GetSignature (). GetName (); System.out.println (Target + "-------" + MethodName); Método método = target.getClass (). GetMethod (MethodName); anotación booleana presente = método.isannotationPresent (requireLogin.class); if (annotationPresent) {// El usuario debe iniciar sesión boolean islogin = false; if (! islogin) {tire nueva excepción ("Debe iniciar sesión para acceder a esta interfaz"); } else {System.out.println ("Iniciar sesión ..."); }}}}Configurar AOP en ApplicationContext.xml
<bean id = "loginAdVices"/> <!-AOP Configuration-> <aop: config proxy-target-class = "true"> <!-section-> <aop: aspecto ref = "loginAdVices"> <!-punto-> <aop: puntos id = "puntos de puntos1" Expression = "Execution (*com.mengdee.manager.controller.*(...). Método de notificación y punto-> <aop: antes del método = "antes" PointCut-Ref = "PointCut1"/> </aop: aspecto> </aop: config>
Excepciones personalizadas
¿Por qué personalizar excepciones?
Aunque Java proporciona una rica variedad de clases de manejo de excepciones, a menudo se usan excepciones personalizadas en proyectos. La razón principal es que las clases de excepción proporcionadas por Java aún no pueden satisfacer las necesidades de varios negocios en algunos casos. Por ejemplo, algunos errores en el sistema cumplen con la sintaxis de Java, pero no cumplen con la lógica de negocios. Si la cuenta no existe cuando el usuario inicia sesión o la cuenta está bloqueada, puede personalizar una cuenta de excepción de la cuenta.
O en algunos casos, la misma excepción en Java puede ser causada por múltiples razones. No es fácil localizar errores al solucionar problemas. En este momento, puede usar una personalización de una excepción más clara.
Beneficios de las excepciones personalizadas: las excepciones personalizadas pueden hacer que las excepciones sean más claras y ocultar las excepciones subyacentes, que es más segura y más intuitiva.
Uso de excepciones personalizadas: las excepciones personalizadas generalmente se heredan de excepción o runtimeException. Según las necesidades comerciales, algunos atributos se pueden tomar como parámetros del constructor. Las excepciones personalizadas requieren que los programadores arrojen manualmente excepciones y manejen excepciones.
A continuación se muestra un ejemplo de excepciones personalizadas en Apache Shiro
public class ShiroException extiende RuntimeException {public shiroException () {} public shiroException (string Message) {super (mensaje); } public shiroException (causa de lanzamiento) {super (causa); } public shiroException (mensaje de cadena, causa de lanzamiento) {super (mensaje, causa); }}Lo anterior es una descripción detallada de la anotación de Java y las anotaciones personalizadas.