Ich suche nützliche Eclipse Java-Codevorlagen [geschlossen]

517

Sie können verschiedene Java-Codevorlagen in Eclipse über erstellen

Fenster> Einstellungen> Java> Editor> Vorlagen

z.B

sysout wird erweitert auf:

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

Sie können dies aktivieren, indem Sie sysoutgefolgt von eingebenCTRL+SPACE

Welche nützlichen Java-Codevorlagen verwenden Sie derzeit? Geben Sie den Namen und die Beschreibung an und warum es so toll ist.

Ich suche nach einer originellen / neuartigen Verwendung einer Vorlage anstelle einer integrierten Funktion.

  • Erstellen Sie den Log4J-Logger
  • Holen Sie sich SWT-Farbe vom Display
  • Syncexec - Eclipse Framework
  • Singleton Pattern / Enum Singleton Generation
  • Readfile
  • Const
  • Traceout
  • Zeichenfolge formatieren
  • Kommentar Code Überprüfung
  • String-Format
  • Versuchen Sie schließlich sperren
  • Nachrichtenformat i18n und Protokoll
  • Equalsbuilder
  • Hashcodebuilder
  • Spring Object Injection
  • Erstellen Sie FileOutputStream
Jon
quelle
5
Gibt es welche, die eine switch-Anweisung aus einer Aufzählung mit allen möglichen Fällen generieren? Ich weiß, dass Sie dies mit STRG + 1 tun können, aber ich würde lieber die cmd-Vervollständigung verwenden.
GreenKiwi
4
Können Sie erklären, was System.out.println(${word_selection}${});${cursor}bedeutet? Es hört sich so an, als gäbe es eine Möglichkeit, ein Wort auszuwählen und es automatisch in einen sysoutAnruf einzuschließen. Stimmt das ? Wie?
CodyBugstein
3
Sie markieren das gewünschte Wort, das von einem Sysout-Aufruf umgeben ist, und drücken Strg-Leertaste (geben dann den Namen der Vorlage ein, wenn Sie viele
markierungsbewusste
@JReader was macht das $ {}?
Roland

Antworten:

423

Die folgenden Codevorlagen erstellen sowohl einen Logger als auch bei Bedarf die richtigen Importe.

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

Quelle .

JUL

${:import(java.util.logging.Logger)}
private static final Logger LOG = Logger.getLogger(${enclosing_type}.class.getName());
Robert Munteanu
quelle
31
Cool. Ich wusste nichts über das Ding $ {: import ...}.
JesperE
3
Ich denke, $ {: import ...} funktioniert nur in neueren Versionen von Eclipse. Ich bin mit 3.2 festgefahren und es funktioniert nicht für mich.
Adam Crume
Auch nicht in meiner Version (3.5). Weiß jemand, in welcher Version es eingeführt wurde?
Finnw
5
Ich liebe es! Aber ich habe das $ {import ...} unter die Logger-Deklaration gesetzt, damit keine neue Zeile hinzugefügt wird.
Dario Seidl
1
@TMS - hinzugefügt, danke!
Robert Munteanu
49

Einige zusätzliche Vorlagen hier: Link I - Link II

Ich mag dieses:

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 : Die Java 7-Version dieser Vorlage lautet:

${: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
}
Jon
quelle
48
Ich denke, das ist, was eine Methode ist :)
Benmmurphy
3
Ähm, ich denke, Sie haben den Punkt verpasst ... zu sagen, dass ich eigentlich nicht weiß, was Ihr Punkt ist ... es geht um Codegenerierung, nicht um Modularität ...
Jon
20
Ich denke, der Punkt ist, dass das Hinzufügen von so viel Code in einer Vorlage das Programmieren durch Ausschneiden und Einfügen für eine sehr häufige Situation ist.
Scott McIntyre
5
Ja, Sie sollten eine Dienstprogrammmethode verwenden, um eine Datei zu lesen, anstatt Codeblöcke einzufügen. Schreiben Sie selbst eine Methode oder verwenden Sie Apache commons-io IOUtils. Wenn Sie jedoch viele Wegwerfprojekte mit unterschiedlichen Klassenpfaden erstellen, kann es schwierig sein, eine JAR oder einen Link in Ihre Utility-Klasse einzufügen, um nur eine Datei zu lesen. Manchmal müssen Sie nur einen Wegwerfcode schreiben, der eine Datei liest, und mit Ihrem Leben weitermachen.
Mike Clark
1
In Java 7 lieber StandardCharsets.UTF_8als Charset.forName("UTF-8").
Mike Clark
33

Formatieren Sie eine Zeichenfolge

MessageFormat - Umgibt die Auswahl mit einem MessageFormat.

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

Auf diese Weise kann ich einen Cursor auf eine Zeichenfolge bewegen, die Auswahl auf die gesamte Zeichenfolge erweitern (Umschalt-Alt-Auf) und dann zweimal Strg-Leertaste.

Sperren Sie die Auswahl

sperren - umgeben Sie die ausgewählten Zeilen mit einem Versuch, die Sperre endgültig zu sperren. Nehmen Sie das Vorhandensein einer Sperrvariablen an.

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

NB- ${line_selection}Vorlagen werden im Menü Surround Mit (Alt-Umschalt-Z) angezeigt.

Jamesh
quelle
Ich benutze diese in Kombination mit Protokollanweisungen: logger.info (MessageFormat.format ($ {word_selection}, $ {cursor});
Pierre Henry
Die Methoden zum Erfassen und Freigeben von Sperren heißen lockund unlock. acquireund releasewerden für Semaphoren verwendet, und ihre Verwendung innerhalb eines Try-finally-Blocks wird nicht so dringend empfohlen wie bei Sperren .
Marco Lackovic
Strg + Leertaste zweimal scheint nicht mehr zu funktionieren, ruft SWT-Vorlagen auf. Gibt es einen Ersatz?
Noumenon
28

Ich weiß, dass ich einen toten Pfosten kicke, wollte dies aber zur Vervollständigung teilen:

Eine korrekte Version der Singleton-Generierungsvorlage, die das fehlerhafte, doppelt überprüfte Verriegelungsdesign überwindet (siehe oben und an anderer Stelle erwähnt).

Singleton-Erstellungsvorlage: Nennen Sie diesecreatesingleton

static enum Singleton {
    INSTANCE;

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

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


So greifen Sie auf Singletons zu, die oben generiert wurden:

Singleton-Referenzvorlage: Nennen Sie diese getsingleton:

${type} ${newName} = ${type}.Singleton.INSTANCE.getSingleton();
questzen
quelle
4
Es ist nicht tot, es ist ein Community-Wiki, daher ist es sinnvoll, weitere Vorlagen hinzuzufügen, sobald Sie sie finden. Es gibt nirgendwo anders wirklich einen umfassenden Satz davon ...
Jon
Jon, die Zeitspanne zwischen dem früheren Beitrag und meinem Beitrag betrug fast 8 Monate, das war es, was mich dazu zwang, dies zu zitieren. Ich könnte es nicht besser
formulieren
Wenn ich dies als Teil einer Klasse erstelle (eine verschachtelte Aufzählung in einer Klasse), erhalte ich den Namen der Klasse wie ${enclosing_type}beabsichtigt?
Mr_and_Mrs_D
1
@ Mr_und_Mrs_D, ich denke das ist der Punkt. Sie erhalten eine Singleton-Instanz der Klasse, in die Sie diese Vorlage eingefügt haben. Jetzt müssen Sie nur noch die einschließenden Konstruktoren vom Typ privat machen und über einen ziemlich sicheren Singleton-Generator verfügen.
Mike Adler
Wenn Sie dies verwenden möchten, um eine Aufzählung zu erstellen, verwenden Sie ein ${primary_type_name}Beispiel:public enum ${primary_type_name} { INSTANCE; private ${return_type} ${name} = new ${return_type}(); public ${return_type} ${getName}(${}) { return ${name}; } ${cursor} }
Robert Smit
28

Fügen Sie ein Code-Snippet hinzu, um es zu wiederholen Map.entrySet():

Vorlage:

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

Generierter Code:

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

Bildschirmfoto

mmdemirbas
quelle
1
Wie Ihr Bild zeigt es mir, dass Sie eine Variable in verwenden können ${}und stattdessen ${cursor}die "Tab-Iteration" zwischen Feldern aktivieren. Vielen Dank.
WesternGun
25

Für logein hilfreiches kleines Liedchen, das der Mitgliedsvariablen hinzugefügt werden kann.

private static Log log = LogFactory.getLog(${enclosing_type}.class);
cgp
quelle
Zum manuellen Schreiben in eine Protokolldatei: $ {: import (java.io.PrintWriter, java.io.BufferedWriter, java.io.FileWriter)} try {PrintWriter out = neuer PrintWriter (neuer BufferedWriter (neuer FileWriter ($ {logFile: var (String)}, true))); out.println ($ {logLine: var (String)} $ {cursor}); out.close (); } catch (IOException e) {/ * TODO: Ausnahmebehandlung * / e.printStackTrace (); }
Jack Miller
24

Erstellen Sie einen Mock mit Mockito (im Kontext "Java-Anweisungen"):

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

Und in "Java-Typ-Mitglieder":

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

Verspotten Sie eine void-Methode, um eine Ausnahme auszulösen:

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

Verspotten Sie eine leere Methode, um etwas zu tun:

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

Überprüfen Sie die verspottete Methode, die genau einmal aufgerufen wird:

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

Stellen Sie sicher, dass die verspottete Methode niemals aufgerufen wird:

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

Neue verknüpfte Liste mit Google Guava (und ähnlichem für Hashset und Hashmap):

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

Außerdem verwende ich eine riesige Vorlage, die eine Testklasse generiert. Hier ist ein verkürztes Fragment davon, das jeder Interessierte anpassen sollte:

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
Mantrid
quelle
1
Ich bin neugierig: Warum sollten Sie den Logger verspotten müssen?
Vladimir Sizikov
6
Sie können überprüfen, ob der verspottete Logger aufgerufen wurde, falls eine Ausnahme abgefangen wurde (Fehlerszenario). Dies ist besonders nützlich, wenn Sie nicht beabsichtigen, es erneut zu werfen, sondern behaupten möchten, dass es nicht stillschweigend ignoriert wird.
Mantrid
23

Null Checks!

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

if( ${word_selection} == null ){
    ${cursor}
}
Prashant Bhate
quelle
Die PreConditions.checkNotNull(...)Methode in Guave ist eine sehr lesbare Alternative (insbesondere bei statischen Importen)
Thorbjørn Ravn Andersen
Es wird empfohlen, zuerst nach null (== null) zu suchen, bevor nach nicht null gesucht wird.
KrishPrabakar
21

Einer meiner Geliebten ist foreach :

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

Und Traceout , da ich es häufig zum Tracking verwende:

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

Ich habe gerade an einen anderen gedacht und ihn eines Tages über das Internet gefunden, const :

private static final ${type} ${name} = new ${type} ${cursor};
Artem Barger
quelle
11
foreach ist als Standard-Code-Assistent in Eclipse verfügbar. Ich sehe nicht, dass Ihre Vorlage zusätzliche Funktionen zur Standardversion bietet
Rich Seller
4
Richtig, und sysout ist eine sehr innovative Vorlage. Die Frage betraf nützliche Vorlagen, die wir verwenden.
Artem Barger
4
Ihr traceoutist bereits in Eclipse als verfügbar systrace.
Dogbane
7
Schön, ich möchte glauben, dass es aufgrund dieser Frage jetzt in Eclipse erscheint.
Artem Barger
const ist als Standardcode-Assistent als static_final verfügbar (nicht sicher, wann es hinzugefügt wurde)
Armand
20

Ein kleiner Tipp zu sysout - ich benenne es gerne in "sop" um. Nichts anderes in den Java-Bibliotheken beginnt mit "sop", so dass Sie schnell "sop" eingeben und boomen können.

Scott Stanchfield
quelle
11
Standardmäßig funktioniert die Eingabe von syso genauso wie die Eingabe von sysout.
MasterScrat
9
Schlage dich mit sop um 25% ...;)
Scott Stanchfield
2
Seit Eclipse Mars gibt es einen schlechten Rückschritt bei der Verknüpfung "syso" + Strg + Leertaste : Es werden einige Klassen aufgelistet , deren Namen die Zeichen s, y, s und o enthalten (aufgrund neuer CamelCase-Ergebnisse). Jetzt müssen Sie zusätzlich sysout aus der Liste auswählen und die Eingabetaste drücken.
Bobbel
17

Wirf eine IllegalArgumentException mit einer Variablen im aktuellen Bereich (illarg):

throw new IllegalArgumentException(${var});

Besser

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

Nichts Besonderes für die Codeproduktion - aber sehr nützlich für Codeüberprüfungen

Ich habe meine Vorlage coderev niedrig / med / hoch die folgenden tun

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

Und dann werden in der Aufgabenansicht alle Kommentare zur Codeüberprüfung angezeigt, die ich während eines Meetings aufrufen möchte.

ist_lion
quelle
14

Einige weitere Vorlagen hier .

Beinhaltet:

  • Erstellen Sie ein Datumsobjekt ab einem bestimmten Datum
  • Erstellen Sie eine neue generische ArrayList
  • Logger-Setup
  • Protokollieren Sie mit der angegebenen Ebene
  • Erstellen Sie eine neue generische HashMap
  • Durchlaufen Sie eine Karte, drucken Sie die Schlüssel und Werte
  • Analysieren Sie eine Zeit mit SimpleDateFormat
  • Lesen Sie eine Datei Zeile für Zeile
  • Protokolliere und wirf eine gefangene Ausnahme erneut
  • Druckausführungszeit eines Codeblocks
  • Erstellen Sie einen regelmäßigen Timer
  • Schreiben Sie einen String in eine Datei
lrussell
quelle
fügte eine Wayback-Maschinenverbindung hinzu
berezovskyi
12

slf4j Protokollierung

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

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

Bean-Eigenschaft

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);
}
qualidafial
quelle
10

Nach Java 7 können Sie Logger, die statische Verweise auf die einschließende Klasse benötigen (oder bevorzugen), mithilfe der neu eingeführten MethodHandles-API einrichten, um die Laufzeitklasse in einem statischen Kontext abzurufen.

Ein Beispiel-Snippet für SLF4J ist:

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

Abgesehen davon, dass es sich um ein einfaches Snippet in einer IDE handelt, ist es auch weniger spröde, wenn Sie bestimmte Funktionen in eine andere Klasse umgestalten, da Sie den Klassennamen nicht versehentlich mit sich führen.

Timothy055
quelle
9

Rufen Sie den Code im GUI-Thread auf

Ich binde die folgende Vorlage an die Verknüpfung, slaterum schnell Code im GUI-Thread zu versenden.

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

Beim Testen mit Code habe ich manchmal das Löschen einiger Systeme verpasst . Also habe ich mir eine Vorlage namens syt gemacht .

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

Bevor ich kompiliere, überprüfe ich immer meine TODOs und vergesse nie wieder, ein System.out zu löschen.

Calon
quelle
9

strf -> String.format("msg", args) ziemlich einfach, spart aber ein bisschen Tippen.

String.format("${cursor}",)
pjp
quelle
6
Ich verwende, String.format("${string}",${objects})weil Eclipse es mir ermöglicht, zwischen meiner Zeichenfolge und meiner Liste von Objekten zu wechseln.
Duncan Jones
Ich benutze diese Version: String.format(${word_selection}${},)${cursor}Wählen Sie zuerst einen String aus und verwenden Sie dann 'sf'. Addiere die% s und so weiter ...
Christophe Roussy
8

Holen Sie sich eine SWT-Farbe von der aktuellen Anzeige:

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

Suround mit Syncexec

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

Verwenden Sie das Singleton-Entwurfsmuster:

/**
 * 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;
}
Manuel Selva
quelle
3
Nur eine kurze Anmerkung - Laut dem als Joshua Bloch bekannten Maestro sollte die Verwendung einer Aufzählung die bevorzugte Methode zum Erstellen von Singletons in Java sein.
Pablojim
Hallo Pablojim, seit ich diese Vorlage gepostet habe, lese ich Effective Java und habe meine Singletons-Implementierungen in enum geändert. Trotzdem habe ich keine Möglichkeit gefunden, dass die Vorlage die Aufzählung generiert und damit die Klassendeklaration ändert. Hast du diese Vorlage? Danke Manu
Manuel Selva
Zu Ihrer Information: Hier ist das Enum-Singleton-Muster electrotek.wordpress.com/2008/08/06/… . Ich mag es nicht besonders, aber dann habe ich nicht viele Singletons. Es ist einfach, daraus eine Java-Vorlage zu machen.
pjp
1
Für den Enum-Ansatz hoffe ich, dass alle Ihre Singletons als vergleichbare, serialisierbare Objekte sinnvoll sind, da viele Singletons dies nicht tun (und er fragt sich, warum dieser "... Ansatz noch nicht weit verbreitet ist" - weil Vergleichbarkeit und Serialisierung dies nicht tun Für einige Singleton-Klassen macht das
keinen
Serialisierbar? Ja. Betrachten Sie die Serialisierung eines Objekts mit einem Verweis auf Ihren Singleton. Wenn es nicht serialisierbar ist, kann es zu einer NPE kommen. Wenn dies der Fall ist (und Sie keine Methoden zum Überschreiben der Standard-De-Serialisierung hinzufügen), erhalten Sie möglicherweise eine andere Instanz Ihres "Singleton".
Johannes Kuhn
8

Und eine Equalsbuilder-, Hashcodebuilder-Anpassung:

${: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);
}
Jon
quelle
Für eine Lösung ohne Reflexion siehe meine Antwort unter Link
gswierczynski
8

Die Vorlage für die Logger-Deklaration ist großartig.

Ich erstelle auch linfo, ldebug, lwarn, lerror für die Protokollstufen, die ich häufiger verwende.

Fehler:

logger.error(${word_selection}${});${cursor}
fgui
quelle
8

Erstellen Sie alles für eine Veranstaltung

Da das Erstellen von Ereignissen in Java schwierig ist - all diese Schnittstellen, Methoden und Dinge, die nur für ein Ereignis geschrieben werden müssen -, habe ich eine einfache Vorlage erstellt, um alles zu erstellen, was für ein Ereignis benötigt wird.

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

Wenn Sie Ereignisse haben, die eine einzelne gemeinsam nutzen EventObject, löschen Sie einfach die von der Vorlage eingefügte benutzerdefinierte und ändern Sie die entsprechenden Teile von raise___()und on____().

Ich hatte einen netten, kleinen, eleganten Eventing-Mechanismus mit einer generischen Schnittstelle und einer generischen Klasse geschrieben, aber er würde aufgrund der Art und Weise, wie Java mit Generika umgeht, nicht funktionieren. = (

Bearbeiten : 1) Ich bin auf das Problem gestoßen, bei dem Threads Listener hinzufügten / entfernten, während ein Ereignis stattfand. Das Listkann während der Verwendung nicht geändert werden, daher habe ich synchronizedBlöcke hinzugefügt , in denen auf die Liste der Listener zugegriffen oder diese verwendet werden, und die Liste selbst gesperrt.

Benny Jobigan
quelle
Das Senden von Ereignissen in einer Sperre (synchronisiert oder auf andere Weise) ist ein Deadlock, der darauf wartet, passiert zu werden. In diesem Fall ist es besser, die Listener in einem synchronisierten Block zu kopieren und die neue Liste zu wiederholen.
ssindelar
Verwenden Sie eine ConcurrentLinkedQueue . Es ist kein Sperren erforderlich, da es einen schwach konsistenten Iterator hat, der niemals eine ConcurrentModificationException auslöst.
Stefan Dollase
8

Fügen Sie Testmethoden ein, die wann gegeben sein sollten

Ich habe kürzlich eine ähnliche Version wie diese gesehen, als ich mit einem sehr guten Entwickler und Freund programmiert habe, und ich denke, es könnte eine schöne Ergänzung zu dieser Liste sein.

Diese Vorlage erstellt eine neue Testmethode für eine Klasse, die dem Ansatz "Gegeben - Wann - Dann" aus dem BDD-Paradigma ( Behaviour-Driven Development ) in den Kommentaren als Leitfaden für die Strukturierung des Codes folgt . Der Methodenname wird mit "sollte" gestartet, und Sie können den Rest des Dummy-Methodennamens "CheckThisAndThat" durch die bestmögliche Beschreibung der Verantwortlichkeit der Testmethode ersetzen. Nachdem Sie den Namen eingegeben haben, führt Sie TAB direkt zu // Given section, damit Sie mit der Eingabe Ihrer Voraussetzungen beginnen können.

Ich habe es den drei Buchstaben "tst" zugeordnet, mit der Beschreibung "Testmethoden sollten-wann-dann gegeben werden";)

Ich hoffe, Sie finden es genauso nützlich wie ich, als ich es gesehen habe:

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

    // When


    // Then

}${:import(org.junit.Test, org.junit.Assert)}
MacLuq
quelle
Ich mag diese Vorlage. Ich habe eine "Wurfausnahme" hinzugefügt, um den Testkomfort noch weiter zu vereinfachen.
Torsten
Ich mag das BDD-Paradigma. Sehr schöne Vorlage dafür. Und nur eine Anmerkung: Ihr sehr guter Entwickler und Freund ist weg!
Bobbel
7

Federeinspritzung

Ich weiß, dass dies etwas spät im Spiel ist, aber hier ist eine, die ich für Spring Injection in einer Klasse verwende:

${: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};
}
Mike Clark
quelle
7

Hier ist ein Konstruktor für nicht instanziierbare Klassen:

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

Dieser ist für benutzerdefinierte Ausnahmen:

/**
 * ${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);
    }
}
David M. Coe
quelle
5

Ich mag einen generierten Klassenkommentar wie folgt:

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

Das "Ich ..." ermutigt den Entwickler sofort, zu beschreiben, was die Klasse tut. Ich scheine das Problem des undokumentierten Unterrichts zu verbessern.

Und natürlich ist $ Id $ ein nützliches CVS-Schlüsselwort.

Skaffman
quelle
5

Ich habe diese Snippets häufig verwendet und nach nullWerten und leeren Zeichenfolgen gesucht .

Ich verwende die "Argumenttest" -Vorlagen als ersten Code in meinen Methoden, um empfangene Argumente zu überprüfen.

testNullArgument

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

Möglicherweise möchten Sie die Ausnahmemeldung an den Standard Ihres Unternehmens oder Projekts anpassen. Ich empfehle jedoch eine Nachricht, die den Namen des betreffenden Arguments enthält. Andernfalls muss der Aufrufer Ihrer Methode im Code nachsehen, um zu verstehen, was schief gelaufen ist. (Eine NullPointerExceptionNachricht ohne Nachricht erzeugt eine Ausnahme mit der ziemlich unsinnigen Nachricht "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}");
}

Sie können die Nullprüfungsvorlage auch von oben wiederverwenden und dieses Snippet implementieren, um nur nach leeren Zeichenfolgen zu suchen. Sie würden dann diese beiden Vorlagen verwenden, um den obigen Code zu erzeugen.

Die obige Vorlage hat jedoch das Problem, dass Sie, wenn das in-Argument endgültig ist, den erzeugten Code etwas ändern müssen (das ${varName} = ${varName}.trim()wird fehlschlagen).

Wenn Sie viele endgültige Argumente verwenden und nach leeren Zeichenfolgen suchen möchten, diese aber nicht als Teil Ihres Codes kürzen müssen, können Sie stattdessen Folgendes tun:

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

Ich habe auch einige Snippets zum Überprüfen von Variablen erstellt, die nicht als Argumente gesendet werden (der große Unterschied ist der Ausnahmetyp, der jetzt ein ist 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

Dies ist eine allgemeine Vorlage zum Testen einer Variablen. Ich habe ein paar Jahre gebraucht, um wirklich zu lernen, dieses zu schätzen, jetzt benutze ich es oft (natürlich in Kombination mit den oben genannten Vorlagen!)

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

Sie geben einen Variablennamen oder eine Bedingung ein, die einen Wert zurückgibt, gefolgt von einem Operanden ("==", "<", ">" usw.) und einem anderen Wert oder einer anderen Variablen. Wenn der Test fehlschlägt, löst der resultierende Code eine IllegalArgumentException aus.

Der Grund für die etwas komplizierte if-Klausel mit dem gesamten Ausdruck in einem "! ()" Ist, dass die Testbedingung in der Ausnahmemeldung wiederverwendet werden kann.

Vielleicht verwirrt es einen Kollegen, aber nur, wenn er sich den Code ansehen muss, was er möglicherweise nicht tun muss, wenn Sie solche Ausnahmen auslösen ...

Hier ist ein Beispiel mit Arrays:

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

Sie erhalten dieses Ergebnis, indem Sie die Vorlage aufrufen und "from.length" [TAB] "== to.length" eingeben.

Das Ergebnis ist viel lustiger als eine "ArrayIndexOutOfBoundsException" oder ähnliches und gibt Ihren Benutzern möglicherweise die Möglichkeit, das Problem herauszufinden.

Genießen!

Erk
quelle
4

Ich benutze dies für MessageFormat (mit Java 1.4). Auf diese Weise bin ich sicher, dass ich keine Verkettungen habe, die bei der Internationalisierung schwer zu extrahieren sind

i18n

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

Auch zur Protokollierung:

Log

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

Meine wenigen Favoriten sind ...

1: Javadoc, um ein Dokument über die Methode einzufügen, bei der es sich um eine Spring-Objektinjektionsmethode handelt.

 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: Debug-Fenster, um einen FileOutputStream zu erstellen und den Inhalt des Puffers in eine Datei zu schreiben. Wird verwendet, wenn Sie einen Puffer mit einem früheren Lauf vergleichen möchten (mithilfe von BeyondCompare) oder wenn Sie den Inhalt eines Puffers nicht anzeigen können (über inspect), weil er zu groß ist ...

java.io.FileOutputStream fos = new java.io.FileOutputStream( new java.io.File("c:\\x.x"));
fos.write(buffer.toString().getBytes());
fos.flush();
fos.close();
Jeff Porter
quelle