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

517

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
Jon
źródło
5
Czy są jakieś, które generują instrukcję zamiany z Enum ze wszystkimi możliwymi przypadkami? Wiem, że możesz to zrobić za pomocą CTRL + 1, ale wolę użyć uzupełniania cmd.
GreenKiwi
4
Czy możesz wyjaśnić, co System.out.println(${word_selection}${});${cursor}to znaczy? Wygląda na to, że istnieje sposób na wybranie słowa i automatyczne zamknięcie go w sysoutpołączeniu, prawda? W jaki sposób?
CodyBugstein
3
wyróżniasz słowo, które chcesz otoczyć wywołaniem sysout i naciskasz Ctrl-Space (a następnie wpisujesz nazwę szablonu, jeśli masz wiele szablonów świadomych wyróżniania)
JReader
@JReader, co robi $ {}?
Roland

Odpowiedzi:

423

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());
Robert Munteanu
źródło
31
Fajne. Nie wiedziałem o $ {: import ...}.
JesperE
3
Myślę, że $ {: import ...} działa tylko w nowszych wersjach Eclipse. Utknąłem z wersją 3.2 i to nie działa dla mnie.
Adam Crume,
Nie w mojej wersji (3.5). Czy ktoś wie, w której wersji został wprowadzony?
finnw
5
Kocham to! Ale umieszczam $ {import ...} poniżej deklaracji Logger, aby nie dodawała nowego wiersza.
Dario Seidl
1
@TMS - dodano, dziękuję!
Robert Munteanu,
49

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
}
Jon
źródło
48
myślę, że po to jest metoda :)
benmmurphy
3
Err Myślę, że przegapiłeś ten punkt ... mówiąc, że tak naprawdę nie wiem o co ci chodzi ... chodzi o generowanie kodu, a nie modułowość ...
Jon
20
Myślę, że chodzi o to, że dodanie tak dużej ilości kodu do szablonu to program do wycinania i wklejania w bardzo częstej sytuacji.
Scott McIntyre
5
Tak, zamiast wklejać bloki kodu, należy użyć metody narzędziowej do odczytu pliku. Napisz metodę samodzielnie lub użyj Apache commons-io IOUtils. Mimo to, jeśli wykonujesz wiele niepotrzebnych projektów z różnymi ścieżkami klas, dodanie JAR lub linku w klasie narzędziowej może być uciążliwe tylko do odczytu pliku. Czasami musisz po prostu napisać niepotrzebny kod, który czyta plik i zacząć żyć dalej.
Mike Clark,
1
W Javie 7 preferuj StandardCharsets.UTF_8ponad Charset.forName("UTF-8").
Mike Clark,
33

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

jamesh
źródło
Używam tego w połączeniu z instrukcjami dziennika: logger.info (MessageFormat.format ($ {word_selection}, $ {kursor});
Pierre Henry
Metody uzyskiwania i zwalniania blokad są nazywane locki unlock. acquirei releasesą używane do semaforów, a ich użycie w bloku try-last nie jest tak zalecane jak w przypadku zamków .
Marco Lackovic
Ctrl + spacja dwukrotnie przestaje działać, wyświetla szablony SWT. Czy jest zamiennik?
Noumenon,
28

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();
questzen
źródło
4
Nie jest martwy, to wiki społeczności, więc warto dodawać do niego więcej szablonów, gdy je znajdziesz. Nigdzie indziej nie ma tak naprawdę kompletnego zestawu takich ...
Jon
Jon, odstęp czasu między wcześniejszym postem a moim postem wynosił prawie 8 miesięcy, i to właśnie zmusiło go do cytowania. Nie potrafię tego lepiej sformułować niż twój komentarz :)
questzen
Kiedy tworzę to jako część klasy (zagnieżdżone wyliczenie w klasie), otrzymuję nazwę klasy zgodnie z ${enclosing_type}przeznaczeniem?
Mr_and_Mrs_D
1
@Mr_and_Mrs_D, myślę, że o to chodzi. Otrzymujesz singletonową instancję klasy, w której umieściłeś ten szablon. Teraz wszystko, co musisz zrobić, to ustawić konstruktora typu otaczającego na prywatny i mieć całkiem bezpieczny generator singletonów.
Mike Adler
Jeśli chcesz to wykorzystać, aby utworzyć przykład wyliczenia, użyj ${primary_type_name}:public enum ${primary_type_name} { INSTANCE; private ${return_type} ${name} = new ${return_type}(); public ${return_type} ${getName}(${}) { return ${name}; } ${cursor} }
Robert Smit
28

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

Zrzut ekranu

mmdemirbas
źródło
1
Podobnie jak twoje zdjęcie, pokazuje mi, że możesz użyć zmiennej ${}i że zamiast tego ${cursor}umożliwia „iterację tabulacji” między polami. Dzięki.
WesternGun
25

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

private static Log log = LogFactory.getLog(${enclosing_type}.class);
cgp
źródło
Aby ręcznie zapisać do pliku dziennika: $ {: import (java.io.PrintWriter, java.io.BufferedWriter, java.io.FileWriter)} spróbuj {PrintWriter out = new PrintWriter (nowy BufferedWriter (nowy FileWriter ($ {logFile: var (String)}, true))); out.println ($ {logLine: var (String)} $ {kursor}); out.close (); } catch (IOException e) {/ * TODO: obsługa wyjątków * / e.printStackTrace (); }
Jack Miller
24

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
Mantrid
źródło
1
Jestem ciekawy: dlaczego miałbyś kpić z rejestratora?
Vladimir Sizikov
6
możesz sprawdzić, czy wywołano wyśmiewany program rejestrujący na wypadek przechwycenia wyjątku (scenariusz awarii). jest to szczególnie przydatne, jeśli nie zamierzasz go ponownie rzucać, ale chcesz stwierdzić, że nie jest ono ignorowane w ciszy.
Mantrid
23

Null Checks!

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

if( ${word_selection} == null ){
    ${cursor}
}
Prashant Bhate
źródło
PreConditions.checkNotNull(...)Metoda Guava jest bardzo czytelna alternatywa (zwłaszcza z importu statycznych)
Thorbjørn Ravn Andersen
Najlepszą praktyką jest sprawdzenie najpierw wartości null (== null) przed sprawdzeniem wartości null.
KrishPrabakar
21

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};
Artem Barger
źródło
11
foreach jest dostępny jako standardowa pomoc w kodzie w Eclipse, nie widzę, że Twój szablon robi coś więcej niż standardowa wersja
Rich Seller
4
Racja, a sysout to bardzo innowacyjny szablon. Pytanie dotyczyło użytecznych szablonów, których używamy.
Artem Barger,
4
Twój traceoutjest już dostępny w Eclipse as systrace.
dogbane
7
Fajnie, chcę wierzyć, że pojawia się teraz w Eclipse z powodu tego pytania.
Artem Barger
const jest dostępny jako standardowy asystent kodu jako static_final (choć nie jestem pewien, kiedy został dodany)
Armand
20

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.

Scott Stanchfield
źródło
11
Domyślnie samo wpisanie syso zrobi to samo co sysout.
MasterScrat,
9
Pokonaj cię o 25% z sop, choć ...;)
Scott Stanchfield
2
Od czasu Eclipse Mars krok wstecz „syso” + Ctrl + Spacja jest słaby krok wstecz : wyświetli listę klas, które mają w nazwie znaki s, y, si (ze względu na nowe odkrycie CamelCase). Więc teraz musisz dodatkowo wybrać sysout z listy i nacisnąć Return.
bobbel
17

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

throw new IllegalArgumentException(${var});

Lepszy

throw new IllegalArgumentException("Invalid ${var} " + ${var});  
javaguy
źródło
14

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.

ist_lion
źródło
14

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
lrussell
źródło
dodano link do maszyny powrotnej
berezovskyi
12

slf4j Logowanie

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

private static final Logger LOGGER = LoggerFactory
    .getLogger(${enclosing_type}.class);
Prashant Bhate
źródło
10

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);
}
Qualidafial
źródło
10

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.

Timothy055
źródło
9

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}
      }
    });
Duncan Jones
źródło
9

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.

Calon
źródło
9

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

String.format("${cursor}",)
pjp
źródło
6
Używam, String.format("${string}",${objects})ponieważ Eclipse pozwala mi tabulować między moim ciągiem znaków a moją listą obiektów.
Duncan Jones
Używam tej wersji: String.format(${word_selection}${},)${cursor}najpierw wybierz ciąg, a następnie użyj na nim „sf”. Dodaj% s i tak dalej ...
Christophe Roussy
8

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;
}
Manuel Selva
źródło
3
Krótka uwaga - Według Maestro znanego jako Joshua Bloch przy użyciu Enum powinna być preferowaną metodą tworzenia singletonów w Javie.
Pablojim
Cześć Pablojim, odkąd opublikowałem ten szablon, zacząłem czytać Effective Java i zmieniłem implementacje singletonów na enum. Niemniej jednak nie znalazłem sposobu, aby szablon generował wyliczenie i modyfikował w ten sposób deklarację klasy. Czy masz ten szablon? Dzięki Manu
Manuel Selva
FYI: Oto wzór enum singleton electrotek.wordpress.com/2008/08/06/… . Nie podoba mi się to, ale nie mam wielu singletonów. Łatwo jest zmienić to w szablon Java.
pjp
1
W przypadku podejścia wyliczeniowego mam nadzieję, że wszystkie wasze singletony mają sens jako porównywalne, szeregowalne obiekty, ponieważ wiele singletonów tego nie robi (i zastanawia się, dlaczego to „... podejście nie zostało jeszcze powszechnie przyjęte” - ponieważ nie można porównywać i serializować nie ma sensu w przypadku niektórych lekcji singletonowych!)
MetroidFan2002
Serializowalny? Tak. Rozważ serializację obiektu w odniesieniu do twojego singletona. Jeśli nie można go szeregować, możesz napotkać NPE. Jeśli tak jest (i nie dodajesz metod zastępujących domyślną deserializację), możesz otrzymać inną instancję „Singleton”.
Johannes Kuhn
8

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);
}
Jon
źródło
Aby znaleźć rozwiązanie bez refleksji, zobacz moją odpowiedź poniżej link
gswierczynski
8

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}
fgui
źródło
8

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ę.

Benny Jobigan
źródło
Wysyłanie zdarzeń w trakcie blokady (zsynchronizowanej lub innej) jest impasem, który czeka. W takim przypadku lepiej byłoby skopiować nasłuchiwacze w zsynchronizowanym bloku i iterować nową listę.
ssindelar
Użyj ConcurrentLinkedQueue . Nie wymaga blokowania, ponieważ ma słabo spójny iterator, który nigdy nie zgłasza ConcurrentModificationException.
Stefan Dollase,
8

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)}
MacLuq
źródło
Podoba mi się ten szablon. Dodałem „wyjątek rzucania”, aby jeszcze bardziej poprawić komfort testowania.
Torsten
Podoba mi się paradygmat BDD. Bardzo fajny szablon do tego. I tylko uwaga: twój bardzo dobry programista i przyjaciel zniknął!
bobbel
7

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};
}
Mike Clark
źródło
7

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);
    }
}
David M. Coe
źródło
5

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.

skaffman
źródło
5

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ę!

Erk
źródło
4

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));
}
Mario Ortegón
źródło
4

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();
Jeff Porter
źródło