Annotations Java utiles

J’ai dissortingbué un tas de commentaires pour les autres utilisateurs, mais juste pour donner mes deux centimes, les seules trois annotations que j’utilise régulièrement sont les principales annotations utilisées directement par le compilateur:

@Override – Idéal pour le rendre explicite dans votre code lorsque vous surchargez une autre méthode. L’avantage supplémentaire est d’être signalé comme une erreur de compilation si vous ne remplacez pas une méthode comme vous le pensez (voir cette autre publication SO ). Ce drapeau informe le compilateur que vous avez l’intention de remplacer quelque chose, donc si vous ne le faites pas (par exemple, vous oubliez un argument dans la signature de la méthode), le compilateur le détectera.

@Deprecated – Indiquez ce que vous marquez comme quelque chose qui ne devrait pas être utilisé à partir de maintenant . Le compilateur générera des avertissements pour l’utilisation des éléments de code que vous avez marqués comme obsolètes. En général, la dépréciation dit “ceci était dans le passé, mais cela pourrait disparaître dans une future version”. Assurez-vous également que vous utilisez également l’indicateur Javadoc “@deprecated” associé pour indiquer aux utilisateurs ce qu’ils doivent utiliser à la place.

@SuppressWarnings – Indiquez au compilateur de supprimer les avertissements spécifiques qu’il générerait autrement. Cela peut être utile pour des choses comme lorsque vous voulez intentionnellement utiliser des méthodes obsolètes, vous pouvez bloquer l’avertissement de dépréciation. J’ai tendance à l’utiliser beaucoup pour bloquer l’avertissement de “Serialization UID” préféré de tout le monde sur les classes sérialisables (que vous deviez ou non faire cela est un autre débat pour une autre fois). Très utile pour les cas où vous savez que quelque chose que vous faites génère un avertissement, mais vous êtes sûr à 100% que c’est le comportement que vous souhaitez.

Consultez le Guide des annotations de Sun et consultez la section “Annotations utilisées par le compilateur”. Ces trois sujets sont longuement discutés.

Les annotations Java dans la pratique en pratique

Très utile pour décrire exactement comment votre code est ou non thread-safe …

Je trouve les annotations relatives à la concurrence définies par Brian Goetz dans son livre “Java Concurrency In Practice” très utiles:

• @Gardé par
• @Immutable
• @NotThreadSafe
• @ThreadSafe

Ils sont particulièrement utiles car FindBugs a des modèles qui les utilisent.

Un pot et de la documentation sont disponibles gratuitement sur http://www.javaconcurrencyinpractice.com/

@Override a mon vote. Cela vous permet de savoir instantanément quelle est votre méthode et de rendre votre code plus lisible.

@Test

( JUnit 4 ) L’écriture et la compréhension des fichiers de test sont un peu plus propres. De plus, la possibilité d’append l’atsortingbut expected a permis de sauver quelques lignes de code ici et là.

@Deprecated

Introduit en Java 5 .

• Il aide les développeurs à voir ce qui est obsolète dans les IDE. (Avant cela, la plupart des IDE pouvaient toujours extraire un @deprecated des commentaires javadoc pour une méthode particulière, mais cette annotation était un bon moyen de rendre les méta-informations sur la méthode elle-même, plutôt qu’un commentaire dans la documentation.)
• Il est également utilisé par le compilateur pour imprimer des avertissements lorsque vous utilisez des méthodes obsolètes.

Personnellement, j’ai examiné la validation des beans JSR303 et les annotations qu’elle fournit, j’imagine que celles-ci deviendront plus courantes, il n’y a que quelques implémentations du JSR jusqu’à présent, mais elles fournissent des annotations telles que:

 @NotNull private Ssortingng name; @NotNull @Size(min = 5, max = 30) private Ssortingng address; 

Plus d’informations ici: http://jcp.org/en/jsr/detail?id=303

ceux-ci devraient être utiles, vous pouvez les définir dans vos projets pour mieux communiquer les intentions:

• @ThreadSafe
• @Immutable
• @ValueObject
• @BagOfFunctions (par exemple, java.util.Collections)
• etc

Junit 4 fournit des annotations très utiles. Voici un tutoriel illustrant l’utilisation des annotations pour définir des tests.

par exemple

 @Test(expected= IndexOutOfBoundsException.class) public void empty() { new ArrayList 

Comme Dan l’a souligné ci-dessous, TestNG l’a fait à l’origine.

Voici quelques annotations que j’utilise dans le développement quotidien

Printemps:

1. @Autowired – utilisé pour haricots automatiques
2. @Rollback – Si défini sur true, toutes les opérations de firebase database effectuées dans le scénario de test seront annulées .

JUnit:

1. @Test – Dites qu’une méthode est un cas de test
2. @Ignore – Si vous voulez ignorer l’un des cas de test
3. @Before – Code devant être exécuté avant chaque test élémentaire

JPA:

1. @Entity – Pour dire qu’un POJO est une entité JPA
2. @ Column – Mappe la propriété à la colonne DB
3. @Id – indique qu’une propriété Java est la clé primaire
4. @EmbeddedId – Utilisé pour les clés primaires composites
5. @Transient – Cette propriété ne doit pas être persistée
6. @Version – Utilisé pour gérer le locking optimiste
7. @NamedQuery – Utilisé pour déclarer des SQL natifs
8. @OneToMany – Relation un à plusieurs
9. @ManyToOne – Plusieurs à une relation

Je n’ai inclus que les plus importants. Vous trouverez des informations sur toutes les annotations JPA à partir des liens suivants.

http://www.oracle.com/technology/products/ias/toplink/jpa/resources/toplink-jpa-annotations.html

http://www.hiberbook.com/

@Given

permet à un test JUnit de s’appuyer sur la valeur de retour d’un autre test. Nécessite JExample .

Nous avons commencé à utiliser un outil de compilation appelé lombok ( http://projectlombok.org/ ). Vous annotez des classes, des membres, etc. et les méthodes sont générées automatiquement au moment de la compilation. Il augmente considérablement la productivité et permet d’économiser des centaines de lignes de codage fastidieux.

Voulez-vous qu’une toSsortingng() soit générée automatiquement? @ToSsortingng simplement votre classe avec @ToSsortingng .

Fatigué de devoir définir des getters et des setters pour vos membres? @Getter votre classe avec @Getter et / ou @Setter et ils @Setter automatiquement ajoutés.

Vous voulez avoir un enregistreur SLF4J pour enregistrer des choses? @Slf4j crée un enregistreur final statique privé pour vous.

 @Data public class MyBean { // Getters for x and y, setter for y and constructor with x as arg automatically created! // toSsortingng() 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."); } } 

La configuration est très simple: ajoutez simplement une dépendance Maven provided . Il y a aussi un petit plugin Eclipse / IntelliJ.

Consultez la liste complète des fonctionnalités: http://projectlombok.org/features/index.html

J’ai démarré un projet de week-end pour mettre en place un cadre de programmation par contrat en utilisant des annotations de méthode et de paramètre

… myMethod (@NotNull Ssortingng a, @NotNullOrEmpty Ssortingng b) {

  if ( !validate() ){ raiseException .. } 

}

Je me suis coincé au point d’obtenir des valeurs de parameters automatiquement. La reflection Java ne l’a pas. Je n’ai jamais compris les discours de plusieurs personnes sur Java avant que je tombe sur cette limitation.

 @FunctionalInterface 

Utile pour communiquer qu’une interface particulière est censée être fonctionnelle. Si la méthode abstraite unique est supprimée, elle génère une erreur de compilation.