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

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

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

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
}

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.

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

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

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

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

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

Null Checks!

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

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

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

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.

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

throw new IllegalArgumentException(${var});

Besser

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

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.

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

slf4j Protokollierung

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

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

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

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.

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

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.

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

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

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

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

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}

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.

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

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

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

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.

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!

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

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