Kotlin annotation Statement and use

Préface

L'appel à une fonction doit connaître la classe dans laquelle la fonction est située,Nombre d'arguments entrants et type d'argument de la fonction,Les annotations et les réflexions peuvent sauter cette limite,Les annotations et les réflexions peuvent écrire n'importe quel Code de classe inconnu à l'avance.Les annotations peuvent donner une sémantique spécifique à la Bibliothèque de classe,La réflexion peut analyser la structure de la classe au moment de l'exécution.

Déclaration et utilisation des annotations

Les notes vous permettent d'ajouterMétadonnéesAssocié à une déclaration,Les métadonnées sont ensuite extraites au moment de l'exécution par réflexion et utilisées.

Pour appliquer une annotation,ParLes caractè[email protected] préfixe de nom,Avant l'annotation.

@Test
fun add(){
    

}

Vous pouvez fournir des arguments pour les annotations

    @Deprecated("removeAt(index) instead.",ReplaceWith("removeAt(index)"))
    fun remove(index:Int){
    
        
    }
    //RelaceWith C'est aussi une note.
	@Target()
	@Retention(BINARY)
	@MustBeDocumented
	public annotation class ReplaceWith(val expression: String, vararg val imports: String)

Attention!：
Le type d'argument d'une annotation peut être le type de base、String、Enumeration、Référence de classe、Autres classes d'annotation、Tableau, etc.,InjavaClasse d'annotation déclarée dans,Nommévalue Un paramètre de forme qui est automatiquement converti en un paramètre de longueur variable à la demande ,Donc ça peut être fait sansarrayOf La fonction peut fournir plusieurs arguments .

Description	Expression
Spécifiez une classe comme argument d'annotation	@CustomAnnotation（MineClass::class）
Une autre annotation est spécifiée comme argument	Supprimer les annotations @,Par exemple：ReplaceWith Comme argument d'annotation ,Non ajouté@Préfixe
Spécifier un tableau comme argument	@RequestMapping（path=arrayof(“/foo”,“/bar”)）

Les arguments annotés nécessitent un délai de compilation déterminé , Donc les propriétés qui sont des arguments d'annotation doivent être utilisées constModification, Déclaration au niveau supérieur du fichier ou objectAu milieu..

Objectifs d'annotation

Il est nécessaire de noter les éléments qui nécessitent des commentaires ,Parce quekotlin Une seule déclaration dans le code source correspond à plusieurs java Élément de déclaration .

{
    
var shengming=1
}
Correspondant àjava
 Une propriété déclarée 、Ungetter,Unsetter, Ces codes de modèle sont générés automatiquement au moment de la compilation 

Déclaration de destination du point d'utilisation Utilisé pour illustrer les éléments à annoter ,Etjava Il suffit d'ajouter un champ ou une fonction @RuleL'annotation fera.

@get:Rule

1. @get： Utiliser des cibles ponctuelles
2. Rule：Nom de l'annotation

class foler{
    
@get:Rule
val folder=TemporaryFolder()
@Test
fun testDemo(){
    
...
}

Kotlin Support complet Point d'utilisation Liste complète des cibles

Utiliser des cibles ponctuelles	Introduction
property	java Ne peut pas être appliqué sous annotation pour
field	Champ
get	Propriétésgetter
set	Propriétéssetter
receiver	Propriétés des paramètres du récepteur
param	Propriétés de la méthode de construction
setparam	PropriétéssetterParamètres pour
delegate	Les propriétés du délégué stockent les champs de l'instance du délégué
file	Classe des fonctions et attributs de haut niveau déclarés dans le fichier

kotlin Permet l'annotation de n'importe quelle expression

Tips: Les notes peuvent être utilisées pour contrôler javaApiGénération de

Notes	Explication
@volatile	Agir commejavaMots clésvolatile
@strictfp	Agir commejavaMots clésstrictfp
@JvmName	Changement par kotlinProduitjava Nom de la méthode ou du champ
@JvmStatic	Sur la façon de déclarer ou d'accompagner un objet ,Exposé àjava staticMéthode statique
@JvmOverloads	Générer plusieurs surcharges pour les paramètres par défaut
@JvmField	Appliquer aux propriétés, Exposé sans accesseur public Champ

Note de déclaration

// Commentaires sans paramètres 
annotation class MineAnnotation
// Commentaires avec paramètres 
annotation class MineAnnotation（val name:String）

La classe annotée n'a pas de corps de classe , Le compilateur interdit également .Notes Structure des métadonnées utilisées pour associer les déclarations et les expressions ,Injava La même structure est déclarée dans

public @interface MineAnnotation{
    
String value()
}

javaMoyennevalueInkotlinEtjava Tous seront traités avec un traitement spécial . Quand vous appliquez une annotation , À fournir en plus de value Afficher le nom de toutes les propriétés spécifiées à l'exception de .Etkotli’nCe n'est pas nécessaire. Utilisé comme un constructeur normal .Sijava Les annotations déclarées dans s'appliquent à kotlinMoyenne, Doit être divisé par value Tous les arguments sauf Méthode des arguments nommés

//Target.java

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    
    /** * Returns an array of the kinds of elements an annotation type * can be applied to. * @return an array of the kinds of elements an annotation type * can be applied to */
    ElementType[] value();
}

Méta - Annotation： Contrôle comment traiter une annotation

Méta - Annotation： Les annotations qui peuvent être appliquées à une classe d'annotation sont appelées métaannotations

@Target（AnnotationTarget.PROPERTY）
annotation class JsonExclude

@Target Les méta - annotations décrivent les types d'éléments auxquels une annotation peut être appliquée ,AnnotationTarget La valeur Enum énumère toutes les cibles possibles pour lesquelles une annotation peut être appliquée , Plusieurs déclarations peuvent également être faites en même temps si nécessaire. AnnotationTargetObjectifs

public enum class AnnotationTarget {
    
    /** Class, interface or object, annotation class is also included */
    CLASS,
    /** Annotation class only */
    ANNOTATION_CLASS,
    /** Generic type parameter (unsupported yet) */
    TYPE_PARAMETER,
    /** Property */
    PROPERTY,
    /** Field, including property's backing field */
    FIELD,
    /** Local variable */
    LOCAL_VARIABLE,
    /** Value parameter of a function or a constructor */
    VALUE_PARAMETER,
    /** Constructor only (primary or secondary) */
    CONSTRUCTOR,
    /** Function (constructors are not included) */
    FUNCTION,
    /** Property getter only */
    PROPERTY_GETTER,
    /** Property setter only */
    PROPERTY_SETTER,
    /** Type usage */
    TYPE,
    /** Any expression */
    EXPRESSION,
    /** File */
    FILE,
    /** Type alias */
    @SinceKotlin("1.1")
    TYPEALIAS
}

Comment définir vos propres méta - annotations ：ANNOTATION_CLASS

@Target（AnnotationTarget.ANNOTATION_CLASS）
annotation class myAnnotation

Utiliser
@myAnnotation
annotation class MYBinding

Attention!： PROPERTY L'annotation n'est disponible que dans kotlinDisponible en,Sijava Pour être disponible, vous devez également déclarer
@Target(AnnotationTarget.FIELD,AnnotationTarget.PROPERTY),[email protected] Commentaires indiquant si les commentaires seront stockés dans .classDocumentation, Le temps d'exécution est - il accessible par la classe reflect ,InjavaDans le.class Réservé mais ne peut pas être exécuté pour obtenir ,Inkotlin Par défaut à .class Informations d'annotation stockées dans ,InRuntimeConserver les commentaires.

Utiliser la classe comme paramètre d'annotation

Le scénario d'utilisation est quand une classe imbriquée est désrialisée , La personnalisation utilise ce type d'argument pour l'assignation

 class School{
    
 //Nom de l'école
 val schoolName
 //Bureau,Utiliser le nom de la classe：：class  Pour faire référence à une classe 
 @DeserializeInterface(xxx::class)
 var office:Office
}

Déclaration annotée

annotation class DeserializeInterface(val targetClass:Kclass<out Any>)

Notez le modificateur générique ici outUtilisation de, Représente la relation du sous - type réservé .C'est - à - dire:Covariance,Kclass Les types qui peuvent être reçus sont AnyC'est - à - dire:Any Tout sous - type dérivé peut être utilisé comme KclassTypes génériques pour.Si non utiliséout Si vous faites des retouches , Vous ne pouvez passer que AnyEn tant queKclassTypes génériques pour.

Utilisez des classes génériques pour annoter

interface ValueSeriailizer<T>{
    

	fun toJsonValue（value:T）:Any?
	
	fun fromJsonValue(jsonValue:Any?):T

}

data class Persion{
    

@CustomAnnotation(DateSerializer::class)
val date:Date
}

//@CustomAnnotation Comment déclarer
annotaion class CustomAnnotation(val serializerClass:Kclass<ValueSerializer<*>>)

Vous devez vous assurer que serializerClass Les arguments entrés lors de l'appel doivent être implémentés ValueSerializerClasse d'interface

Kclass<out ValueSerializer<*>>

outModificateur, Indique la réception de toute implémentation ValueSerializerInterface,Ce n'est pas justeValueSerializer::class
ValueSerializer<*>Dans * , Vous pouvez sérialiser n'importe quelle valeur

Voici une écriture générique pour les classes d'annotation qui doivent être passées avec des classes d'annotation comme arguments réels ：

//SiYourClassName  A son propre type d'argument ,C'est bon.*Remplacer
Kclass<out YourClassName>

Résumé

1. java Appliquer la syntaxe annotée et kotlinPresque pareil.
2. kotlin Rendre la plage cible de l'annotation plus grande que javaPlus large, Y compris les fichiers et les expressions
3. Les paramètres d'une classe d'annotation peuvent être des types de base 、String、Enumeration、Référence de classe、 Autres exemples de classes d'annotation 、Ou données
4. Utiliser des cibles ponctuelles pour traiter kotlin Cette déclaration produit plusieurs cas d'éléments de code byte .var a=1 Correspondant àjava Trois types d'éléments de code byte .
5. La Déclaration de classe annotée a une construction principale sans que tous les paramètres de la méthode de construction du corps de classe soient marqués comme valPropriétés
6. Les méta - annotations sont utilisées pour spécifier la destination du point d'utilisation 、 Mode de conservation 、 Et d'autres propriétés annotées

Références
Kotlin Le combat réel chapitre 10 ,Notes