Alla ricerca di utili modelli di codice Java Eclipse [chiuso]

È possibile creare vari modelli di codice Java in Eclipse tramite

Finestra> Preferenze> Java> Editor> Modelli

per esempio

sysout è espanso a:

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

È possibile attivare questo digitando sysoutseguito daCTRL+SPACE

Quali utili modelli di codice Java usi attualmente? Includi il nome e la descrizione e perché è fantastico.

Sto cercando un uso originale / nuovo di un modello piuttosto che una funzione esistente integrata.

• Crea logger Log4J
• Ottieni colore swt dal display
• Syncexec - Eclipse Framework
• Singleton Pattern / Enum Singleton Generation
• readfile
• const
• Tracciare
• Stringa formato
• Revisione codice commento
• Formato stringa
• Prova finalmente a bloccare
• Formato messaggio i18n e registro
• Equalsbuilder
• Hashcodebuilder
• Iniezione di oggetti a molla
• Crea FileOutputStream

I seguenti modelli di codice creeranno entrambi un logger e creeranno le giuste importazioni, se necessario.

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

Fonte .

luglio

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

Alcuni modelli aggiuntivi qui: Link I - Link II

Mi piace questa:

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} 

AGGIORNAMENTO : la versione Java 7 di questo modello è:

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

Formatta una stringa

MessageFormat: circonda la selezione con un MessageFormat.

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

Questo mi permette di spostare un cursore su una stringa, espandere la selezione sull'intera stringa (Maiusc-Alt-Su), quindi Ctrl-Spazio due volte.

Blocca la selezione

lock - circonda le linee selezionate con un tentativo di bloccare finalmente. Supponi la presenza di una variabile di blocco.

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

NB i ${line_selection}modelli vengono visualizzati nel menu Surround With (Alt-Shift-Z).

So che sto prendendo a calci un post morto, ma volevo condividerlo per amor di completamento:

Una versione corretta del modello di generazione singleton, che supera il design di chiusura a doppio controllo difettoso (discusso sopra e menzionato altrove)

Modello di creazione Singleton: nominalocreatesingleton

static enum Singleton {
    INSTANCE;

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

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

Per accedere ai singoli generati usando sopra:

Modello di riferimento Singleton: Nomina questo getsingleton:

${type} ${newName} = ${type}.Singleton.INSTANCE.getSingleton();

Aggiungi frammento di codice per scorrere su Map.entrySet():

Modello:

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

Codice generato:

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

Per log, un piccolo utile utile da aggiungere nella variabile membro.

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

Crea un finto con Mockito (nel contesto di "Istruzioni Java"):

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

E in "Membri di tipo Java":

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

Derida un metodo vuoto per generare un'eccezione:

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

Deridere un metodo vuoto per fare qualcosa:

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

Verifica il metodo deriso chiamato esattamente una volta:

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

Verifica che il metodo deriso non venga mai richiamato:

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

Nuovo elenco collegato con Google Guava (e simili per hashset e hashmap):

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

Inoltre uso un modello enorme che genera una classe Test. Ecco un frammento abbreviato che tutti gli interessati dovrebbero personalizzare:

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

Uno dei miei amati è foreach :

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

E traceout , poiché lo sto usando molto per il monitoraggio:

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

Ho appena pensato a un altro e l'ho trovato su Internet un giorno, const :

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

Un piccolo consiglio su sysout: mi piace rinominarlo in "sop". Nient'altro nelle librerie Java inizia con "sop" in modo da poter digitare rapidamente "sop" e boom, si inserisce.

Genera un'eccezione IllegalArgumentException con variabile nell'ambito corrente (illarg):

throw new IllegalArgumentException(${var});

Meglio

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

Niente di speciale per la produzione di codice, ma abbastanza utile per le revisioni del codice

Ho il mio modello di codice basso / medio / alto fare quanto segue

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

E poi nella vista Attività - mi mostrerà tutti i commenti di revisione del codice che voglio far apparire durante una riunione.

Alcuni altri modelli qui .

include:

• Crea un oggetto data da una data particolare
• Crea un nuovo ArrayList generico
• Impostazione del logger
• Accedi con il livello specificato
• Crea una nuova HashMap generica
• Scorrere una mappa, stampare chiavi e valori
• Analizzare una volta usando SimpleDateFormat
• Leggi un file riga per riga
• Registra e rilancia un'eccezione colta
• Stampa il tempo di esecuzione di un blocco di codice
• Crea timer periodico
• Scrivi una stringa in un file

slf4j Registrazione

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

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

Proprietà del fagiolo

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

Post Java 7, un ottimo modo per impostare logger che necessitano (o preferiscono) riferimenti statici alla classe che lo racchiude è utilizzare l'API MethodHandles appena introdotta per ottenere la classe di runtime in un contesto statico.

Un frammento di esempio per SLF4J è:

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

Oltre ad essere un semplice frammento in qualsiasi IDE, è anche meno fragile se si refactment di determinate funzionalità in un'altra classe perché non si porta accidentalmente il nome della classe con esso.

Richiamare il codice sul thread della GUI

Associo il seguente modello al collegamento slaterper inviare rapidamente il codice sul thread della GUI.

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

Durante i test con il codice a volte mi mancava l'eliminazione di alcuni syso . Quindi mi sono fatto un modello chiamato syt .

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

Prima di compilare controllo sempre i miei TODO e non dimenticherò mai più di eliminare un System.out.

strf -> String.format("msg", args) piuttosto semplice ma risparmia un po 'di battitura.

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

Ottieni un colore SWT dal display corrente:

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

Circondato da syncexec

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

Usa il modello di progettazione 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;
}

E un equalsbuilder, adattamento di 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);
}

Il modello per la dichiarazione del logger è eccezionale.

Creo anche linfo, ldebug, lwarn, lerror per i livelli di registro che utilizzo più spesso.

lerror:

logger.error(${word_selection}${});${cursor}

Crea tutto per un evento

Dato che gli eventi sono un po 'difficili da creare in Java - tutte quelle interfacce, metodi e cose da scrivere solo per 1 evento - ho creato un modello semplice per creare tutto il necessario per 1 evento.

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

Se hai eventi che condividono un singolo EventObject, elimina quello personalizzato inserito dal modello e modifica le parti appropriate di raise___()eon____() .

Avevo scritto un meccanismo di eventi bello, piccolo ed elegante usando un'interfaccia generica e una classe generica, ma non avrebbe funzionato a causa del modo in cui Java gestisce i generici. = (

Modifica : 1) Mi sono imbattuto nel problema in cui i thread aggiungevano / rimuovevano i listener mentre si stava svolgendo un evento. Il Listnon può essere modificata durante l'uso, così ho aggiunto synchronizedblocchi in cui l'elenco degli ascoltatori l'accesso o usate, bloccaggio nella lista stessa.

Inserisci i metodi di test dovrebbero essere forniti quando

Di recente ho visto una versione simile a questa mentre accoppiavo la programmazione con un ottimo sviluppatore e un amico, e penso che potrebbe essere una bella aggiunta a questo elenco.

Questo modello creerà un nuovo metodo di prova su una classe, seguendo l' approccio Dato - Quando - Allora dal paradigma di sviluppo guidato dal comportamento (BDD) sui commenti, come guida per strutturare il codice. Inizierà il nome del metodo con "should" e ti permetterà di sostituire il resto del nome del metodo fittizio "CheckThisAndThat" con la migliore descrizione possibile della responsabilità del metodo di test. Dopo aver inserito il nome, TAB ti porterà direttamente al// Given section , in modo da poter iniziare a digitare i tuoi presupposti.

L'ho mappato alle tre lettere "tst", con la descrizione "Metodi di prova dovrebbe-dato-quando-allora";)

Spero che lo trovi utile come quando l'ho visto:

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

    // When


    // Then

}${:import(org.junit.Test, org.junit.Assert)}

Iniezione di primavera

So che questo è un po 'tardi per il gioco, ma eccone uno che uso per Spring Injection in una 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};
}

Ecco un costruttore per le classi non istanziabili:

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

Questo è per eccezioni personalizzate:

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

Mi piace un commento di classe generato come questo:

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

"I ..." incoraggia immediatamente lo sviluppatore a descrivere ciò che fa la classe. Mi sembra di migliorare il problema delle classi prive di documenti.

E ovviamente $ Id $ è una parola chiave CVS utile.

Ho cercato molto di questi frammenti, cercandoli null valori e stringhe vuote.

Uso il modello "test argomento" come primo codice nei miei metodi per controllare gli argomenti ricevuti.

testNullArgument

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

È possibile che si desideri modificare il messaggio di eccezione per adattarlo allo standard dell'azienda o del progetto. Tuttavia, raccomando di avere qualche messaggio che includa il nome dell'argomento offensivo. Altrimenti il ​​chiamante del tuo metodo dovrà cercare nel codice per capire cosa è andato storto. (UNNullPointerException senza messaggio produce un'eccezione con il messaggio abbastanza nullo "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}");
}

Puoi anche riutilizzare il modello di controllo null dall'alto e implementare questo frammento per verificare solo le stringhe vuote. Quindi useresti quei due template per produrre il codice sopra.

Il modello precedente, tuttavia, ha il problema che se l'argomento in è final dovrai modificare un po 'il codice prodotto (il ${varName} = ${varName}.trim() fallirà).

Se usi molti argomenti finali e vuoi controllare le stringhe vuote ma non devi tagliarle come parte del tuo codice, puoi invece procedere con questo:

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

Ho anche creato alcuni frammenti per controllare le variabili che non vengono inviate come argomenti (la grande differenza è il tipo di eccezione, ora IllegalStateExceptioninvece un ).

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

Questo è un modello generale per testare una variabile. Mi ci sono voluti alcuni anni per imparare davvero ad apprezzare questo, ora lo uso molto (in combinazione con i modelli sopra ovviamente!)

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

Immettere un nome di variabile o una condizione che restituisce un valore, seguito da un operando ("==", "<", ">" ecc.) E un altro valore o variabile e se il test ha esito negativo il codice risultante genererà un IllegalArgumentException.

Il motivo della clausola if leggermente complicata, con l'intera espressione racchiusa in un "! ()" È di rendere possibile riutilizzare la condizione di test nel messaggio di eccezione.

Forse confonderà un collega, ma solo se devono guardare il codice, cosa che potrebbe non essere necessario se si lanciano questo tipo di eccezioni ...

Ecco un esempio con le matrici:

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

Ottieni questo risultato richiamando il modello, digitando "from.length" [TAB] "== to.length".

Il risultato è molto più divertente di un "ArrayIndexOutOfBoundsException" o simile e può effettivamente dare ai tuoi utenti la possibilità di capire il problema.

Godere!

Lo uso per MessageFormat (usando Java 1.4). In questo modo sono sicuro di non avere concatenazioni difficili da estrarre durante l'internazionalizzazione

i18n

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

Anche per la registrazione:

log

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

I miei pochi preferiti sono ...

1: Javadoc, per inserire doc riguardo al metodo come metodo di iniezione di oggetti 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: finestra di debug, per creare un FileOutputStream e scrivere il contenuto del buffer in un file. Utilizzato per quando si desidera confrontare un buffer con una corsa passata (utilizzando BeyondCompare) o se non è possibile visualizzare il contenuto di un buffer (tramite inspect) perché è troppo grande ...

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