java - reflexion - para que sirven las anotaciones
Anotaciones de Java útiles (14)
Me interesa saber exactamente qué anotaciones de Java piensan las personas que son más útiles durante el desarrollo. Esto no necesariamente tiene que limitarse a la API de Java central, puede incluir anotaciones que haya encontrado en bibliotecas de terceros o anotaciones que haya desarrollado usted mismo (asegúrese de incluir un enlace a la fuente).
Estoy realmente interesado en las tareas de desarrollo comunes en lugar de saber por qué el @ManyToOne(optional=false) en JPA es increíble ...
Incluya la anotación y una descripción de por qué es útil para el desarrollo general.
@Override tiene mi voto. De este modo, se aclara instantáneamente de qué se trata su método y hace que su código sea más legible.
Aquí hay algunas anotaciones que utilizo en el desarrollo del día a día.
Primavera:
- @Autowired - usado para Auto Wire Beans
- @Rollback : si se establece en true, se revertirán todas las operaciones de DB realizadas dentro del caso de prueba
JUIT
- Prueba @ : diga que un método es un caso de prueba
- @Ignore - Si desea ignorar alguno de los casos de prueba
- @Anterior : código que debe ejecutarse antes de cada caso de prueba
JPA:
- @Entity : para indicar que un POJO es una entidad JPA
- @Column - Asignar la propiedad a la columna DB
- @Id - dice que una propiedad java es clave principal
- @EmbeddedId : se utiliza para claves primarias compuestas
- @Transient - Esta propiedad no debe ser persistente
- @Version - Se utiliza para gestionar el bloqueo optimista
- @NamedQuery : se utiliza para declarar SQL nativos
- @OneToMany - Relación uno a muchos
- @ManyToOne - Relación de muchos a uno
He incluido solo los más esenciales. Puede encontrar detalles sobre todas las anotaciones de JPA en los siguientes enlaces.
http://www.oracle.com/technology/products/ias/toplink/jpa/resources/toplink-jpa-annotations.html
Comencé un proyecto de fin de semana para implementar un marco de programación por contrato utilizando anotaciones de parámetros y parámetros, por ejemplo
... myMethod (@NotNull String a, @NotNullOrEmpty String b) {
if ( !validate() ){
raiseException ..
}
}
Me quedé atascado en el punto de obtener valores param automáticamente. La reflexión de Java no lo tiene. Nunca entendí las opiniones de varias personas sobre Java hasta que encontré esta limitación.
Comenzamos a usar una herramienta de compilación llamada lombok ( http://projectlombok.org/ ). Anota clases, miembros, etc. y los métodos se generan automáticamente en tiempo de compilación. Es un gran aumento de la productividad y ahorra cientos de líneas de codificación tediosa.
¿Quieres que un método toString() sea generado automáticamente? Simplemente anota tu clase con @ToString .
¿Cansado de tener que definir getters y setters para sus miembros? @Getter tu clase con @Getter y / o @Setter y se agregan automáticamente.
¿Quieres tener un registrador SLF4J para registrar cosas? @Slf4j crea un registrador final estático privado para ti.
@Data
public class MyBean {
// Getters for x and y, setter for y and constructor with x as arg automatically created!
// toString() and hashCode() methods are there too!
private final int x;
private int y;
}
.
@Slf4j
public class SomeClass {
public void doSomething() {
log.info("I''ve got log.");
}
}
Configurarlo es muy fácil: solo agregue una dependencia de maven provided . También hay un pequeño plugin Eclipse / IntelliJ.
Echa un vistazo a la lista completa de características allí: http://projectlombok.org/features/index.html
Considero que las anotaciones relacionadas con la concurrencia de él definidas por Brian Goetz en su libro "Java Concurrency In Practice" son muy útiles:
- @Vigilado por
- @Inmutable
- @NotThreadSafe
- @A salvo de amenazas
Son particularmente útiles ya que FindBugs tiene patrones que los usan.
Un frasco y documentación están disponibles gratuitamente en http://www.javaconcurrencyinpractice.com/
Distribuí un montón de upvotes para otros usuarios, pero solo para dar a mis dos centavos las únicas tres anotaciones que uso con cierta regularidad en el desarrollo son las principales anotaciones utilizadas directamente por el compilador:
@Override : excelente para hacerlo explícito en su código cuando está anulando otro método. También tiene el beneficio adicional de estar marcado como un error de compilación si no invalida un método de la forma en que cree que está (consulte esta otra publicación SO ). Este indicador le informa al compilador que tiene la intención de anular algo, por lo que si no lo hace (por ejemplo, si olvida un argumento en la firma del método), el compilador lo detectará.
@Deprecated : indique lo que está marcando como algo que no debe usarse desde este punto en adelante. El compilador generará advertencias para el uso de cualquier elemento de código que haya marcado como obsoleto. En general, la desaprobación dice que "esto estuvo aquí en el pasado, pero puede desaparecer en una versión futura". Asegúrate de que también usas el indicador Javadoc asociado "@deprecated" junto con esto también para decirle a la gente qué deben usar en su lugar.
@SuppressWarnings - Indica al compilador que suprima las advertencias específicas que de otro modo generaría. Esto puede ser útil para cosas como cuando intencionalmente desea utilizar métodos en desuso, puede bloquear la advertencia de desaprobación. Tiendo a usarlo mucho para bloquear la advertencia de "Serialization UID" favorita de todos en las clases serializables (ya sea que debas hacerlo o no es otro debate para otro momento). Simplemente útil para aquellos casos en los que sabe que algo que está haciendo genera una advertencia, pero está 100% seguro de que es el comportamiento adecuado que desea.
Consulte la Guía de anotaciones de Sun y consulte la sección "Anotaciones utilizadas por el compilador". A estos tres se les da una discusión bastante larga.
Estos deberían ser útiles, puede definirlos en sus proyectos para comunicar mejor sus intenciones:
- @A salvo de amenazas
- @Inmutable
- @ValueObject
- @BagOfFunctions (por ejemplo, java.util.Collections)
- etc
Las anotaciones de concurrencia de Java en la práctica.
Muy útil para describir exactamente cómo su código es o no es seguro para subprocesos ...
Personalmente, he estado viendo la validación de frijoles JSR303 y las anotaciones que proporciona, me imagino que se volverán más comunes, hasta ahora solo hay algunas implementaciones de JSR, pero ofrecen anotaciones como:
@NotNull private String name;
@NotNull @Size(min = 5, max = 30) private String address;
Más información aquí: http://jcp.org/en/jsr/detail?id=303
Junit 4 proporciona anotaciones muy útiles. Aquí hay un tutorial que ilustra el uso de anotaciones para definir pruebas.
p.ej
@Test(expected= IndexOutOfBoundsException.class) public void empty() {
new ArrayList<Object>().get(0);
}
Como Dan señaló a continuación, TestNG hizo esto originalmente.
@Deprecated
- Ayuda a los desarrolladores a ver lo que está en desuso en los IDE. (Antes de esto, la mayoría de los IDE aún podían extraer un
@deprecatedde los comentarios de javadoc para un método en particular, pero esta anotación era una buena forma de convertirla en metainformación sobre el método en lugar de un comentario en la documentación) - El compilador también lo utiliza para imprimir advertencias cuando está usando métodos en desuso.
@Given
permite que una prueba JUnit se base en el valor de retorno de otra prueba. Requiere JExample .
@Test
( JUnit 4 ) Está hecho para escribir y entender los archivos de prueba un poco más limpios. Además, la capacidad de agregar el atributo expected ha guardado algunas líneas de código aquí y allá.
@FunctionalInterface
Útil para comunicar que una interfaz particular está destinada a ser funcional. Si se elimina el método abstracto único, arrojará un error de compilación.