Question Modèles de code Java Eclipse utiles [fermé]


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

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

par exemple.

sysout est étendu à:

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

Vous pouvez activer ceci en tapant sysout suivi par CTRL+SPACE

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

Il y a une prime ouverte sur ceci pour 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 - Framework Eclipse
  • Singleton Pattern / Enum Singleton Generation
  • Fichier de lecture
  • Const
  • Tracer
  • Chaîne de format
  • Révision du code de commentaire
  • Format de chaîne
  • Essayez enfin Lock
  • Format de message i18n et journal
  • Equalsbuilder
  • Hashcodebuilder
  • Injection d'objets de printemps
  • Créer FileOutputStream

489


origine


Réponses:


Les modèles de code suivants créent un enregistreur et créent 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);

La source.

JUIL

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

399



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} 

METTRE À JOUR: La version Java 7 de ce modèle est la suivante:

${: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
}

47



Mettre en forme une chaîne

MessageFormat - entoure la sélection avec 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 à la chaîne entière (Maj-Alt-Haut), puis deux fois sur Ctrl-Espace.

Verrouille la sélection

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

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

NB ${line_selection} les modèles apparaissent dans le Surround avec menu (Alt-Maj-Z).


30



Je sais que je frappe un poteau mort, mais je voulais partager cela pour mon intérêt:

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

Modèle de création singleton: Nommez ceci createsingleton 

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

25



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

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

24



Ajouter un extrait de code pour itérer 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();
    |
}

Screenshot


22



Null Checks!

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

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

22



Créez un simulacre avec Mockito (dans le contexte "instructions Java"):

${: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 vide pour lancer une exception:

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

Mock une méthode vide 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érifier que la méthode simulée n'est jamais appelée:

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

Nouvelle liste liée 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. Voici un fragment raccourci que tout le monde devrait 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

22



Un de mes bien-aimés est pour chaque:

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

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

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

Je viens de penser à un autre et l'ai trouvé sur Internet un jour, const:

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

21