Para aprender las anotaciones en profundidad, debemos poder definir nuestras propias anotaciones y usarlas. Antes de definir nuestras propias anotaciones, debemos comprender la sintaxis de las metaanotaciones y las anotaciones de definición relacionadas proporcionadas por Java.
-------------------------------------------------- ----------------------------------
Metaanotación:
La función de las metaanotaciones es anotar otras anotaciones. Java 5.0 define cuatro tipos de metanotaciones estándar, que se utilizan para proporcionar descripciones de otros tipos de anotaciones. Metaanotaciones definidas por Java5.0:
1.@objetivo,
2.@Retención,
3.@Documentado,
4.@Heredado
Estos tipos y las clases que admiten se encuentran en el paquete java.lang.annotation. Echemos un vistazo a la función de cada metaanotación y las instrucciones para usar los subparámetros correspondientes.
-------------------------------------------------- ----------------------------------
@Objetivo:
@Target explica el alcance de los objetos modificados por anotación: la anotación se puede usar para paquetes, tipos (clases, interfaces, enumeraciones, tipos de anotación), miembros de tipo (métodos, constructores, variables miembro, valores de enumeración), parámetros de método y variables locales ( como variables de bucle, parámetros de captura). El uso del objetivo en la declaración del tipo de anotación puede aclarar el objetivo modificado.
Función: se utiliza para describir el alcance de uso de las anotaciones (es decir, dónde se pueden utilizar las anotaciones descritas)
Los valores (ElementType) son:
1.CONSTRUCTOR: usado para describir el constructor 2.FIELD: usado para describir el dominio 3.LOCAL_VARIABLE: usado para describir variables locales 4.METHOD: usado para describir el método 5.PACKAGE: usado para describir el paquete 6.PARAMETER: usado para describir los parámetros 7.TYPE: se utiliza para describir clases, interfaces (incluidos los tipos de anotaciones) o declaraciones de enumeración
Ejemplos de uso:
@Destino(TipoElemento.CAMPO)
pública @interfaz NoDBColumn {
}
-------------------------------------------------- ----------------------------------
@Retención:
@Retention define el período de tiempo que se retiene la anotación: algunas anotaciones solo aparecen en el código fuente y el compilador las descarta, mientras que otras se compilan en el archivo de clase. Las anotaciones compiladas en el archivo de clase pueden virtualizarse y la máquina las ignora; mientras que otros se leerán cuando se cargue la clase (tenga en cuenta que no afecta la ejecución de la clase, porque la anotación y la clase se usan por separado). Utilice esta metaanotación para limitar el "ciclo de vida" de la anotación.
Función: indica en qué nivel se debe guardar la información de la anotación y se utiliza para describir el ciclo de vida de la anotación (es decir, dentro de qué alcance es válida la anotación descrita).
Los valores (RetentionPoicy) son:
1.FUENTE: Válido en el archivo fuente (es decir, se conserva el archivo fuente)
2.CLASS: Válido en archivos de clase (es decir, clase reservada)
3.RUNTIME: válido en tiempo de ejecución (es decir, retenido en tiempo de ejecución)
El tipo de metaanotación de retención tiene un valor único como miembro y su valor proviene del valor del tipo de enumeración de java.lang.annotation.RetentionPolicy. Los ejemplos específicos son los siguientes:
-------------------------------------------------- ----------------------------------
@Documentado:
@Documented se usa para describir otros tipos de anotaciones que deben usarse como API pública de los miembros del programa anotado y, por lo tanto, pueden documentarse mediante herramientas como javadoc. Documentado es una anotación de marcado y no tiene miembros.
La metaanotación @Inherited es una anotación de marcado que @Inherited indica que se hereda un determinado tipo anotado. Si se usa un tipo de anotación modificado con @Inherited para una clase, esta anotación se usará para las subclases de esa clase.
Nota: Los tipos de anotación @Inherited los heredan las subclases de la clase anotada. Una clase no hereda anotaciones de la interfaz que implementa y un método no hereda anotaciones del método que sobrecarga.
Cuando la retención de la anotación anotada con el tipo de anotación @Inherited es RetentionPolicy.RUNTIME, la API de reflexión mejora esta herencia. Si usamos java.lang.reflect para consultar la anotación de un tipo de anotación @Inherited, la inspección del código reflexivo comenzará a funcionar: verificando la clase y su clase principal hasta que se encuentre el tipo de anotación especificado, o el nivel superior de la estructura de herencia de clases. se alcanza.
Código de ejemplo:
-------------------------------------------------- ----------------------------------
Anotación personalizada:
Cuando se utiliza @interface para personalizar anotaciones, la interfaz java.lang.annotation.Annotation se hereda automáticamente y el compilador completa automáticamente otros detalles. Al definir anotaciones, no puede heredar otras anotaciones o interfaces. @interface se usa para declarar una anotación y cada método en realidad declara un parámetro de configuración. El nombre del método es el nombre del parámetro y el tipo de valor de retorno es el tipo de parámetro (el tipo de valor de retorno solo puede ser tipos básicos, Clase, Cadena o enumeración). Puede declarar el valor predeterminado de un parámetro de forma predeterminada.
Definir formato de anotación:
nombre de anotación pública @interface {cuerpo de definición}
Tipos de datos admitidos de parámetros de anotación:
1. Todos los tipos de datos básicos (int, float, boolean, byte, double, char, long, short)
2. Tipo de cadena 3. Tipo de clase 4. Tipo de enumeración 5. Tipo de anotación 6. Matrices de todos los tipos anteriores
Cómo configurar los parámetros en el tipo de anotación:
Primero, solo se puede modificar con los dos derechos de acceso público o predeterminado. Por ejemplo, String value() aquí el método se establece en el tipo predeterminado;
En segundo lugar, los miembros de parámetros solo pueden usar los ocho tipos de datos básicos de byte, short, char, int, long, float, double, boolean y tipos de datos como String, Enum, Class, anotaciones y matrices de estos tipos. Valor de cadena (); El miembro del parámetro aquí es Cadena;
En tercer lugar, si solo hay un miembro de parámetro, es mejor establecer el nombre del parámetro en "valor" seguido de paréntesis. Ejemplo: la anotación FruitName en el siguiente ejemplo tiene solo un miembro de parámetro.
Anotaciones personalizadas simples y ejemplos de uso de anotaciones:
importar java.lang.annotation.Documented;
importar java.lang.annotation.ElementType;
importar java.lang.annotation.Retention;
importar java.lang.annotation.RetentionPolicy;
importar java.lang.annotation.Target;
/**
* Notas sobre nombres de frutas.
*@autor peida
*
*/
@Destino(TipoElemento.CAMPO)
@Retención(RetentionPolicy.RUNTIME)
@Documentado
public @interface NombreFruta {
Valor de cadena() predeterminado "";
}
importar java.lang.annotation.Documented;
importar java.lang.annotation.ElementType;
importar java.lang.annotation.Retention;
importar java.lang.annotation.RetentionPolicy;
importar java.lang.annotation.Target;
/**
* Anotación de color de fruta
*@autor peida
*
*/
@Destino(TipoElemento.CAMPO)
@Retención(RetentionPolicy.RUNTIME)
@Documentado
público @interfaz ColorFruta {
/**
* Enumeración de colores
*@autor peida
*
*/
Color de enumeración pública {BULE,RED,GREEN};
/**
* Atributos de color
* @devolver
*/
Color fruitColor() predeterminado Color.GREEN;
}
importar anotación.FruitColor.Color;
clase pública Apple {
@NombreFruta("Manzana")
cadena privada nombre de manzana;
@FruitColor(frutaColor=Color.ROJO)
cadena privada appleColor;
public void setAppleColor(String appleColor) {
this.appleColor = manzanaColor;
}
Cadena pública getAppleColor() {
devolver colormanzana;
}
setAppleName público vacío (String nombreApple) {
this.appleName = appleName;
}
cadena pública getAppleName() {
devolver nombre de manzana;
}
nombre de visualización vacío público(){
System.out.println("El nombre de la fruta es: Manzana");
}
}