¿Hay alguna forma de utilizar anotaciones en Java para reemplazar los usuarios?

Question

soy un poco nuevo en las anotaciones de Java 5 y estoy ansioso por ver si cualquiera de éstos son posibles:

Esta anotación generaría un captador simple y setter para usted.

@attribute 
private String var = ""; 

El @NotNull anotación indica que una variable de connot ser nula por lo que no tiene que escribir código repetitivo que cada vez.

/* 
* @param s @NotNull 
*/ 
public void setString(String s){ 
    ... 
} 

¿Alguno de estos trabajos? Parecen las primeras cosas por las que escribiría anotaciones si pudiera. Como no veo mucho sobre esto cuando leo los documentos, asumo que no se trata realmente de las anotaciones. Cualquier dirección aquí sería apreciada.

Answer 1

procesamiento de anotación se produce en el árbol de sintaxis abstracta. Esta es una estructura que el analizador crea y el compilador manipula.

La especificación actual (enlace a venir) dice que los procesadores de anotación no pueden alterar el árbol de sintaxis abstracta. Una de las consecuencias de esto es que no es adecuado para generar código.

Si desea este tipo de funcionalidad, eche un vistazo a XDoclet. Esto debería darle el preprocesamiento de generación de código que creo que está buscando.

Para su ejemplo @NonNull, JSR-305 es una set of annotations para mejorar la detección de defectos de software, e incluye @NonNull y @CheckForNull y una multitud de otros.

Editar: Project Lombok resuelve exactamente el problema de la generación getter y setter.

Answer 2

¿Hay alguna manera de utilizar las anotaciones en Java para reemplazar los programas de acceso?

En resumen, no, el compilador Java 5/6 no es compatible con esto y sería difícil para terceros agregar dicho soporte de forma independiente del compilador.

Para obtener un mejor manejo de las anotaciones, comenzaría con JUnit. Si escribe código para las versiones 3 (pre-anotaciones) y 4 (basadas en anotaciones), rápidamente obtiene una idea de cómo el marco reemplazó un contrato basado en patrones de nombres con uno basado en anotaciones.

Para un ejemplo más dramático, comparar EJB 2 con EJB 3.

Answer 3

El @attribute al que se refiere tampoco puede trabajar con anotaciones, ya que ahora están en Java (como señaló jamesh).

Lo que probablemente esté buscando es "properties" que aún no existe en Java. Pero es un tema muy candente en este momento, y podríamos obtenerlo en Java 7 o tal vez en Java 8 (ya que todavía estoy atascado en 1.4.2 no me ayudará, pero podría ayudarte).

Hubo una discusión interesante alusión a la implementación de propiedades con anotaciones en el Java Posse episode #219.

Answer 4

Hay un proyecto llamado OVal y creo que hace lo que quiere. http://oval.sourceforge.net/

Si recuerdo bien para el aspecto de adelanto AspectJ es necesario, sin embargo el trabajo de verificación simple sin AspectJ. Echale un vistazo.

También hay Hibernate Validator, comprobar que funciona demasiado: P

Answer 5

Es posible, pero no donde se les está declarando.

Echa un vistazo http://code.google.com/p/javadude/wiki/Annotations.

tengo una clase anotada como

package sample; 
import com.javadude.annotation.Bean; 
import com.javadude.annotation.Property; 
import com.javadude.annotation.PropertyKind; 

@Bean(properties={ 
    @Property(name="name"), 
    @Property(name="phone", bound=true), 
    @Property(name="friend", type=Person.class, kind=PropertyKind.LIST) 
}) 
public class Person extends PersonGen {} 

Y genera la clase PersonGen para usted, que contiene getters/setters, etc

El procesador también hace un poco más. Tenga en cuenta que estoy trabajando en una nueva versión que tiene una pequeña rotura API de la versión actual

Answer 6

Getters/Setters: Sí, es posible. El Project Lombok (http://projectlombok.org/index.html) define anotaciones para generar getters/setters y más.

Así, por ejemplo

@lombok.Data; 
public class Person { 
    private final String name; 
    private int age; 
} 

generará captador para el nombre (no Setter ya que es final) y captador/definidor de edad. También generará equals, hashCode, toString y construtor inicializando los campos obligatorios (nombre). Agregar @AllArgsConstructor generaría el constructor inicializando ambos campos.

Existen otras anotaciones y parámetros que le otorgan control sobre los derechos de acceso (si su getter está protegido o es público), nombres (getName o name?), Etc. Y hay más. Por ejemplo, realmente me gustan los métodos de extensión.

Lombok es muy fácil de usar. Simplemente descargue el jar y use las anotaciones, luego los getter/setters se pueden usar en su código sin que realmente se deletreen. Además, IDE's como Netbeans lo soportan, para que veas getter/setter en la finalización del código, navegación, etc. Las anotaciones se usan solo durante la compilación, no durante el tiempo de ejecución, por lo que no distribuyes lombok con tus jar's.

NotNull: Esto es apoyado por findbugs y IdeaJ IDE, tal vez otros

Answer 7

A pesar de que a veces son útiles, si está seriamente perdiendo atributos entonces usted es probablemente un poco inestable sobre todo el asunto de diseño orientado a objetos.

La idea de OO Design es que los métodos son "Acciones" en las que le pide al objeto que haga algo por usted, no solo establecer u obtener un valor, eso no es un objeto, es una estructura.

Si cree que la falta de atributos es un problema grave, le recomiendo que intente codificar por un tiempo sin usar setters y getters resistentes.

Puede ser difícil al principio, pero apuesto a que al final tendrá una comprensión más firme de los principios de diseño de OO.

(Nota: hay situaciones poco comunes en las que debe realizar operaciones tipo "setter" después de la construcción de un objeto, más comúnmente cuando debe crear dos objetos que se refieren entre sí. En este caso, recomiendo algo como patrón de constructor donde se debe llamar a los instaladores una vez y están protegidos de ser llamados dos veces)