Peut annotation java complexes de retour de type HashMap

Peut annotation complexes de type de retour, tels que la table de hachage.

Je suis à la recherche de quelque chose comme:

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

afin que je puisse avoir une constante annoté comme(pseudo-code):

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

Si l'Annotation ne vous autorise pas à avoir de complexes de type de retour, puis les bonnes pratiques pour ce genre de cas?

excellente question..

InformationsquelleAutor Shengjie | 2012-11-26

61

Non, annotation des éléments ne peut être de type primitif, des Cordes, des enum types, Class, d'autres annotations, ou des tableaux de l'un de ces. Typique de la façon de représenter ces types de structure serait de déclarer un autre type d'annotation
```
public @interface TableMapping {
  public String dbName();
  public String tableName();
}
```
puis dire
```
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface column {
    public TableMapping[] table();
}
```
Et l'utilisation de l'annotation comme
```
@column(table={
  @TableMapping(dbName="dbName", tableName="tableName"),
  @TableMapping(dbName="db2", tableName="table2")
})
public String userId = "userid";
```
- N'oubliez pas les énumérations et les classes
- bon point, merci.
- J'ai fait quelque chose de similaire, c'est un peu gênant, si vous utilisez @ tableau, même certains de la colonne n'a qu'un seul TableMapping a @ table avec un @ TableMapping. Si vous commencez à l'aide de @ table pour les champs ayant plus d'un tablemapping tout en utilisant @ TableMapping pour les colonnes ayant un seul tablemapping. Mais dans ce dernier cas, on aura de plus en plus complexe méthode de récupération par exemple. getColumnsInTableA().
InformationsquelleAutor Ian Roberts

Un couple d'années plus tard, nous apporte de Java 8. Il offre un moyen de répéter les annotations de la même classe.

Dans Java 8, vous pouvez déclarer une annotation à être implicitement encapsulé dans un conteneur d'annotation. Vous déclarez comme @Repeated(value=a_class) une annotation que vous voulez être reproductibles. Lorsque vous ajoutez plusieurs instances d'un modèle d'annotation le compilateur va automatiquement enroulez-les dans le récipient d'annotation a_class spécifié comme argument pour @Repeated.

Si vous déclarez:

@Retention(RetentionPolicy.RUNTIME)
public @interface Columns {
    Column[] value() default {};
}

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

ensuite, vous pouvez utiliser l'annotation plusieurs fois avec ou sans les emballer dans une autre annotation, les deux sont équivalents:

@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";

Les annotations sont récupérées à l'aide de getAnnotationsByType(class) dans les deux cas.

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();
    }
}

Il devrait de sortie:

Field: USER_ID
    db: db1 table: table1
    db: db2 table: table2

Field: LAST_NAME
    db: db3 table: table3
    db: db4 table: table4

InformationsquelleAutor Florian F

Vous devez vous connecter pour publier un commentaire.