Wyszukiwanie przydatnych szablonów kodu Java Eclipse [zamknięte]

Możesz tworzyć różne szablony kodu Java w Eclipse poprzez

Okno> Preferencje> Java> Edytor> Szablony

na przykład

sysout jest rozszerzony do:

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

Możesz to aktywować, wpisując, sysouta następnieCTRL+SPACE

Z jakich użytecznych szablonów kodu Java obecnie korzystasz? Podaj jego nazwę i opis oraz dlaczego jest niesamowity.

Szukam oryginalnego / nowatorskiego zastosowania szablonu, a nie wbudowanej istniejącej funkcji.

• Utwórz rejestrator Log4J
• Uzyskaj kolor SWT z wyświetlacza
• Syncexec - środowisko Eclipse
• Singleton Pattern / Enum Singleton Generation
• Plik do odczytu
• Const
• Wyśledzić
• Formatuj ciąg
• Przegląd kodu komentarza
• Format ciągu
• Wypróbuj wreszcie Lock
• Format wiadomości i18n i dziennik
• Equalsbuilder
• Hashcodebuilder
• Spring Object Injection
• Utwórz FileOutputStream

Poniższe szablony kodu utworzą rejestrator i w razie potrzeby utworzą odpowiedni import.

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

Źródło .

LIPIEC

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

Kilka dodatkowych szablonów tutaj: Link I - Link II

Podoba mi się ten:

plik do odczytu

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

AKTUALIZACJA : Wersja tego szablonu Java 7 to:

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

Sformatuj ciąg

MessageFormat - otaczaj zaznaczenie MessageFormat.

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

To pozwala mi przesunąć kursor do łańcucha, rozwinąć zaznaczenie do całego łańcucha (Shift-Alt-Up), a następnie dwa razy Ctrl-Spacja.

Zablokuj wybór

blokada - otaczaj wybrane linie, próbując w końcu zablokować. Załóżmy obecność zmiennej blokującej.

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

${line_selection}Szablony NB pojawiają się w menu Surround With (Alt-Shift-Z).

Wiem, że kopię martwy post, ale chciałem się tym podzielić w celu ukończenia:

Prawidłowa wersja szablonu generowania singletonów, która eliminuje wadliwy projekt podwójnie sprawdzonej blokady (omówiony powyżej i gdzie indziej wspomniany)

Szablon tworzenia singletonów: Nazwij tocreatesingleton

static enum Singleton {
    INSTANCE;

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

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

Aby uzyskać dostęp do singletonów wygenerowanych za pomocą powyższego:

Szablon referencyjny Singleton: Nazwij to getsingleton:

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

Dołącz fragment kodu, aby iterować Map.entrySet() :

Szablon:

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

Wygenerowany kod:

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

Dla logpomocnej małej ditty do dodania do zmiennej członka.

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

Utwórz makietę za pomocą Mockito (w kontekście „instrukcji Java”):

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

I w „członkach typu Java”:

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

Wyśmiewać pustą metodę, aby zgłosić wyjątek:

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

Kpuj z pustej metody, aby coś zrobić:

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

Zweryfikuj próbną metodę o nazwie dokładnie raz:

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

Sprawdź, czy próbowana metoda nigdy nie jest wywoływana:

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

Nowa połączona lista korzystająca z Google Guava (i podobna dla skrótów i skrótów):

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

Używam również ogromnego szablonu, który generuje klasę testową. Oto skrócony fragment, który każdy zainteresowany powinien dostosować:

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

Jednym z moich umiłowanych jest kazanie :

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

I śledzenia , ponieważ często używam go do śledzenia:

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

Właśnie pomyślałem o innym i pewnego dnia znalazłem go w Internecie, const :

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

Mała wskazówka na temat sysout - chciałbym zmienić nazwę na „sop”. Nic innego w bibliotekach Java nie zaczyna się od „sop”, więc możesz szybko wpisać „sop” i boom, wstawia.

Zgłaszaj wyjątek IllegalArgumentException ze zmienną w bieżącym zakresie (illarg):

throw new IllegalArgumentException(${var});

Lepszy

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

Nic szczególnego do tworzenia kodu - ale całkiem przydatne do recenzji kodu

Mam mój szablon coderev low / med / high, wykonaj następujące czynności

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

A potem w widoku Zadania - pokaże mi wszystkie komentarze do przeglądu kodu, które chcę przywołać podczas spotkania.

Więcej szablonów tutaj .

Obejmuje:

• Utwórz obiekt daty z określonej daty
• Utwórz nową ogólną ArrayList
• Konfiguracja rejestratora
• Zaloguj się na określonym poziomie
• Utwórz nową ogólną HashMap
• Iteruj po mapie, wydrukuj klucze i wartości
• Analizuj czas za pomocą SimpleDateFormat
• Czytaj plik linia po linii
• Zaloguj się i ponownie zwróć złapany wyjątek
• Wydrukuj czas wykonania bloku kodu
• Utwórz okresowy licznik czasu
• Napisz ciąg do pliku

slf4j Logowanie

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

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

Własność fasoli

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

Po Javie 7 doskonałym sposobem na skonfigurowanie programów rejestrujących, które potrzebują (lub preferują) statyczne odniesienia do otaczającej klasy, jest użycie nowo wprowadzonego API MethodHandles w celu uzyskania klasy środowiska uruchomieniowego w kontekście statycznym.

Przykładowy fragment kodu dla SLF4J to:

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

Oprócz tego, że jest prostym fragmentem w dowolnym środowisku IDE, jest również mniej kruchy, jeśli przefakturujesz pewną funkcjonalność do innej klasy, ponieważ przypadkowo nie będziesz nosić przy sobie nazwy klasy.

Wywołaj kod w wątku GUI

Wiążę następujący szablon ze skrótem, slateraby szybko wysłać kod w wątku GUI.

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

Podczas testowania kodu czasami pomijałem usunięcie niektórych syso . Zrobiłem sobie szablon o nazwie syt .

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

Przed kompilacją zawsze sprawdzam moje TODO i nigdy nie zapomnę ponownie usunąć pliku System.out.

strf -> String.format("msg", args) dość proste, ale oszczędza trochę pisania.

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

Uzyskaj kolor SWT z bieżącego wyświetlacza:

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

Omówienie z syncexec

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

Użyj wzorca projektowego 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;
}

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

Szablon deklaracji rejestratora jest świetny.

Tworzę również linfo, ldebug, lwarn, lerror dla poziomów dziennika, których używam częściej.

lerror:

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

Stwórz wszystko na wydarzenie

Ponieważ wydarzenia w Java są dość trudne do utworzenia - wszystkie interfejsy, metody i rzeczy do napisania tylko dla jednego zdarzenia - stworzyłem prosty szablon, aby stworzyć wszystko, co potrzebne dla 1 zdarzenia.

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

Jeśli masz zdarzenia, które współużytkują jeden EventObject, po prostu usuń niestandardowe wstawione przez szablon i zmień odpowiednie części raise___()ion____() .

Napisałem ładny, mały, elegancki mechanizm tworzenia zdarzeń za pomocą ogólnego interfejsu i ogólnej klasy, ale nie działałoby to z powodu sposobu, w jaki Java obsługuje ogólne. = (

Edycja : 1) Natknąłem się na problem polegający na dodawaniu / usuwaniu wątków przez słuchaczy podczas wydarzenia. Nie Listmożna go modyfikować podczas używania, więc dodałem synchronizedbloki, w których lista słuchaczy jest otwierana lub używana, blokując samą listę.

Wstaw metody testowe, które należy podać kiedy

Ostatnio widziałem podobną wersję do tej, kiedy programowałem w parę z bardzo dobrym programistą i przyjacielem i myślę, że może to być miły dodatek do tej listy.

Ten szablon utworzy nową metodę testową w klasie, zgodnie z paradygmatem Danych - Kiedy - To, a następnie z rozwoju opartego na zachowaniu (BDD) w komentarzach, jako przewodnika po strukturze kodu. Rozpocznie nazwę metody od „powinien” i pozwoli ci zastąpić resztę nazwy fikcyjnej metody „CheckThisAndThat” najlepszym opisem odpowiedzialności za metodę testową. Po // Given sectionwpisaniu nazwy, TAB zabierze Cię prosto do , więc możesz zacząć wpisywać swoje warunki wstępne.

Mam odwzorowane na trzy litery „tst”, z opisem „Metody testowe należy podać kiedy”;)

Mam nadzieję, że okaże się tak przydatny, jak ja, kiedy go zobaczyłem:

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

    // When


    // Then

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

Wtrysk wiosenny

Wiem, że to trochę za późno na grę, ale oto jeden, którego używam do Spring Injection w klasie:

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

Oto konstruktor dla klas, które nie są możliwe do utworzenia:

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

Ten dotyczy wyjątków niestandardowych:

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

Podoba mi się wygenerowany komentarz klasy w ten sposób:

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

„Ja ...” natychmiast zachęca programistę do opisania tego, co robi klasa. Wydaje się, że poprawiam problem nieudokumentowanych klas.

I oczywiście $ Id $ jest użytecznym słowem kluczowym CVS.

Wiele razy korzystałem z tych fragmentów null wartości i pustych ciągów.

Używam „testu argumentów” - szablonów jako pierwszego kodu w moich metodach do sprawdzania otrzymanych argumentów.

testNullArgument

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

Możesz zmienić komunikat wyjątku, aby pasował do standardu firmy lub projektu. Polecam jednak komunikat zawierający nazwę niepoprawnego argumentu. W przeciwnym razie program wywołujący twoją metodę będzie musiał zajrzeć do kodu, aby zrozumieć, co poszło nie tak. (ZANullPointerException bez komunikatu powoduje wyjątek z dość bezsensownym komunikatem „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}");
}

Możesz również ponownie użyć powyższego szablonu sprawdzania wartości zerowej i zaimplementować ten fragment kodu, aby sprawdzać tylko puste ciągi. Następnie użyjesz tych dwóch szablonów do wygenerowania powyższego kodu.

Powyższy szablon ma jednak problem polegający na tym, że jeśli argument in jest ostateczny, będziesz musiał poprawić wygenerowany kod ( ${varName} = ${varName}.trim() nie powiedzie się).

Jeśli używasz wielu końcowych argumentów i chcesz sprawdzić puste ciągi, ale nie musisz przycinać ich jako części kodu, możesz zamiast tego zrobić to:

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

Stworzyłem również fragmenty do sprawdzania zmiennych, które nie są wysyłane jako argumenty (duża różnica to typ wyjątku, który teraz jest IllegalStateExceptionzamiast niego).

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

Jest to ogólny szablon do testowania zmiennej. Kilka lat zajęło mi naprawdę nauczenie się doceniać ten, teraz go używam (oczywiście w połączeniu z powyższymi szablonami!)

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

Wpisujesz nazwę zmiennej lub warunek, który zwraca wartość, następnie operand („==”, „<”, „>” itd.) I inną wartość lub zmienną, a jeśli test się nie powiedzie, wynikowy kod zgłosi wyjątek IllegalArgumentException.

Przyczyną nieco skomplikowanej klauzuli if, z całym wyrażeniem zawartym w „! ()”, Jest umożliwienie ponownego użycia warunku testowego w komunikacie wyjątku.

Być może wprowadzi to w błąd kolegę, ale tylko wtedy, gdy będzie musiał spojrzeć na kod, czego nie będą musieli, jeśli wprowadzicie tego rodzaju wyjątki ...

Oto przykład z tablicami:

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

Otrzymujesz ten wynik, wywołując szablon, wpisując „from.length” [TAB] „== to.length”.

Rezultat jest o wiele zabawniejszy niż „ArrayIndexOutOfBoundsException” lub podobny i może faktycznie dać użytkownikom szansę rozwiązania problemu.

Cieszyć się!

Używam tego do MessageFormat (przy użyciu Java 1.4). W ten sposób jestem pewien, że nie mam żadnych konkatenacji, które trudno wyodrębnić podczas przeprowadzania internacjonalizacji

i18n

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

Również do logowania:

log

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

Moje ulubione to ...

1: Javadoc, aby wstawić dokument dotyczący metody wstrzykiwania obiektu 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: Okno debugowania, aby utworzyć FileOutputStream i zapisać zawartość bufora w pliku. Używane, gdy chcesz porównać bufor z poprzednim uruchomieniem (używając BeyondCompare) lub jeśli nie możesz wyświetlić zawartości bufora (poprzez inspekcję), ponieważ jest zbyt duży ...

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