Recherche de modèles de code Eclipse Java utiles
Vous pouvez créer différents 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 sysout suivi de 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.
Je recherche une utilisation originale/novatrice d'un modèle plutôt qu'une fonctionnalité existante intégrée.
- Créer un enregistreur Log4J
- Obtenir la couleur swt de l'affichage
- Syncexec - Cadre Eclipse
- Singleton Pattern/Enum Singleton Génération
- Fichier de lecture
- Const
- Tracer
- Format de chaîne
- Commentaire du code de commentaire
- Format de chaîne
- Essayez enfin de verrouiller
- Format de message i18n et log
- Equalsbuilder
- Hashcodebuilder
- Injection d'objet 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 .
JUL
${: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}
UPDATE: 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
}
Formater 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 sur toute la chaîne (Maj-Alt-Haut), puis deux fois sur Ctrl-Espace.
Verrouiller la sélection
lock - entourez les lignes sélectionnées avec un essai de verrouillage final. Supposons la présence d'une variable de verrouillage.
${lock}.acquire();
try {
${line_selection}
${cursor}
} finally {
${lock}.release();
}
NB ${line_selection} modèles apparaissent dans le menu Surround With (Alt-Shift-Z).
Je sais que je botte un poste mort, mais je voulais partager ceci pour la fin:
Une version correcte du modèle de génération unique, qui surmonte la conception de verrouillage à double vérification défectueuse (discutée ci-dessus et mentionnée ailleurs où)
Singleton Creation Template: Nommez cette 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:
Singleton reference Template: Nommez cette getsingleton:
${type} ${newName} = ${type}.Singleton.INSTANCE.getSingleton();
Ajouter un extrait de code à parcourir sur 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 phrase utile pour ajouter la variable membre.
private static Log log = LogFactory.getLog(${enclosing_type}.class);
Créez une maquette 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 void 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é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 chaîné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 aussi un énorme modèle qui génère une classe de test. En voici un court extrait 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
Null Checks!
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}()");
Je viens de penser à un autre et l'ai trouvé sur Internet un jour, const:
private static final ${type} ${name} = new ${type} ${cursor};
Un petit conseil sur sysout - j'aime bien le renommer "sop". Rien d’autre dans les Java libs ne commence par "sop", vous pouvez donc taper rapidement "sop" et boum, cela s’insère.
Lance une exception IllegalArgumentException avec une variable dans l'étendue actuelle (illarg):
throw new IllegalArgumentException(${var});
Mieux
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
*
*/
Ensuite, dans la vue Tâches, vous verrez tous les commentaires de révision de code que je souhaite faire apparaître lors d'une réunion.
Quelques autres modèles ici .
Comprend:
- Créer un objet de date à partir d'une date particulière
- Créer une nouvelle ArrayList générique
- Configuration de l'enregistreur
- Log avec le niveau spécifié
- Créer un nouveau HashMap générique
- Parcourez une carte, imprimez les clés et les valeurs
- Analyser une heure en utilisant 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
enregistrement slf4j
${imp:import(org.slf4j.Logger,org.slf4j.LoggerFactory)}
private static final Logger LOGGER = LoggerFactory
.getLogger(${enclosing_type}.class);
Post Java 7, un excellent moyen de configurer les enregistreurs qui ont besoin (ou préfèrent) des références statiques à la classe englobante consiste à utiliser la nouvelle API MethodHandles afin d’obtenir la classe d’exécution dans un contexte statique.
Un extrait de code pour SLF4J est:
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
En plus d'être un simple extrait de code 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 celle-ci.
propriété du haricot
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);
}
strf -> String.format("msg", args) assez simple mais enregistre un peu de frappe.
String.format("${cursor}",)
Lors des tests avec du code, je manquais parfois d’effacer des syso s. Alors je me suis fabriqué un modèle appelé syt.
System.out.println(${Word_selection}${});//${todo}:remove${cursor}
Avant de compiler, je vérifie toujours mes TODOs et je n'oublierai jamais de supprimer à nouveau un System.out.
invoquer du code sur le fil de l'interface graphique
Je lie le modèle suivant au raccourci slater pour envoyer rapidement le code sur le thread d'interface graphique.
${:import(javax.swing.SwingUtilities)}
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
${cursor}
}
});
Le modèle pour la déclaration de l'enregistreur est génial.
Je crée également des informations, des mises au point, des alertes et des erreurs pour les niveaux de journalisation que j'utilise plus souvent.
lerror:
logger.error(${Word_selection}${});${cursor}
Obtenir une couleur SWT 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;
}
Insérer les méthodes de test devrait-donné-quand-alors
J'ai récemment vu une version similaire à celle-ci en programmation en couple avec un très bon développeur et ami, et je pense que cela pourrait être un ajout intéressant à cette liste.
Ce modèle créera une nouvelle méthode de test sur une classe, en suivant le paradigme Étant donné - Quand - Alors du paradigme développement guidé par le comportement (BDD) sur les commentaires, en tant que guide pour structurer le code. Le nom de la méthode commence par "devrait" et vous permet 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 saisi le nom, TAB vous mènera directement au // Given section afin que vous puissiez commencer à saisir vos conditions préalables.
Je l'ai mis en correspondance avec les trois lettres "tst", avec la description "Les méthodes de test devraient être données à l'heure indiquée";)
J'espère que vous le trouverez aussi utile que lorsque 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)}
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);
}
Tout créer pour un événement
Comme les événements sont un peu pénibles à créer en Java - toutes ces interfaces, méthodes et éléments à écrire pour un seul événement -, j'ai créé un modèle simple pour créer tout le nécessaire pour un seul é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 joli petit mécanisme élégant utilisant une interface générique et une classe générique, mais cela ne fonctionnerait pas du fait de la façon dont Java traite les génériques. = (
Edit: 1) Je suis tombé sur le problème où les threads ajoutaient/supprimaient des écouteurs alors qu'un événement se déroulait. Le List ne pouvant pas être modifié en cours d'utilisation, j'ai donc ajouté les blocs synchronized où la liste des écouteurs est en cours d'accès ou utilisée, verrouillée sur la liste elle-même.
injection de printemps
Je sais que c'est un peu tard pour le jeu, mais en voici un 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'ai beaucoup utilisé ces extraits, recherchant des valeurs null et des chaînes vides.
J'utilise les modèles "argument test" comme premier code de 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 voudrez peut-être modifier le message d'exception pour l'adapter au standard de votre entreprise ou de votre projet. Cependant, je vous recommande d’avoir un message incluant le nom de l’argument incriminé. Sinon, l'appelant de votre méthode devra chercher dans le code pour comprendre ce qui ne va pas. (Un NullPointerException sans message génère une exception avec le message plutôt absurde "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 contrôle de null ci-dessus et implémenter cet extrait pour vérifier uniquement les chaînes vides. Vous utiliseriez ensuite ces deux modèles pour générer le code ci-dessus.
Le modèle ci-dessus, cependant, pose le problème suivant: 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 voulez vérifier les chaînes vides mais que vous n'avez pas à les couper dans 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 fragments de vérification des variables qui ne sont pas envoyés en tant qu'arguments (la grande différence est le type d'exception, qui est maintenant un IllegalStateException.).
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
Ceci est 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, suivi d'un opérande ("==", "<", ">" etc.) et d'une autre valeur ou variable. Si le test échoue, le code résultant lève 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.
Cela confondra peut-être un collègue, mais seulement s’ils doivent consulter le code, ce qu’ils n’auraient peut-être pas à le faire si vous lancez ce type 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 bien plus amusant qu'un "ArrayIndexOutOfBoundsException" ou similaire et peut en fait donner à vos utilisateurs une chance de comprendre le problème.
Prendre plaisir!
J'aime un commentaire de classe généré comme ceci:
/**
* I...
*
* $Id$
*/
Le "Je ..." encourage immédiatement le développeur à décrire le rôle de la classe. Je semble améliorer le problème des classes non documentées.
Et bien sûr, le $ Id $ est un mot clé CVS utile.
Mes rares préférés sont ...
1: Javadoc, pour insérer un document sur la méthode étant une méthode d'injection d'objet 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é pour 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 inspect) 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();
- public int hashCode ()
- public boolean equals (Object)
Utilisation de tests explicites plutôt que de réflexions plus lentes et susceptibles d’échouer sous un gestionnaire de sécurité ( EqualBuilder javadoc ).
Le modèle contient 20 membres. Vous pouvez les parcourir avec TAB. Une fois terminé, les appels restants à apppend() doivent être supprimés.
${:import(org.Apache.commons.lang.builder.HashCodeBuilder, org.Apache.commons.lang.builder.EqualsBuilder)}
@Override
public int hashCode() {
return new HashCodeBuilder()
.append(${field1:field})
.append(${field2:field})
.append(${field3:field})
.append(${field4:field})
.append(${field5:field})
.append(${field6:field})
.append(${field7:field})
.append(${field8:field})
.append(${field9:field})
.append(${field10:field})
.append(${field11:field})
.append(${field12:field})
.append(${field13:field})
.append(${field14:field})
.append(${field15:field})
.append(${field16:field})
.append(${field17:field})
.append(${field18:field})
.append(${field19:field})
.append(${field20:field})
.toHashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (obj == this) {
return true;
}
if (obj.getClass() != getClass()) {
return false;
}
${enclosing_type} rhs = (${enclosing_type}) obj;
return new EqualsBuilder()
.append(${field1}, rhs.${field1})
.append(${field2}, rhs.${field2})
.append(${field3}, rhs.${field3})
.append(${field4}, rhs.${field4})
.append(${field5}, rhs.${field5})
.append(${field6}, rhs.${field6})
.append(${field7}, rhs.${field7})
.append(${field8}, rhs.${field8})
.append(${field9}, rhs.${field9})
.append(${field10}, rhs.${field10})
.append(${field11}, rhs.${field11})
.append(${field12}, rhs.${field12})
.append(${field13}, rhs.${field13})
.append(${field14}, rhs.${field14})
.append(${field15}, rhs.${field15})
.append(${field16}, rhs.${field16})
.append(${field17}, rhs.${field17})
.append(${field18}, rhs.${field18})
.append(${field19}, rhs.${field19})
.append(${field20}, rhs.${field20})${cursor}
.isEquals();
}
J'utilise ceci pour MessageFormat (en utilisant Java 1.4). De cette façon, je suis sûr de ne pas avoir de concaténations difficiles à extraire lors de l'internationalisation
i18n
String msg = "${message}";
Object[] params = {${params}};
MessageFormat.format(msg, params);
Aussi pour la journalisation:
log
if(logger.isDebugEnabled()){
String msg = "${message}"; //NLS-1
Object[] params = {${params}};
logger.debug(MessageFormat.format(msg, params));
}
Test Hamcrest avec importations statiques
Voici un modèle pour générer les méthodes @Test avec les importations nécessaires de hamcrest, si vous souhaitez utiliser les nouvelles fonctionnalités de JUnit 4.8.2 (assertThat, is, hasItems, etc ...)
@${testType:newType(org.junit.Test)}
public void ${testName}() throws Exception {
// Arrange
${staticImport:importStatic('org.hamcrest.MatcherAssert.*','org.hamcrest.Matchers.*')}${cursor}
// Act
// Assert
}
Je l'ai déjà utilisé plusieurs fois lors de la rédaction de test.
Avec l'aide du plugin: http://code.google.com/p/Eclipse-log-param/
Il est possible d'ajouter le modèle suivant:
logger.trace("${enclosing_method}. ${formatted_method_parameters});
Et obtenir le résultat:
public static void saveUserPreferences(String userName, String[] preferences) {
logger.trace("saveUserPreferences. userName: " + userName + " preferences: " + preferences);
}
J'utilise les modèles suivants pour le développement de Android:
Verbose (Logv)
Log.v(TAG, ${Word_selection}${});${cursor}
Debug (Logd)
Log.d(TAG, ${Word_selection}${});${cursor}
Info (Logi)
Log.i(TAG, ${Word_selection}${});${cursor}
Avertir (Logw)
Log.w(TAG, ${Word_selection}${});${cursor}
Erreur (loge)
Log.e(TAG, ${Word_selection}${});${cursor}
Assert (Loga)
Log.a(TAG, ${Word_selection}${});${cursor}
TAG est une constante que je définis dans chaque activité.
Cela simplifie énormément l'impression/la journalisation des valeurs locales. Il capture automatiquement le nom de la variable dans une chaîne. Cela évite beaucoup de frappe et de correction de frappe.
Le gabarit:
+ ", ${1:var}: " + ${1:var}
Il comporte deux pièges:
Bien que vous soyez invité à sélectionner un champ/paramètre/champ local, cela n'inclut pas les primitives :(
L'invite se produit presque chaque fois que le code est compilé sans erreur. L'utilisation de cette macro génère souvent une syntaxe brisée, il est donc nécessaire de jongler pour insérer plusieurs variables. Rien de proche de la commodité de ne pas avoir de fautes de frappe dans les noms de variables.
Je viens de remarquer que @Duncan Jones possède déjà ce modèle, mais en ajoutant le ${line_selection} et en utilisant Shift + Alt + Z est une tactique utile.
Ceci n’est peut-être utile que comme solution de rechange à un problème de mauvaise conception dans un projet sur lequel je travaille, mais il existe de nombreuses situations dans lesquelles du code hérité modifie des composants Swing hors du thread AWT et provoque des bugs intermittents. pour les corriger rapidement, j'utilise:
${:import(javax.swing.SwingUtilities)}
// Ensure that any Swing components will be invoked only from the AWT thread
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
${line_selection}${cursor}
}
});
Donc, je peux mettre en évidence les déclarations incriminées et utiliser Shift + Alt + Z entourer avec. J'appelle ce modèle swinvoke.
Voici un foreach qui fonctionnera pour une itération sur un List<Stuff>. Le contenu optionnel de la boucle permet de rechercher un élément dans la liste et de le renvoyer.
for (${t:elemType(w)} elem: ${w:collection}) {
if (elem.get.equals(${localVar})){
return elem;
}
}
return null;
Modèles EasyMock
Créer une maquette
${:importStatic(org.easymock.EasyMock.createMock)}
${type} ${name} = createMock(${type}.class);
Réinitialiser Mock
${:importStatic(org.easymock.EasyMock.reset)}
reset(${var});
Replay Mock
${:importStatic(org.easymock.EasyMock.replay)}
replay(${var});
Vérifier la maquette
${:importStatic(org.easymock.EasyMock.verify)}
verify(${var});
Créez un nouveau cas de test JUnit à partir du mot sélectionné:
Cela nécessite un enregistreur (appelé _logger: il existe également un très joli modèle pour cela dans ce fil).
Je suis un grand fan de ce modèle, car il me permet très facilement de créer rapidement des scénarios de test non implémentés dès que je pense à eux. Ils resteront assis là à ne pas me rappeler de l'affaire que je dois examiner.
${:import(org.junit.Test, org.junit.Assert)}
@Test
public void fooTest() throws Throwable {
try {
${cursor}
Assert.fail("Not Implemented");
} catch (Throwable e) {
_logger.error("Failed test", e);
throw e;
}
}
Pour l'utiliser, tapez le nom du scénario de test (par exemple, testSerializeObject), mettez en surbrillance le mot, puis appuyez sur Ctrl + Space (ou ce que vous avez configuré pour l'assistant de code).
Mon modèle favori pour un scénario de test est celui qui enregistre les exceptions, puis les retranscrit, car j'aime les voir dans la console plutôt que dans l'afficheur d'exceptions de JUnit.
Si vous préférez System.out dans vos tests par rapport aux fichiers journaux, vous pouvez toujours utiliser quelque chose de similaire, par exemple:
${:import(org.junit.Test, org.junit.Assert)}
@Test
public void ${Word_selection}() throws Exception {
try {
${cursor}
Assert.fail("Not Implemented");
} catch (Exception e) {
System.out.println("Failed test");
e.printStackTrace();
throw e;
}
}
Section de code
//--------------------------------------------------------------
// ${title}
//--------------------------------------------------------------
${cursor}
Utilisez ce modèle pour faciliter la mise en commentaire de sections de code. ce n'est pas très complexe, mais m'a permis de gagner beaucoup de temps :)
Classe d'écoute interne pour le développement SWT et plugin:
${imports:import(org.Eclipse.swt.widgets.Listener)}
private class ${className} implements Listener{
@Override
public void handleEvent(Event e) {
final Widget w = e.widget;
}
}
list_methods - génère les méthodes pour ajouter, supprimer, compter et contenir une liste
public void add${listname}(${listtype} toAdd){
get${listname}s().add(toAdd);
}
public void remove${listname}(${listtype} toRemove){
get${listname}s().remove(toRemove);
}
public ${listtype} get${listname}(int index){
return get${listname}s().get(index);
}
public int get${listname}Count(){
return get${listname}s().size();
}
public boolean contains${listname}(${listtype} toFind){
return get${listname}s().contains(toFind);
}
${cursor}
id - insère les annotations, les importations, le champ et le getter pour JPA @Id simple
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
public Long getId(){
return id;
}
${cursor}
${:import (javax.persistence.GenerationType,javax.persistence.GeneratedValue,javax.persistence.Id)}
J'ai vu une réponse pour un modèle créant une classe de test de base, et voici quelques appels individuels si vous préférez cette approche:
Créez une méthode setUp avec @Before import
${:import(org.junit.Before)}
@Before
public final void setUp() {
${cursor}
}
Créez une nouvelle méthode de test avec l'importation @Test
${:import(org.junit.Test)}
@Test
public final void test${newName} () {
${cursor}
}
J'utilise ce qui suit pour aider les conversions JAXB entre types et DTO :
Modèle de conversion de la variable existante en type valeur (fonctionne avec le paramètre)
${return_type} ${name} = null;
if (${var} != null) {
${name} = new ${return_type}();
${cursor}
}
return ${name};
Vecteur à tableau
${array_type}[] ${v:var(Vector)}Array = new ${array_type}[${v}.size()];
${v}.copyInto(${v}Array);
Une nouvelle méthode de test JUnit:
@${testType:newType(org.junit.Test)}
public void ${testname}() throws Exception {
${staticImport:importStatic('org.junit.Assert.*')}${cursor}
String expected = "" ;
String actual = "" ;
Assert.assertEquals(expected, actual);
}
Ceci affiche un objet entier (en supposant que vous ayez déjà lancé un objet log4j LOGGER):
${:import(org.codehaus.jackson.map.ObjectMapper)}
// If check to avoid argument evaluation costs
if (LOGGER.isDebugEnabled()) {
try {
LOGGER.debug("Object ${Object}: " + "\n"
+ new ObjectMapper().writeValueAsString(${Object}));
} catch (JsonGenerationException e) {
LOGGER.info(e.toString());
} catch (JsonMappingException e) {
LOGGER.info(e.toString());
} catch (IOException e) {
LOGGER.info(e.toString());
}
}