Buscando modelos de código Java Eclipse úteis [fechado]

516

É possível criar vários modelos de código Java no Eclipse via

Janela> Preferências> Java> Editor> Modelos

por exemplo

sysout é expandido para:

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

Você pode ativar isso digitando sysoutseguido deCTRL+SPACE

Quais modelos de código Java úteis você usa atualmente? Inclua o nome e a descrição dele e por que é incrível.

Estou procurando um uso original / novo de um modelo, em vez de um recurso existente existente.

  • Criar log4J logger
  • Obter cores swt da tela
  • Syncexec - Estrutura Eclipse
  • Padrão Singleton / Enum Singleton Generation
  • Readfile
  • Const
  • Traçar
  • Formatar sequência
  • Revisão do código do comentário
  • Formato da cadeia
  • Tente Finalmente Bloquear
  • Formato de mensagem i18n e log
  • Equalsbuilder
  • Hashcodebuilder
  • Injeção de Objetos de Mola
  • Criar FileOutputStream
Jon
fonte
5
Existe algum que gere uma instrução switch de um Enum com todos os casos possíveis? Eu sei que você pode fazer isso com CTRL + 1, mas prefiro usar a conclusão do cmd.
GreenKiwi
4
Você pode explicar o que System.out.println(${word_selection}${});${cursor}significa? Parece que há uma maneira de selecionar uma palavra e colocá-la automaticamente dentro de uma sysoutchamada, estou certo? Quão?
CodyBugstein
3
realçar a palavra pretendida cercado por chamada sysout e pressione Ctrl-Space (em seguida, digitando o nome do modelo, se você tem um monte de destaque modelos conscientes)
JReader
@JReader, o que o $ {} faz?
Roland

Respostas:

423

Os seguintes modelos de código criarão um criador de logs e as importações corretas, se necessário.

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 .

JULHO

${:import(java.util.logging.Logger)}
private static final Logger LOG = Logger.getLogger(${enclosing_type}.class.getName());
Robert Munteanu
fonte
31
Legal. Eu não sabia sobre a coisa $ {: import ...}.
JesperE
3
Acho que $ {: import ...} só funciona em versões mais recentes do Eclipse. Estou preso com 3.2 e não funciona para mim.
1111 Adam Adamume
Também não está na minha versão (3.5). Alguém sabe em qual versão foi introduzida?
finnw
5
Eu amo isso! Mas coloquei $ {import ...} abaixo da declaração do Logger, para que não adicione uma nova linha.
Dario Seidl
1
@TMS - adicionado, obrigado!
Robert Munteanu 20/05
49

Alguns modelos adicionais aqui: Link I - Link II

Eu gosto deste:

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} 

ATUALIZAÇÃO : A versão Java 7 deste modelo é:

${: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
fonte
48
eu acho que isso é o que um método é para :)
benmmurphy
3
Err Eu acho que você perdeu o ponto ... dizendo que eu realmente não sei o que seu ponto é ... é sobre a geração de código não modularidade ...
Jon
20
Acho que o ponto é que a adição de tanto código em um modelo é uma programação recortar e colar para uma situação muito comum.
10139 Scott McIntyre
5
Sim, você deve usar um método utilitário para ler um arquivo em vez de colar blocos de código. Escreva você mesmo um método ou use IOUtils do Apache commons-io. Ainda assim, se você criar muitos projetos descartáveis ​​com caminhos de classe diferentes, pode ser difícil adicionar um JAR ou link em sua classe de utilitário apenas para ler um arquivo. Às vezes, você só precisa escrever um código descartável que leia um arquivo e seguir com sua vida.
Mike Clark
1
No Java 7, prefira StandardCharsets.UTF_8sobre Charset.forName("UTF-8").
Mike Clark
33

Formatar uma sequência

MessageFormat - envolva a seleção com um MessageFormat.

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

Isso permite que eu mova o cursor para uma string, expanda a seleção para a string inteira (Shift-Alt-Up) e pressione Ctrl-Space duas vezes.

Bloquear a seleção

bloquear - rodeie as linhas selecionadas com uma tentativa de finalmente bloquear. Suponha a presença de uma variável de bloqueio.

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

Os ${line_selection}modelos de notas aparecem no menu Surround With (Alt-Shift-Z).

jamesh
fonte
Eu uso este combinado com declarações de log: logger.info (MessageFormat.format ($ {word_selection}, $ {cursor});
Pierre Henry
Os métodos para adquirir e liberar bloqueios são chamados locke unlock. acquiree releasesão usados ​​para semáforos e seu uso em um bloco try-finally não é tão fortemente recomendado quanto nos bloqueios .
Marco Lackovic
Ctrl + Space duas vezes parece não funcionar mais, exibe modelos SWT. Existe um substituto?
Noumenon
28

Sei que estou chutando um post morto, mas queria compartilhar isso para concluir:

Uma versão correta do modelo de geração de singleton, que supera o design de bloqueio com falha e com verificação dupla (discutido acima e mencionado em outro local)

Modelo de criação de Singleton: Nomeie issocreatesingleton

static enum Singleton {
    INSTANCE;

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

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


Para acessar singletons gerados usando acima:

Referência de Singleton Predefinição: Nome getsingleton:

${type} ${newName} = ${type}.Singleton.INSTANCE.getSingleton();
questzen
fonte
4
Não está morto, é um wiki da comunidade, por isso faz sentido adicionar mais modelos à medida que você os encontra. Não há realmente um conjunto abrangente de estes em qualquer outro lugar ...
Jon
Jon, o intervalo de tempo entre o post anterior e o meu post foi de quase 8 meses, foi o que obrigou a citar isso. Eu não conseguia expressá-lo melhor do que o seu comentário :)
questzen
Quando crio isso como parte de uma classe (um enum aninhado em uma classe), recebo o nome da classe como ${enclosing_type}pretendido?
Mr_and_Mrs_D
1
@Mr_and_Mrs_D, acho que esse é o ponto. Você obtém uma instância singleton da classe na qual você coloca este modelo. Agora tudo que você precisa fazer é tornar o (s) construtor (es) do tipo anexo privado e ter um gerador singleton bastante seguro.
Mike Adler
Se você quiser usar isso para criar um ${primary_type_name}exemplo de uso de enum :public enum ${primary_type_name} { INSTANCE; private ${return_type} ${name} = new ${return_type}(); public ${return_type} ${getName}(${}) { return ${name}; } ${cursor} }
Robert Smit
28

Acrescente o trecho de código para iterar sobre Map.entrySet():

Modelo:

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

Código gerado:

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

Captura de tela

mmdemirbas
fonte
1
Como sua foto, ela me mostra que você pode usar uma variável ${}e que, em vez de ${cursor}, habilita a "iteração de tabulação" entre os campos. Obrigado.
WesternGun 30/08/19
25

Para log, um pouco de talento útil para adicionar na variável de membro.

private static Log log = LogFactory.getLog(${enclosing_type}.class);
cgp
fonte
Para gravar em um arquivo de log manualmente: $ {: import (java.io.PrintWriter, java.io.BufferedWriter, java.io.FileWriter)} tente {PrintWriter out = new PrintWriter (novo BufferedWriter (novo FileWriter ($ {logFile: var (String)}, true))); out.println ($ {logLine: var (String)} $ {cursor}); out.close (); } catch (IOException e) {/ * TODO: tratamento de exceções * / e.printStackTrace (); }
Jack Miller
24

Crie uma simulação com o Mockito (no contexto "Instruções Java"):

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

E em "membros do tipo Java":

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

Zombe de um método nulo para lançar uma exceção:

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

Zombe de um método nulo para fazer algo:

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

Verifique o método simulado chamado exatamente uma vez:

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

Verifique se o método simulado nunca é chamado:

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

Nova lista vinculada usando o Google Guava (e semelhante para hashset e hashmap):

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

Também uso um modelo enorme que gera uma classe de teste. Aqui está um fragmento reduzido que todos os interessados ​​devem personalizar:

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
fonte
1
Estou curioso: por que você precisaria zombar do criador de logs?
Vladimir Sizikov
6
você pode verificar se o logger simulado foi chamado caso uma exceção fosse detectada (cenário de falha). isso é útil em termos espaciais se você não pretende repeti-lo, mas deseja afirmar que não é ignorado silenciosamente.
mantrid
23

Verificações nulas!

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

if( ${word_selection} == null ){
    ${cursor}
}
Prashant Bhate
fonte
O PreConditions.checkNotNull(...)método na goiaba é uma alternativa muito legível (principalmente com importações estáticas)
Thorbjørn Ravn Andersen
É uma prática recomendada verificar nulo (== nulo) antes de verificar se não é nulo.
22414 KrishPrabakar
21

Um dos meus amados é foreach :

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

E rastreio , já que estou usando muito para rastreamento:

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

Eu apenas pensei em outro e encontrei na Internet algum dia, const :

private static final ${type} ${name} = new ${type} ${cursor};
Artem Barger
fonte
11
foreach está disponível como um código padrão auxiliar no Eclipse, não vejo que o modelo faz alguma coisa adicional para a versão standard
Rich Seller
4
Certo, e o sysout é um modelo muito inovador. A pergunta era sobre modelos úteis que estamos usando.
Artem Barger
4
o seu traceoutjá está disponível no Eclipse como systrace.
9788 dogbane
7
Bom, eu quero acreditar que ele aparece agora no Eclipse devido a esta pergunta.
Artem Barger
const está disponível como um código padrão auxiliar como static_final (não tenho certeza quando ele foi adicionado embora)
Armand
20

Uma pequena dica sobre o sysout - eu gosto de mudar o nome para "sop". Nada mais nas bibliotecas java começa com "sop", para que você possa digitar rapidamente "sop" e boom, ele é inserido.

Scott Stanchfield
fonte
11
Por padrão, apenas digitar syso fará o mesmo que sysout.
MasterScrat
9
Bata ya em 25% com sop, embora ...;)
Scott Stanchfield
2
Desde o Eclipse Mars, há um retrocesso ruim no atalho "syso" + Ctrl + Espaço : ele listará algumas classes que possuem os caracteres s, y, se o em seu nome (devido à nova descoberta do CamelCase). Portanto, agora você também deve escolher o sysout da lista e pressionar Retornar.
bobbel
17

Lance uma IllegalArgumentException com variável no escopo atual (illarg):

throw new IllegalArgumentException(${var});

Melhor

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

Nada sofisticado para produção de código - mas bastante útil para revisões de código

Eu tenho o meu coder template baixo / médio / alto, faça o seguinte

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

E, em seguida, na exibição Tarefas - mostrará todos os comentários de revisão de código que desejo trazer durante uma reunião.

ist_lion
fonte
14

Mais alguns modelos aqui .

Inclui:

  • Crie um objeto de data a partir de uma data específica
  • Crie um novo ArrayList genérico
  • Configuração do registrador
  • Log com nível especificado
  • Crie um novo HashMap genérico
  • Itere através de um mapa, imprima as chaves e os valores
  • Analisar uma hora usando SimpleDateFormat
  • Leia um arquivo linha por linha
  • Registrar e repetir uma exceção capturada
  • Tempo de execução de impressão de um bloco de código
  • Criar temporizador periódico
  • Escreva uma String em um arquivo
lrussell
fonte
adicionou um link de máquina de wayback
berezovskyi
12

log do slf4j

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

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

Propriedade Bean

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
fonte
10

Após o Java 7, uma ótima maneira de configurar os registradores que precisam (ou preferem) referências estáticas para a classe envolvente é usar a API MethodHandles recém-introduzida para obter a classe de tempo de execução em um contexto estático.

Um exemplo de snippet para SLF4J é:

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

Além de ser um trecho simples em qualquer IDE, também é menos quebradiço se você refatorar certa funcionalidade em outra classe, porque você não carregará acidentalmente o nome da classe.

Timothy055
fonte
9

Chamar código no encadeamento da GUI

Vinculo o modelo a seguir ao atalho slaterpara despachar rapidamente o código no thread da GUI.

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

Ao testar com o código, às vezes perdi a exclusão de alguns sistemas . Então eu criei um modelo chamado syt .

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

Antes de compilar, sempre verifico meus TODOs e nunca esquecerei de excluir um System.out novamente.

Calon
fonte
9

strf -> String.format("msg", args) bastante simples, mas economiza um pouco de digitação.

String.format("${cursor}",)
pjp
fonte
6
Eu uso String.format("${string}",${objects})porque o Eclipse me permite tabular entre minha string e minha lista de objetos.
Duncan Jones
Eu uso esta versão:, String.format(${word_selection}${},)${cursor}primeiro selecione uma string e use 'sf' nela. Adicione% s e assim por diante ...
Christophe Roussy 28/10
8

Obtenha uma cor SWT na exibição atual:

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

Ao redor com syncexec

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

Use o padrão de design 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
fonte
3
Apenas uma observação rápida - De acordo com o Maestro conhecido como Joshua Bloch, usar um Enum deve ser o método preferido para criar singletons em Java.
Pablojim 02/07/2009
Oi pessoal, Desde que publiquei este modelo, começo a ler Java eficaz e mudei as implementações de singletons para enum. No entanto, não encontrei uma maneira de o modelo gerar a enumeração e modificar a declaração da classe. Você tem este modelo? Obrigado Manu
Manuel Selva
FYI: Aqui está o padrão enum singleton electrotek.wordpress.com/2008/08/06/… . Não gosto particularmente, mas não tenho muitos singletons. É fácil transformar isso em um modelo Java.
pjp
1
Para a abordagem enum, espero que todos os seus singletons façam sentido como objetos comparáveis ​​e serializáveis, porque muitos singletons não (e ele se pergunta por que essa "... abordagem ainda não foi amplamente adotada" - porque a comparabilidade e a serialização não 'faz sentido t para algumas classes únicas)!
MetroidFan2002
Serializável? Sim. Considere a serialização de um objeto com uma referência ao seu Singleton. Se não for serializável, você poderá encontrar um NPE. Se for (e você não adicionar métodos para substituir a desserialização padrão), poderá obter outra instância do seu "Singleton".
Johannes Kuhn
8

E uma adaptação 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
fonte
Para uma solução sem reflexão ver minha resposta abaixo ligação
gswierczynski
8

O modelo para a declaração do criador de logs é ótimo.

Também crio linfo, ldebug, lwarn, lerror para os níveis de log que uso com mais frequência.

lerror:

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

Crie tudo para um evento

Como os eventos são meio difíceis de criar em Java - todas essas interfaces, métodos e outras coisas para escrever apenas para um evento -, criei um modelo simples para criar tudo o que é necessário para um 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 houver eventos que compartilhem um único EventObject, basta excluir o personalizado inserido pelo modelo e alterar as partes apropriadas de raise___()e on____().

Eu escrevi um mecanismo de eventos agradável, pequeno e elegante, usando uma interface genérica e uma classe genérica, mas não funcionou devido à maneira como o Java lida com os genéricos. = (

Edit : 1) Corri para o problema em que tópicos foram adicionando / removendo ouvintes enquanto um evento estava ocorrendo. Como Listnão pode ser modificado enquanto estiver em uso, adicionei synchronizedblocos nos quais a lista de ouvintes está sendo acessada ou usada, bloqueando a própria lista.

Benny Jobigan
fonte
Enviar eventos enquanto estiver em um bloqueio (sincronizado ou não) é um impasse aguardando para acontecer. Nesse caso, seria melhor copiar os ouvintes em um bloco sincronizado e iterar a nova lista.
ssindelar
Use um ConcurrentLinkedQueue . Ele não requer bloqueio, porque possui um iterador fracamente consistente, que nunca gera uma ConcurrentModificationException.
Stefan Dollase
8

Inserir métodos de teste devem ser fornecidos quando e então

Eu vi uma versão semelhante a esta recentemente durante a programação em pares com um desenvolvedor e amigo muito bons, e acho que poderia ser uma boa adição a esta lista.

Este modelo criará um novo método de teste em uma classe, seguindo a abordagem Fornecido quando e depois do paradigma de desenvolvimento orientado a comportamento (BDD) nos comentários, como um guia para estruturar o código. Ele iniciará o nome do método com "should" e permitirá que você substitua o restante do nome do método fictício "CheckThisAndThat" pela melhor descrição possível da responsabilidade do método de teste. Depois de preencher o nome, o TAB o levará diretamente ao // Given section, para que você possa começar a digitar suas pré-condições.

Eu o mapeei para as três letras "tst", com a descrição "Métodos de teste devem ser dados quando então";)

Espero que você ache tão útil quanto eu quando o vi:

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

    // When


    // Then

}${:import(org.junit.Test, org.junit.Assert)}
MacLuq
fonte
Eu gosto desse modelo. Eu adicionei um "Throws Exception" para facilitar um pouco mais o conforto do teste.
Torsten
Eu gosto do paradigma BDD. Modelo muito bom para isso. E apenas uma observação: seu muito bom desenvolvedor e amigo se foi!
bobbel
7

Injeção de mola

Eu sei que isso é meio tarde para o jogo, mas aqui está um que eu uso para o Spring Injection em uma 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};
}
Mike Clark
fonte
7

Aqui está um construtor para classes não instanciadas:

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

Este é para exceções personalizadas:

/**
 * ${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
fonte
5

Eu gosto de um comentário de classe gerado assim:

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

O "eu ..." imediatamente incentiva o desenvolvedor a descrever o que a classe faz. Eu pareço melhorar o problema de classes não documentadas.

E, claro, o $ Id $ é uma palavra-chave útil do CVS.

skaffman
fonte
5

Eu tive muito uso desses trechos, procurando nullvalores e cadeias vazias.

Eu uso os modelos de "teste de argumento" como o primeiro código nos meus métodos para verificar os argumentos recebidos.

testNullArgument

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

Você pode alterar a mensagem de exceção para se ajustar ao padrão da sua empresa ou projeto. No entanto, eu recomendo ter alguma mensagem que inclua o nome do argumento incorreto. Caso contrário, o responsável pela chamada do seu método terá que procurar no código para entender o que deu errado. (A NullPointerExceptionsem mensagem produz uma exceção com a mensagem bastante absurda "nula").

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

Você também pode reutilizar o modelo de verificação nula acima e implementar esse snippet para verificar apenas cadeias vazias. Você usaria esses dois modelos para produzir o código acima.

O modelo acima, no entanto, tem o problema de que, se o argumento in for final, você precisará alterar um pouco o código produzido (o ${varName} = ${varName}.trim()erro irá ocorrer).

Se você usa muitos argumentos finais e deseja procurar por seqüências de caracteres vazias, mas não precisa apará-las como parte do seu código, pode optar por isso:

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

Também criei alguns trechos para verificar variáveis ​​que não são enviadas como argumentos (a grande diferença é o tipo de exceção, agora sendo um 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

Este é um modelo geral para testar uma variável. Levei alguns anos para realmente aprender a apreciar este, agora eu o uso muito (em combinação com os modelos acima, é claro!)

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

Você insere um nome de variável ou uma condição que retorna um valor, seguido por um operando ("==", "<", ">" etc) e outro valor ou variável e, se o teste falhar, o código resultante lançará uma IllegalArgumentException.

O motivo da cláusula if ligeiramente complicada, com toda a expressão envolvida em um "! ()", É possibilitar a reutilização da condição de teste na mensagem de exceção.

Talvez isso confunda um colega, mas apenas se ele precisar examinar o código, o que talvez não seja necessário se você lançar esse tipo de exceção ...

Aqui está um exemplo com matrizes:

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

Você obtém esse resultado acessando o modelo, digitando "from.length" [TAB] "== to.length".

O resultado é muito mais engraçado que um "ArrayIndexOutOfBoundsException" ou semelhante e pode realmente dar aos usuários a chance de descobrir o problema.

Aproveitar!

Erk
fonte
4

Eu uso isso para MessageFormat (usando Java 1.4). Dessa forma, tenho certeza de que não tenho concatenações difíceis de extrair ao fazer a internacionalização

i18n

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

Também para registro:

registro

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

Meus poucos favoritos são ...

1: Javadoc, para inserir um documento sobre o método ser um método de injeção de objeto 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: Janela Debug, para criar um FileOutputStream e gravar o conteúdo do buffer em um arquivo. Utilizado para quando você deseja comparar um buffer com uma execução passada (usando BeyondCompare) ou se não conseguir visualizar o conteúdo de um buffer (via inspecionar) porque é muito 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();
jeff porter
fonte