Puede anotación de complejos de tipo de retorno, tales como HashMap.

Estoy buscando algo como:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface column {
    public HashMap<String, String> table();
}

para que yo pueda tener una constante anotado como(pseudo código):

@column({table=(dbName, tableName), table=(dbName, tableName2)})
public static final String USER_ID = "userid";

Si la Anotación no permite tener complejos de tipo de retorno, entonces cualquier buena práctica para este tipo de casos?

  • excelente pregunta..
InformationsquelleAutor Shengjie | 2012-11-26

2 Comentarios

  1. 61

    No, anotación elementos sólo pueden ser tipos primitivos, Cadenas, enum tipos, Class, otras anotaciones, o matrices de cualquiera de estos. La típica forma de representar este tipo de estructuras sería declarar otro tipo de anotación

    public @interface TableMapping {
      public String dbName();
      public String tableName();
    }

    luego dicen que

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.FIELD)
    public @interface column {
        public TableMapping[] table();
    }

    Y el uso de la anotación como

    @column(table={
      @TableMapping(dbName="dbName", tableName="tableName"),
      @TableMapping(dbName="db2", tableName="table2")
    })
    public String userId = "userid";
    • No te olvides de las enumeraciones y las clases
    • buen punto, gracias.
    • Yo he hecho algo similar, es un poco molesto, si usamos @ mesa, solo, incluso algunos de la columna sólo tiene una TableMapping tiene que tener @ mesa junto con un @ TableMapping. Si usted comienza a utilizar @ tabla de campos a tener más de un tablemapping mientras que el uso de @ TableMapping para las columnas que tienen sólo uno tablemapping. Pero en este último caso más complejo método para recuperar, por ejemplo. getColumnsInTableA().
  2. 9

    Un par de años más tarde nos trae Java 8. Ofrece una forma de repetir las anotaciones de la misma clase.

    En Java 8 se puede declarar una anotación implícitamente envuelto en un contenedor de anotación. Se declara como @Repeated(value=a_class) una anotación que desea ser repetible. Al agregar varias instancias de un repetible anotación el compilador se ajustarán automáticamente estas en el contenedor de anotación a_class especificado como argumento para @Repeated.

    Si declara:

    @Retention(RetentionPolicy.RUNTIME)
    public @interface Columns {
        Column[] value() default {};
    }
    
    @Retention(RetentionPolicy.RUNTIME)
    @Repeatable( value = Columns.class )
    public @interface Column {
        String dbName();
        String tableName();
    }

    a continuación, puede utilizar la anotación varias veces con o sin embalaje de ellas en otra anotación, ambos son equivalentes:

    @Column(dbName="db1", tableName="table1")
    @Column(dbName="db2", tableName="table2")
    public static final String USER_ID = "userid";
    
    @Columns({
            @Column(dbName="db3", tableName="table3"),
            @Column(dbName="db4", tableName="table4")
    })
    public static final String LAST_NAME = "last name";

    Las anotaciones se recuperan mediante getAnnotationsByType(class) en ambos casos.

    public static void main(String[] args) {
        for( Field field : AnnotationsTest.class.getDeclaredFields() ){
            System.out.println("Field: " + field.getName());
            Column[] columns = field.getAnnotationsByType(Column.class);
            for( Column column : columns ){
                System.out.println("    db: " + column.dbName() + " table: " + column.tableName());
            }
            System.out.println();
        }
    }

    Debe de salida:

    Field: USER_ID
        db: db1 table: table1
        db: db2 table: table2
    
    Field: LAST_NAME
        db: db3 table: table3
        db: db4 table: table4

Dejar respuesta

Please enter your comment!
Please enter your name here