À la recherche de modèles de code Java Eclipse utiles [fermé]


516

Vous pouvez créer divers modèles de code Java dans Eclipse via

Fenêtre> Préférences> Java> Éditeur> Modèles

par exemple

sysout est étendu à:

System.out.println(${word_selection}${});${cursor}

Vous pouvez l'activer en tapant sysoutsuivi deCTRL+SPACE

Quels modèles de code Java utiles utilisez-vous actuellement? Incluez le nom et la description de celui-ci et pourquoi il est génial.

Je recherche une utilisation originale / nouvelle d'un modèle plutôt qu'une fonctionnalité existante intégrée.

  • Créer un enregistreur Log4J
  • Obtenez la couleur swt de l'affichage
  • Syncexec - Eclipse Framework
  • Modèle de singleton / Génération de singleton enum
  • Readfile
  • Const
  • Tracer
  • Format de chaîne
  • Examen du code de commentaire
  • Format de chaîne
  • Essayez enfin de verrouiller
  • Format du message i18n et journal
  • Equalsbuilder
  • Hashcodebuilder
  • Injection d'objets de printemps
  • Créer FileOutputStream

5
Y en a-t-il qui génèrent une instruction switch à partir d'un Enum avec tous les cas possibles? Je sais que vous pouvez le faire avec CTRL + 1, mais je préfère utiliser la complétion cmd.
GreenKiwi

4
Pouvez-vous expliquer ce que cela System.out.println(${word_selection}${});${cursor}signifie? Il semble qu'il existe un moyen de sélectionner un mot et de l'enfermer automatiquement dans un sysoutappel, ai-je raison? Comment?
CodyBugstein

3
vous mettez en surbrillance le mot que vous voulez entouré par appel sysout et appuyez sur Ctrl-Espace (puis en tapant le nom du modèle si vous avez beaucoup de modèles sensibles à la surbrillance)
JReader

@JReader, que fait $ {}?
Roland

Réponses:


423

Les modèles de code suivants créeront un enregistreur et créeront les importations appropriées, si nécessaire.

SLF4J

${:import(org.slf4j.Logger,org.slf4j.LoggerFactory)}
private static final Logger LOG = LoggerFactory.getLogger(${enclosing_type}.class);

Log4J 2

${:import(org.apache.logging.log4j.LogManager,org.apache.logging.log4j.Logger)} 
private static final Logger LOG = LogManager.getLogger(${enclosing_type}.class); 

Log4J

${:import(org.apache.log4j.Logger)}
private static final Logger LOG = Logger.getLogger(${enclosing_type}.class);

Source .

JUIL

${:import(java.util.logging.Logger)}
private static final Logger LOG = Logger.getLogger(${enclosing_type}.class.getName());

31
Cool. Je ne connaissais pas le truc $ {: import ...}.
JesperE

3
Je pense que $ {: import ...} ne fonctionne que dans les nouvelles versions d'Eclipse. Je suis bloqué avec 3.2 et cela ne fonctionne pas pour moi.
Adam Crume

Pas dans ma version (3.5) non plus. Quelqu'un sait-il dans quelle version il a été introduit?
finnw

5
J'aime cela! Mais j'ai mis $ {import ...} en dessous de la déclaration Logger, afin qu'il n'ajoute pas de nouvelle ligne.
Dario Seidl

1
@TMS - ajouté, merci!
Robert Munteanu

49

Quelques modèles supplémentaires ici: Lien I - Lien II

J'aime celui la:

readfile

 ${:import(java.io.BufferedReader,  
           java.io.FileNotFoundException,  
           java.io.FileReader,  
           java.io.IOException)}  
 BufferedReader in = null;  
 try {  
    in = new BufferedReader(new FileReader(${fileName}));  
    String line;  
    while ((line = in.readLine()) != null) {  
       ${process}  
    }  
 }  
 catch (FileNotFoundException e) {  
    logger.error(e) ;  
 }  
 catch (IOException e) {  
    logger.error(e) ;  
 } finally {  
    if(in != null) in.close();  
 }  
 ${cursor} 

MISE À JOUR : La version Java 7 de ce modèle est:

${:import(java.nio.file.Files,
          java.nio.file.Paths,
          java.nio.charset.Charset,
          java.io.IOException,
          java.io.BufferedReader)}
try (BufferedReader in = Files.newBufferedReader(Paths.get(${fileName:var(String)}),
                                                 Charset.forName("UTF-8"))) {
    String line = null;
    while ((line = in.readLine()) != null) {
        ${cursor}
    }
} catch (IOException e) {
    // ${todo}: handle exception
}

48
je pense que c'est à ça que sert une méthode :)
benmmurphy

3
Euh, je pense que vous avez manqué le point ... en disant que je ne sais pas vraiment quel est votre point ... il s'agit de la génération de code et non de la modularité ...
Jon

20
Je pense que le fait est que l'ajout de beaucoup de code dans un modèle est un programme de copier-coller pour une situation très courante.
Scott McIntyre

5
Oui, vous devez utiliser une méthode utilitaire pour lire un fichier au lieu de coller des blocs de code. Écrivez une méthode vous-même ou utilisez Apache commons-io IOUtils. Pourtant, si vous faites beaucoup de projets jetables avec différents chemins de classe, il peut être difficile d'ajouter un JAR ou un lien dans votre classe utilitaire juste pour lire un fichier. Parfois, il vous suffit d'écrire du code jetable qui lit un fichier et de continuer votre vie.
Mike Clark

1
En Java 7, préférez StandardCharsets.UTF_8plutôt Charset.forName("UTF-8").
Mike Clark

33

Formater une chaîne

MessageFormat - entourez la sélection d'un MessageFormat.

 ${:import(java.text.MessageFormat)} 
 MessageFormat.format(${word_selection}, ${cursor})

Cela me permet de déplacer un curseur sur une chaîne, d'étendre la sélection à toute la chaîne (Maj-Alt-Haut), puis Ctrl-Espace deux fois.

Verrouiller la sélection

lock - entourez les lignes sélectionnées d'un essai de verrouillage final. Supposons la présence d'une variable de verrouillage.

${lock}.acquire();
try {
    ${line_selection}
    ${cursor}
} finally {
    ${lock}.release();
}

Les ${line_selection}modèles NB apparaissent dans le menu Surround With (Alt-Shift-Z).


J'utilise celui-ci combiné avec des instructions de journal: logger.info (MessageFormat.format ($ {word_selection}, $ {cursor});
Pierre Henry

Les méthodes d'acquisition et de libération des verrous sont appelées locket unlock. acquireet releasesont utilisés pour les sémaphores et leur utilisation dans un bloc try-finally n'est pas aussi fortement conseillée qu'avec les verrous .
Marco Lackovic

Ctrl + Espace deux fois ne semble plus fonctionner, fait apparaître des modèles SWT. Y a-t-il un remplaçant?
Noumenon

28

Je sais que je donne un coup de pied à un poste mort, mais je voulais le partager pour terminer:

Une version correcte du modèle de génération singleton, qui surmonte la conception de verrouillage défectueuse à double vérification (discutée ci-dessus et mentionnée ailleurs où)

Modèle de création de singleton: nommez-lecreatesingleton

static enum Singleton {
    INSTANCE;

    private static final ${enclosing_type} singleton = new ${enclosing_type}();

    public ${enclosing_type} getSingleton() {
        return singleton;
    }
}
${cursor}


Pour accéder aux singletons générés en utilisant ci-dessus:

Modèle de référence Singleton: Nommez ceci getsingleton:

${type} ${newName} = ${type}.Singleton.INSTANCE.getSingleton();

4
Ce n'est pas mort, c'est un wiki communautaire, il est donc logique d'y ajouter plus de modèles au fur et à mesure que vous les trouvez. Il n'y a pas vraiment un ensemble complet de ceux-ci ailleurs ...
Jon

Jon, l'écart de temps entre le post précédent et mon post était de près de 8 mois, c'est ce qui a obligé à le citer. Je ne pourrais pas l'
exprimer

Lorsque je crée cela dans le cadre d'une classe (une énumération imbriquée dans une classe) j'obtiens le nom de la classe comme ${enclosing_type}prévu?
Mr_and_Mrs_D

1
@Mr_and_Mrs_D, je pense que c'est le point. Vous obtenez une instance singleton de la classe dans laquelle vous placez ce modèle. Maintenant, tout ce que vous avez à faire est de rendre les constructeurs de type englobants privés et d'avoir un générateur de singleton assez sûr.
Mike Adler

Si vous souhaitez utiliser ceci pour créer un ${primary_type_name}exemple d' utilisation d'énumération :public enum ${primary_type_name} { INSTANCE; private ${return_type} ${name} = new ${return_type}(); public ${return_type} ${getName}(${}) { return ${name}; } ${cursor} }
Robert Smit

28

Ajoutez un extrait de code pour parcourir Map.entrySet():

Modèle:

${:import(java.util.Map.Entry)}
for (Entry<${keyType:argType(map, 0)}, ${valueType:argType(map, 1)}> ${entry} : ${map:var(java.util.Map)}.entrySet())
{
    ${keyType} ${key} = ${entry}.getKey();
    ${valueType} ${value} = ${entry}.getValue();
    ${cursor}
}

Code généré:

for (Entry<String, String> entry : properties.entrySet())
{
    String key = entry.getKey();
    String value = entry.getValue();
    |
}

Capture d'écran


1
Comme votre photo, cela me montre que vous pouvez utiliser une variable dans ${}et que, au lieu de ${cursor}, permet une "itération de tabulation" entre les champs. Merci.
WesternGun

25

Pour log, une petite chanson utile à ajouter dans la variable membre.

private static Log log = LogFactory.getLog(${enclosing_type}.class);

Pour écrire manuellement dans un fichier journal: $ {: import (java.io.PrintWriter, java.io.BufferedWriter, java.io.FileWriter)} essayez {PrintWriter out = new PrintWriter (new BufferedWriter (new FileWriter ($ {logFile: var (String)}, true))); out.println ($ {logLine: var (String)} $ {cursor}); out.close (); } catch (IOException e) {/ * TODO: gestion des exceptions * / e.printStackTrace (); }
Jack Miller

24

Créez une maquette avec Mockito (dans le contexte "Java déclarations"):

${:importStatic('org.mockito.Mockito.mock')}${Type} ${mockName} = mock(${Type}.class);

Et dans "Membres de type Java":

${:import(org.mockito.Mock)}@Mock
${Type} ${mockName};

Mock une méthode void pour lever une exception:

${:import(org.mockito.invocation.InvocationOnMock,org.mockito.stubbing.Answer)}
doThrow(${RuntimeException}.class).when(${mock:localVar}).${mockedMethod}(${args});

Se moquer d'une méthode void pour faire quelque chose:

${:import(org.mockito.invocation.InvocationOnMock,org.mockito.stubbing.Answer)}doAnswer(new Answer<Object>() {
public Object answer(InvocationOnMock invocation) throws Throwable {
    Object arg1 = invocation.getArguments()[0];
    return null;
}
}).when(${mock:localVar}).${mockedMethod}(${args});

Vérifiez la méthode simulée appelée exactement une fois:

${:importStatic(org.mockito.Mockito.verify,org.mockito.Mockito.times)}
verify(${mock:localVar}, times(1)).${mockMethod}(${args});

Vérifiez que la méthode simulée n'est jamais invoquée:

${:importStatic(org.mockito.Mockito.verify,org.mockito.Mockito.never)}verify(${mock:localVar}, never()).${mockMethod}(${args});

Nouvelle liste de liens utilisant Google Guava (et similaire pour hashset et hashmap):

${import:import(java.util.List,com.google.common.collect.Lists)}List<${T}> ${newName} = Lists.newLinkedList();

J'utilise également un énorme modèle qui génère une classe de test. En voici un fragment abrégé que toutes les personnes intéressées devraient personnaliser:

package ${enclosing_package};

import org.junit.*;
import static org.junit.Assert.*;
import static org.hamcrest.Matchers.*;
import static org.mockito.Matchers.*;
import static org.mockito.Mockito.*;
import org.mockito.Mockito;
import org.slf4j.Logger;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import org.junit.runner.RunWith;

// TODO autogenerated test stub
@RunWith(MockitoJUnitRunner.class)
public class ${primary_type_name} {

    @InjectMocks
    protected ${testedType} ${testedInstance};
    ${cursor}

    @Mock
    protected Logger logger;

    @Before
    public void setup() throws Exception {
    }

    @Test
    public void shouldXXX() throws Exception {
        // given

        // when
        // TODO autogenerated method stub

        // then
        fail("Not implemented.");
    }
}
// Here goes mockito+junit cheetsheet

1
Je suis curieux: pourquoi auriez-vous besoin de vous moquer de l'enregistreur?
Vladimir Sizikov

6
vous pouvez vérifier que l'enregistreur simulé a été appelé au cas où une exception a été interceptée (scénario d'échec). c'est particulièrement utile si vous n'avez pas l'intention de le renverser mais que vous voulez affirmer qu'il n'est pas ignoré en silence.
mantrid

23

Contrôles nuls!

if( ${word_selection} != null ){
    ${cursor}
}

if( ${word_selection} == null ){
    ${cursor}
}

La PreConditions.checkNotNull(...)méthode à Guava est une alternative très lisible (en particulier avec les importations statiques)
Thorbjørn Ravn Andersen

Il est recommandé de vérifier d'abord null (== null) avant de vérifier non null.
KrishPrabakar

21

Un de mes bien-aimés est foreach :

for (${iterable_type} ${iterable_element} : ${iterable}) {
    ${cursor}
}

Et traceout , puisque je l'utilise beaucoup pour le suivi:

System.out.println("${enclosing_type}.${enclosing_method}()");

J'ai juste pensé à un autre et je l'ai trouvé un jour sur Internet, const :

private static final ${type} ${name} = new ${type} ${cursor};

11
foreach est disponible en tant qu'assistant de code standard dans Eclipse, je ne vois pas que votre modèle fasse quoi que ce soit de plus que la version standard
Rich Seller

4
À droite, et sysout est un modèle très innovant. La question portait sur les modèles utiles que nous utilisons.
Artem Barger le

4
votre traceoutest déjà disponible dans Eclipse en tant que systrace.
dogbane

7
Bien, je veux croire qu'il apparaît maintenant dans Eclipse à cause de cette question.
Artem Barger

const est disponible en tant qu'assistant de code standard en tant que static_final (je ne sais pas quand il a été ajouté)
Armand

20

Un petit conseil sur sysout - j'aime le renommer "sop". Rien d'autre dans les bibliothèques java ne commence par "sop", vous pouvez donc taper rapidement "sop" et boom, insère-t-il.


11
Par défaut, la simple saisie de syso fera la même chose que sysout.
MasterScrat

9
Vous battre de 25% avec sop, cependant ...;)
Scott Stanchfield

2
Depuis Eclipse Mars, il y a un mauvais retour en arrière sur le raccourci "syso" + Ctrl + Espace : il listera certaines classes qui ont les caractères s, y, s et o dans leur nom (en raison d'une nouvelle découverte de CamelCase). Donc, maintenant, vous devez également choisir sysout dans la liste et appuyer sur Retour.
bobbel

17

Lancez une exception IllegalArgumentException avec une variable dans la portée actuelle (illarg):

throw new IllegalArgumentException(${var});

Meilleur

throw new IllegalArgumentException("Invalid ${var} " + ${var});  

14

Rien d'extraordinaire pour la production de code - mais très utile pour les revues de code

J'ai mon modèle coderev low / med / high faire ce qui suit

/**
 * Code Review: Low Importance
 * 
 *
 * TODO: Insert problem with code here 
 *
 */

Et puis, dans la vue Tâches - me montrera tous les commentaires de révision de code que je veux faire apparaître lors d'une réunion.


14

Quelques modèles supplémentaires ici .

Comprend:

  • Créer un objet date à partir d'une date particulière
  • Créer une nouvelle liste de tableaux générique
  • Configuration de l'enregistreur
  • Journal avec niveau spécifié
  • Créer un nouveau HashMap générique
  • Itérer à travers une carte, imprimer les clés et les valeurs
  • Analyser un temps à l'aide de SimpleDateFormat
  • Lire un fichier ligne par ligne
  • Connectez-vous et relancez une exception capturée
  • Imprimer le temps d'exécution d'un bloc de code
  • Créer une minuterie périodique
  • Écrire une chaîne dans un fichier

a ajouté un lien de machine de retour
berezovskyi

12

slf4j Logging

${imp:import(org.slf4j.Logger,org.slf4j.LoggerFactory)}

private static final Logger LOGGER = LoggerFactory
    .getLogger(${enclosing_type}.class);

10

Propriété Bean

private ${Type} ${property};

public ${Type} get${Property}() {
    return ${property};
}

public void set${Property}(${Type} ${property}) {
    ${propertyChangeSupport}.firePropertyChange("${property}", this.${property},     this.${property} = ${property});
}

PropertyChangeSupport

private PropertyChangeSupport ${propertyChangeSupport} = new PropertyChangeSupport(this);${:import(java.beans.PropertyChangeSupport,java.beans.PropertyChangeListener)}
public void addPropertyChangeListener(PropertyChangeListener listener) {
  ${propertyChangeSupport}.addPropertyChangeListener(listener);
}

public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
  ${propertyChangeSupport}.addPropertyChangeListener(propertyName, listener);
}

public void removePropertyChangeListener(PropertyChangeListener listener) {
  ${propertyChangeSupport}.removePropertyChangeListener(listener);
}

public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
  ${propertyChangeSupport}.removePropertyChangeListener(propertyName, listener);
}

10

Après Java 7, un excellent moyen de configurer des enregistreurs qui ont besoin (ou préfèrent) des références statiques à la classe englobante consiste à utiliser l'API MethodHandles nouvellement introduite pour obtenir la classe d'exécution dans un contexte statique.

Un exemple d'extrait pour SLF4J est:

private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());

En plus d'être un simple extrait dans n'importe quel IDE, il est également moins fragile si vous refactorisez certaines fonctionnalités dans une autre classe car vous ne porterez pas accidentellement le nom de la classe avec lui.


9

Appeler du code sur le thread GUI

Je lie le modèle suivant au raccourci slaterpour envoyer rapidement du code sur le thread GUI.

${:import(javax.swing.SwingUtilities)}
SwingUtilities.invokeLater(new Runnable() {      
      @Override
      public void run() {
        ${cursor}
      }
    });

9

Lors de tests avec du code, j'ai parfois manqué de supprimer certains syso . Je me suis donc fait un modèle appelé syt .

System.out.println(${word_selection}${});//${todo}:remove${cursor}

Avant de compiler, je vérifie toujours mes TODO et n'oublierai jamais de supprimer un System.out à nouveau.


9

strf -> String.format("msg", args) assez simple mais économise un peu de frappe.

String.format("${cursor}",)

6
J'utilise String.format("${string}",${objects})car Eclipse me permet de tabuler entre ma chaîne et ma liste d'objets.
Duncan Jones

J'utilise cette version String.format(${word_selection}${},)${cursor}:, sélectionnez d'abord une chaîne puis utilisez 'sf' dessus. Ajoutez le% s et ainsi de suite ...
Christophe Roussy

8

Obtenez une couleur SWT à partir de l'affichage actuel:

Display.getCurrent().getSystemColor(SWT.COLOR_${cursor})

Suround avec syncexec

PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable(){
    public void run(){
        ${line_selection}${cursor}
    }
});

Utilisez le modèle de conception singleton:

/**
 * The shared instance.
 */
private static ${enclosing_type} instance = new ${enclosing_type}();

/**
 * Private constructor.
 */
private ${enclosing_type}() {
    super();
}

/**
 * Returns this shared instance.
 *
 * @returns The shared instance
 */
public static ${enclosing_type} getInstance() {
    return instance;
}

3
Juste une note rapide - Selon le Maestro connu sous le nom de Joshua Bloch, l'utilisation d'un Enum devrait être la méthode préférée pour créer des singletons en Java.
Pablojim

Salut Pablojim, Depuis que j'ai publié ce modèle, je commence à lire Effective Java et j'ai changé mes implémentations singletons en enum. Néanmoins, je n'ai pas trouvé de moyen pour que le modèle génère l'énumération et modifie ainsi la déclaration de classe. Avez-vous ce modèle? Merci Manu
Manuel Selva le

Pour info: voici le motif enum singleton electrotek.wordpress.com/2008/08/06/… . Je n'aime pas particulièrement ça mais je n'ai pas beaucoup de singletons. Il est facile de transformer cela en un modèle Java.
pjp

1
Pour l'approche enum, j'espère que tous vos singletons ont un sens en tant qu'objets comparables et sérialisables, car beaucoup de singletons ne le font pas (et il se demande pourquoi cette "... approche n'a pas encore été largement adoptée" - parce que la comparabilité et la sérialisation ne
ça n'a pas de

Sérialisable? Oui. Envisagez la sérialisation d'un objet avec une référence à votre singleton. S'il n'est pas sérialisable, vous pouvez rencontrer un NPE. Si c'est le cas (et que vous n'ajoutez pas de méthodes pour remplacer la désérialisation par défaut), alors vous pourriez obtenir une autre instance de votre "Singleton".
Johannes Kuhn

8

Et une adaptation equalsbuilder, hashcodebuilder:

${:import(org.apache.commons.lang.builder.EqualsBuilder,org.apache.commons.lang.builder.HashCodeBuilder)}
@Override
public boolean equals(Object obj) {
    return EqualsBuilder.reflectionEquals(this, obj);
}

@Override
public int hashCode() {
    return HashCodeBuilder.reflectionHashCode(this);
}

Pour une solution sans réflexion, voir ma réponse sous le lien
gswierczynski

8

Le modèle de déclaration de l'enregistreur est excellent.

Je crée également linfo, ldebug, lwarn, lerror pour les niveaux de journalisation que j'utilise le plus souvent.

lerror:

logger.error(${word_selection}${});${cursor}

8

Créez tout pour un événement

Étant donné que les événements sont un peu pénibles à créer en Java - toutes ces interfaces, méthodes et autres choses à écrire juste pour 1 événement - j'ai créé un modèle simple pour créer tout le nécessaire pour 1 événement.

${:import(java.util.List, java.util.LinkedList, java.util.EventListener, java.util.EventObject)}

private final List<${eventname}Listener> ${eventname}Listeners = new LinkedList<${eventname}Listener>();

public final void add${eventname}Listener(${eventname}Listener listener)
{
    synchronized(${eventname}Listeners) {
        ${eventname}Listeners.add(listener);
    }
}

public final void remove${eventname}Listener(${eventname}Listener listener)
{
    synchronized(${eventname}Listeners) {
        ${eventname}Listeners.remove(listener);
    }
}

private void raise${eventname}Event(${eventname}Args args)
{
    synchronized(${eventname}Listeners) {
        for(${eventname}Listener listener : ${eventname}Listeners)
            listener.on${eventname}(args);
    }
}

public interface ${eventname}Listener extends EventListener
{
    public void on${eventname}(${eventname}Args args);
}

public class ${eventname}Args extends EventObject
{
    public ${eventname}Args(Object source${cursor})
    {
        super(source);
    }
}

Si vous avez des événements qui partagent un seul EventObject, supprimez simplement celui personnalisé inséré par le modèle et modifiez les parties appropriées de raise___()et on____().

J'avais écrit un mécanisme d'événement agréable, petit et élégant à l'aide d'une interface générique et d'une classe générique, mais cela ne fonctionnerait pas en raison de la façon dont Java gère les génériques. = (

Edit : 1) Je suis tombé sur le problème où les threads ajoutaient / supprimaient des écouteurs pendant qu'un événement se déroulait. Le Listne peut pas être modifié en cours d'utilisation, j'ai donc ajouté des synchronizedblocs où la liste des écouteurs est accédée ou utilisée, se verrouillant sur la liste elle-même.


L'envoi d'événements tout en étant verrouillé (synchronisé ou non) est un blocage en attente de se produire. Dans ce cas, il serait préférable de copier les écouteurs dans un bloc synchronisé et d'itérer la nouvelle liste.
ssindelar

Utilisez un ConcurrentLinkedQueue . Il ne nécessite pas de verrouillage, car il possède un itérateur faiblement cohérent, qui ne lève jamais d'exception ConcurrentModificationException.
Stefan Dollase

8

Insérez les méthodes de test devraient-être-données-quand-alors

J'ai vu une version similaire à celle-ci récemment lors de la programmation en binôme avec un très bon développeur et ami, et je pense que cela pourrait être un bon ajout à cette liste.

Ce modèle créera une nouvelle méthode de test sur une classe, en suivant l' approche Donné - Quand - Alors du paradigme de développement conduit par le comportement (BDD) sur les commentaires, comme guide pour structurer le code. Il démarrera le nom de la méthode par "devrait" et vous permettra de remplacer le reste du nom de la méthode factice "CheckThisAndThat" par la meilleure description possible de la responsabilité de la méthode de test. Après avoir rempli le nom, TAB vous amènera directement à la // Given section, afin que vous puissiez commencer à taper vos conditions préalables.

Je l'ai mappé aux trois lettres "tst", avec la description "Les méthodes de test devraient être données quand-alors";)

J'espère que vous le trouverez aussi utile que je l'ai fait quand je l'ai vu:

@Test
public void should${CheckThisAndThat}() {
    Assert.fail("Not yet implemented");
    // Given
    ${cursor}

    // When


    // Then

}${:import(org.junit.Test, org.junit.Assert)}

J'aime ce modèle. J'ai ajouté une "exception de lancers" pour faciliter encore le confort de test.
Torsten

J'aime le paradigme BDD. Très joli modèle pour ça. Et juste une note: votre très bon développeur et ami est parti!
bobbel

7

Injection de ressort

Je sais que c'est un peu tard dans le jeu, mais voici celui que j'utilise pour Spring Injection dans une classe:

${:import(org.springframework.beans.factory.annotation.Autowired)}
private ${class_to_inject} ${var_name};

@Autowired
public void set${class_to_inject}(${class_to_inject} ${var_name}) {
  this.${var_name} = ${var_name};
}

public ${class_to_inject} get${class_to_inject}() {
  return this.${var_name};
}

7

Voici un constructeur pour les classes non instanciables:

// Suppress default constructor for noninstantiability
@SuppressWarnings("unused")
private ${enclosing_type}() {
    throw new AssertionError();
}

Celui-ci est pour les exceptions personnalisées:

/**
 * ${cursor}TODO Auto-generated Exception
 */
public class ${Name}Exception extends Exception {
    /**
     * TODO Auto-generated Default Serial Version UID
     */
    private static final long serialVersionUID = 1L;    

    /**
     * @see Exception#Exception()
     */
    public ${Name}Exception() {
        super();
    }

    /**
     * @see Exception#Exception(String) 
     */
    public ${Name}Exception(String message) {
        super(message);         
    }

    /**
     * @see Exception#Exception(Throwable)
     */
    public ${Name}Exception(Throwable cause) {
        super(cause);           
    }

    /**
     * @see Exception#Exception(String, Throwable)
     */
    public ${Name}Exception(String message, Throwable cause) {
        super(message, cause);
    }
}

5

J'aime un commentaire de classe généré comme celui-ci:

/**
 * I... 
 * 
 * $Id$
 */

Le "je ..." encourage immédiatement le développeur à décrire ce que fait la classe. Il semble que j'améliore le problème des classes non documentées.

Et bien sûr, le $ Id $ est un mot-clé CVS utile.


5

J'ai beaucoup utilisé ces extraits, recherchant des nullvaleurs et des chaînes vides.

J'utilise les modèles "test d'argument" comme premier code dans mes méthodes pour vérifier les arguments reçus.

testNullArgument

if (${varName} == null) {
    throw new NullPointerException(
        "Illegal argument. The argument cannot be null: ${varName}");
}

Vous souhaiterez peut-être modifier le message d'exception pour l'adapter aux normes de votre entreprise ou de votre projet. Cependant, je recommande d'avoir un message qui inclut le nom de l'argument incriminé. Sinon, l'appelant de votre méthode devra chercher dans le code pour comprendre ce qui s'est mal passé. (Un NullPointerExceptionsans message produit une exception avec le message assez insensé "null").

testNullOrEmptyStringArgument

if (${varName} == null) {
    throw new NullPointerException(
        "Illegal argument. The argument cannot be null: ${varName}");
}
${varName} = ${varName}.trim();
if (${varName}.isEmpty()) {
    throw new IllegalArgumentException(
        "Illegal argument. The argument cannot be an empty string: ${varName}");
}

Vous pouvez également réutiliser le modèle de vérification null ci-dessus et implémenter cet extrait de code pour vérifier uniquement les chaînes vides. Vous utiliseriez ensuite ces deux modèles pour produire le code ci-dessus.

Le modèle ci-dessus, cependant, a le problème que si l'argument in est final, vous devrez modifier le code produit (le ${varName} = ${varName}.trim()échouera).

Si vous utilisez beaucoup d'arguments finaux et que vous souhaitez vérifier les chaînes vides mais que vous n'avez pas à les supprimer dans le cadre de votre code, vous pouvez utiliser ceci à la place:

if (${varName} == null) {
    throw new NullPointerException(
        "Illegal argument. The argument cannot be null: ${varName}");
}
if (${varName}.trim().isEmpty()) {
    throw new IllegalArgumentException(
        "Illegal argument. The argument cannot be an empty string: ${varName}");
}

testNullFieldState

J'ai également créé des extraits de code pour vérifier les variables qui ne sont pas envoyées comme arguments (la grande différence est le type d'exception, qui est maintenant un à la IllegalStateExceptionplace).

if (${varName} == null) {
    throw new IllegalStateException(
        "Illegal state. The variable or class field cannot be null: ${varName}");
}

testNullOrEmptyStringFieldState

if (${varName} == null) {
    throw new IllegalStateException(
        "Illegal state. The variable or class field cannot be null: ${varName}");
}
${varName} = ${varName}.trim();
if (${varName}.isEmpty()) {
    throw new IllegalStateException(
        "Illegal state. The variable or class field " +
            "cannot be an empty string: ${varName}");
}

testArgument

Il s'agit d'un modèle général pour tester une variable. Il m'a fallu quelques années pour vraiment apprendre à apprécier celui-ci, maintenant je l'utilise beaucoup (en combinaison avec les modèles ci-dessus bien sûr!)

if (!(${varName} ${testExpression})) {
    throw new IllegalArgumentException(
        "Illegal argument. The argument ${varName} (" + ${varName} + ") " +
        "did not pass the test: ${varName} ${testExpression}");
}

Vous entrez un nom de variable ou une condition qui renvoie une valeur, suivie d'un opérande ("==", "<", ">" etc.) et d'une autre valeur ou variable et si le test échoue, le code résultant lèvera une exception IllegalArgumentException.

La raison de la clause if légèrement compliquée, avec l'expression entière entourée d'un "! ()" Est de permettre de réutiliser la condition de test dans le message d'exception.

Peut-être que cela déroutera un collègue, mais seulement s'il doit consulter le code, ce qu'il pourrait ne pas avoir à faire si vous jetez ce genre d'exceptions ...

Voici un exemple avec des tableaux:

public void copy(String[] from, String[] to) {
    if (!(from.length == to.length)) {
        throw new IllegalArgumentException(
                "Illegal argument. The argument from.length (" +
                            from.length + ") " +
                "did not pass the test: from.length == to.length");
    }
}

Vous obtenez ce résultat en appelant le modèle, en tapant "from.length" [TAB] "== to.length".

Le résultat est beaucoup plus drôle qu'une "ArrayIndexOutOfBoundsException" ou similaire et peut réellement donner à vos utilisateurs une chance de comprendre le problème.

Prendre plaisir!


4

J'utilise ceci pour MessageFormat (en utilisant Java 1.4). De cette façon, je suis sûr que je n'ai pas de concaténations difficiles à extraire lors de l'internationalisation

i18n

String msg = "${message}";
Object[] params = {${params}};
MessageFormat.format(msg, params);

Aussi pour la journalisation:

Journal

if(logger.isDebugEnabled()){
  String msg = "${message}"; //NLS-1
  Object[] params = {${params}};
  logger.debug(MessageFormat.format(msg, params));
}

4

Mes préférés sont ...

1: Javadoc, pour insérer un document sur la méthode étant une méthode d'injection d'objets Spring.

 Method to set the <code>I${enclosing_type}</code> implementation that this class will use.
* 
* @param ${enclosing_method_arguments}<code>I${enclosing_type}</code> instance 

2: Fenêtre de débogage, pour créer un FileOutputStream et écrire le contenu du tampon dans un fichier. Utilisé lorsque vous souhaitez comparer un tampon avec une exécution antérieure (à l'aide de BeyondCompare), ou si vous ne pouvez pas afficher le contenu d'un tampon (via inspecter) car il est trop volumineux ...

java.io.FileOutputStream fos = new java.io.FileOutputStream( new java.io.File("c:\\x.x"));
fos.write(buffer.toString().getBytes());
fos.flush();
fos.close();
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.