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

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

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

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
}

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).

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

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

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

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

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

Contrôles nuls!

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

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

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

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.

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

throw new IllegalArgumentException(${var});

Meilleur

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

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.

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

slf4j Logging

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

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

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

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.

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

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.

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

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

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

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

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}

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.

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

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

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

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.

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!

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

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