Résumé du comportement de ToString avec les annotations Java et Groovy

c'est?

Le travail est src.main est Java, src.test est Groovy, mais si j'écrivais src.main dans Groovy avec une exigence un peu différente, je me suis accroché à @ ToString alors je l'ai résumé Note Je ne sais pas à quel point le résumé est significatif

C'est un système qui crée une classe avec Groovy, l'exécute et l'utilise lors de la sortie des variables vers le terminal et le fichier journal avec ʻAOP, mais ce n'était pas correctement ToString` du tout, donc je l'ai vérifié

Java Java a une annotation @ lombok.ToString (nécessite lombok)

lombok.ToString

public @interface ToString {
	boolean includeFieldNames() default true;

	String[] exclude() default {};

	String[] of() default {};

	boolean callSuper() default false;

	boolean doNotUseGetters() default false;
}

C'est un extrait excluant la partie javadoc de la source, mais le point principal est les éléments de réglage ci-dessus

Class Normalement, il est utilisé comme ʻimport, mais cette fois je veux le spécifier et l'écrire comme @ lombok.ToString` pour réduire le nombre de lignes de code publiées.

1 Aucune annotation

Qui veut voir ça

public class FooId1 {
    private final String value = "1234";
}
// to_string.j.c.FooId1@27c170f0

2 Attachez simplement

C'est facile, et selon la situation, cela suffit

@lombok.ToString
public class FooId2 {
    private final String value = "1234";
}
// FooId2(value=1234))

3 Éliminer les noms de champs

Je vous donnerai un exemple plus tard, mais c'est mieux si vous avez une structure de classe avec de nombreux nids.

@lombok.ToString(includeFieldNames = false)
public class FooId3 {
    private final String value = "1234";
}
// FooId3(1234)

4 Utilisé lorsqu'il y a un accesseur

Il est peu probable que vous écriviez un accessoire étrange à la main, mais cela semble être un accident et publié comme une petite histoire

@lombok.ToString
public class FooId4 {
    private final String value = "1234";

    public String getValue() {
        return "5678";
    }
}
// FooId4(value=5678)

5 N'utilisez pas d'accesseurs

Si vous écrivez comme ça, vous pouvez éviter les accidents

@lombok.ToString(doNotUseGetters = true)
public class FooId5 {
    private final String value = "1234";

    public String getValue() {
        return "5678";
    }
}
// FooId5(value=1234)

Exemple 2'2 d'imbrication

Si vous l'attachez simplement, c'est personnellement redondant

@lombok.ToString
public class Foo2 {
    private final FooId2 id = new FooId2();
    private final FooName2 name = new FooName2();
}
// Foo2(id=FooId2(value=1234), name=FooName2(value=John Doe))

Exemple 3'3 d'imbrication

C'est le meilleur personnellement pour la classe Java

@lombok.ToString(includeFieldNames = false)
public class Foo3 {
    private final FooId3 id = new FooId3();
    private final FooName3 name = new FooName3();
}
// Foo3(FooId3(1234), FooName3(John Doe))

Enum J'ai également vérifié ʻEnum`

1 Aucune annotation

ʻEnum` est d'accord avec ça

public enum FooStatus1 {
    APPLYING, NOT_APPLYING
}
// NOT_APPLYING

2 Attachez simplement

C'est bien que le nom de la classe apparaisse, mais la partie importante n'est pas incluse

@lombok.ToString
public enum FooStatus2 {
    APPLYING, NOT_APPLYING
}
// FooStatus2()

Groovy Groovy a une annotation @ groovy.transform.ToString, qui est fournie par le langage

lombok.ToString

public @interface ToString {
    String[] excludes() default {};

    String[] includes() default {};

    boolean includeSuper() default false;

    boolean includeSuperProperties() default false;

    boolean includeNames() default false;

    boolean includeFields() default false;

    boolean ignoreNulls() default false;

    boolean includePackage() default true;

    boolean cache() default false;
}

De même, seuls les éléments de paramétrage sont extraits

Class Je n'ai pas compris «Groovy» avant d'essayer diverses choses.

1 Aucune annotation

De même, il n'y a pas de demande pour cela

class FooId1 {
    private final String value = '1234'
}
// to_string.g.c.FooId1@3159c4b8

2 Attachez simplement

Ce n'est pas un prix! ?? Pratiquement rien n'a changé, non? ??

@groovy.transform.ToString
class FooId2 {
    private final String value = '1234'
}
// to_string.g.c.FooId2()

3 Essayez de le rendre public

Je pensais que «privé» était mauvais, alors j'ai essayé de le rendre «public», mais cela n'a pas résolu

@groovy.transform.ToString
class FooId3 {
    public final String value = '1234'
}
// to_string.g.c.FooId3()

4 Supprimer le modificateur d'accès

Résolu pour une raison quelconque Mais je veux le rendre `privé '

@groovy.transform.ToString
class FooId4 {
    final String value = '1234'
}
// to_string.g.c.FooId4(1234)

Inclut explicitement 5 champs

Il semble que le champ ne soit pas inclus par défaut lorsque l'on regarde diverses choses

@groovy.transform.ToString(includeFields = true)
class FooId5 {
    private final String value = '1234'
}
// to_string.g.c.FooId5(1234)

6 Y compris le nom du champ

Peut également être inclus

@groovy.transform.ToString(includeFields = true, includeNames = true)
class FooId6 {
    private final String value = '1234'
}
// to_string.g.c.FooId6(value:1234)

7 N'incluez pas le FQCN

Si vous pensez correctement à la configuration du paquet à une certaine échelle, ce sera trop long s'il y a FQCN, donc je veux l'effacer

@groovy.transform.ToString(includeFields = true, includePackage = false)
class FooId7 {
    private final String value = '1234'
}
// FooId7(1234)

Exemples d'imbrication 6'6

Est-il trop long d'avoir «FQCN» et le nom du champ?

@groovy.transform.ToString(includeFields = true, includeNames = true)
class Foo6 {
    private final FooId6 id = new FooId6()
    private final FooName6 name = new FooName6()
}
// to_string.g.c.Foo6(id:to_string.g.c.FooId6(value:1234), name:to_string.g.c.FooName6(value:Jane Doe))

Exemples d'imbrication 7'7

Pour la classe Groovy, c'est personnellement le meilleur

@groovy.transform.ToString(includeFields = true, includePackage = false)
class Foo7 {
    private final FooId7 id = new FooId7()
    private final FooName7 name = new FooName7()
}
// Foo7(FooId7(1234), FooName7(Jane Doe))

Enum Exactement la même chose que Java pour ʻEnum`

1 Aucune annotation

ʻEnum` est d'accord avec ça

public enum FooStatus1 {
    APPLYING, NOT_APPLYING
}
// NOT_APPLYING

2 Attachez simplement

C'est bien que le nom de la classe apparaisse, mais la partie importante n'est pas incluse

@lombok.ToString
public enum FooStatus2 {
    APPLYING, NOT_APPLYING
}
// FooStatus2()

Résumé

Table de correspondance

Organisez uniquement les parties susceptibles de correspondre

Il y a toujours un élément dans @ groovy.transform.ToString, mais il n'y a pas d'élément correspondant dans @ lombok.ToString et je ne suis pas intéressé par cela maintenant, donc je vais l'omettre

Republication Java

Class a la même méthode de spécification que Foo, et ʻEnum` est unifié sans annotations.

@lombok.ToString(includeFieldNames = false)
public class Foo {
    private final FooId id = new FooId();
    private final FooName name = new FooName();
    private final FooStatus fooStatus = FooStatus.NOT_APPLYING;
    private final BarStatus barStatus = BarStatus.NOT_APPLYING;
}
// Foo(FooId(1234), FooName(John Doe), NOT_APPLYING, NOT_APPLYING)

Je pense que seuls les points les plus rafraîchissants et les plus importants sont affichés

Groovy republié

De même, «Class» a la même méthode de spécification que «Foo» et «Enum» est unifié sans annotations.

@groovy.transform.ToString(includeFields = true, includePackage = false)
class Foo {
    private final FooId id = new FooId()
    private final FooName name = new FooName()
    private final FooStatus fooStatus = FooStatus.NOT_APPLYING
    private final BarStatus barStatus = BarStatus.NOT_APPLYING
}

// Foo(FooId(1234), FooName(Jane Doe), NOT_APPLYING, NOT_APPLYING)

C'était exactement la même chose!

prime

Utilisez @ lombok.ToString pour Groovy Class

Je crée généralement une classe avec Java, mais quand je crée une classe avec Groovy et ne copie que la partie annotation de java, elle est mélangée.

Cela n'a pas de sens dès la conclusion

@lombok.ToString
class FooId1 {
    private final String value = '1234'
}

// to_string.r.g.FooId1@29ca901e

Utilisez @ groovy.transform.ToString pour la classe Java

Je ne pense pas que le contraire puisse arriver, mais je l'ai essayé

Après tout, cela n'a aucun sens de la conclusion

@groovy.transform.ToString
public class FooId1 {
    private final String value = "1234";
}

// to_string.r.j.FooId1@27c170f0

Comment spécifier un tableau d'annotations Java

S'agit-il davantage des annotations en général que de «@ ToString»?

Pour Java, spécifiez {x, y, ...} je le savais

@lombok.ToString(includeFieldNames = false, of = {"spam", "egg"})
public class Python {
    private final String spam = "spam";
    private final String ham = "ham";
    private final String egg = "egg";
}
// Python(spam, egg)

• C'est facile de se tromper (?), Mais ce n'est pas [" spam "," ham "]
• Si c'est ʻInelli J`, vous remarquerez immédiatement la ligne rouge
• {" Spam "} peut être écrit comme "spam" `
• Ceci est une abréviation

Comment spécifier un tableau d'annotations Groovy

Je n'ai pas compris cela au début, et c'était très déroutant à cause du comportement du modificateur d'accès de groovy.transform.ToString.

S'il s'agit de Groovy, spécifiez [x, y, ...]

@groovy.transform.ToString(includePackage = false, includes = ['spam', 'egg'])
class Python {
    private final String spam = 'spam'
    private final String ham = 'ham'
    private final String egg = 'egg'
}
// Python()

...！？ Je n'ai été prévenu de rien, mais ça me semble totalement inutile, mais qu'est-ce que c'est!

J'étais vraiment dedans, mais quand j'y pense maintenant, il n'y a pas de ʻincludeFields = true`. Je suis un peu drôle parce que j'ai mis en place juste ça pour que je puisse le comprendre tout de suite

N'est-il pas logique de spécifier ʻincludes sans définir ʻinclude Fields? !! Déroutant! !! !!

À propos, la notation mystérieuse telle que ʻincludes = 'spam, egg'` semble être fourmi. Est-ce la règle de «@ groovy.transform.ToString»? Les règles «Groovy»?

Terrain privé Groovy

En fait, «privé» de «Groovy» n'a presque aucun sens Donc, même si vous supprimez private et ajoutez simplement @ groovy.transform.ToString, ce n'est pas grave.

Éloignons-nous de @ groovy.transform.ToString pour un moment et organisons le comportement de privé

class Bar {
    String v1 = 'v1'
    public String v2 = 'v2'
    private String v3 = 'v3'
    static String v4 = 'v4'
    static public String v5 = 'v5'
    static private String v6 = 'v6'
}

Écrivez un cours comme celui-ci

Si vous écrivez comme ça, vous pouvez y accéder

Cependant, si c'est ʻIntelliJ, il ne sera pas complété et un avertissement sera émis même si vous le forcez, donc je veux l'écrire comme privé`

«v3» et «v6» n'apparaissent pas comme des candidats à l'achèvement, et même si vous écrivez, «v3» et «v6» sont un peu jaunes! Merci ʻIntelliJ`!

Référence

En fait insatisfait du résultat d'Enum

Comme je l'ai republié dans le résumé, il devient un peu difficile de comprendre si ʻEnum` avec le même nom d'élément est aligné.

// Foo(FooId(1234), FooName(John Doe), NOT_APPLYING, NOT_APPLYING)

Si ʻAPPLYING, NOT_APPLYING, APPLYING` sont alignés, vous pouvez obtenir "Hmm? Quel est le second?"

L'idéal est donc de ressembler à celui ci-dessous, mais cela n'a pas fonctionné

// Foo(FooId(1234), FooName(John Doe), FooStatus.NOT_APPLYING, BarStatus.NOT_APPLYING)

Je peux le faire si j'écris comme ça Je ne veux pas écrire à la main

public enum BazStatus {
    APPLYING, NOT_APPLYING;

    @Override
    public String toString() {
        return getClass().getSimpleName() + "." + name();
    }
}
// BazStatus.NOT_APPLYING

J'ai beaucoup de petites plaintes autres que «@ ToString», donc je veux faire une annotation, mais comment faire une annotation pour un système qui produit un tel code? Selon le contenu, vous aurez également besoin du plug-in ʻInelli J`, et il m'est toujours difficile de l'utiliser en équipe au travail.

MetaClass est mixte

Au fait, j'ai oublié parce que je ne l'ai pas vu dans ce résumé, mais quand je l'ai traité pendant le travail, quelque chose comme ça a été mélangé dans le résultat de @ groovy.transform.ToString. Cependant, c'était un obstacle car c'était juste un hash avec FQCN et c'était inutilement long et je n'étais pas intéressé par le contenu car je ne l'ai pas défini moi-même.

Je me demande donc si j'ai fait une enquête sur "comprend" J'étais confus parce que j'ai vérifié en combinant les modificateurs d'accès, ʻincludeFields, ʻincludes et les spécifications de tableau à la fois.

La fin