Modelos de código Java do Eclipse úteis

Você pode criar vários modelos de código Java no Eclipse por meio de

Janela> Preferências> Java> Editor> Modelos

por exemplo

sysout é expandido para:

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

Você pode ativar isso digitando sysout seguido por CTRL+SPACE

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

Há uma recompensa aberta sobre isso para um uso original / novo de um modelo, em vez de um recurso existente embutido.

  • Criar registrador Log4J
  • Obter cor swt de exibição
  • Syncexec – Eclipse Framework
  • Singleton Pattern / Enum Singleton Generation
  • Readfile
  • Const
  • Traçar
  • Cadeia de formato
  • Revisão do Código de Comentários
  • Formato de string
  • Tente finalmente bloquear
  • Formato de mensagem i18n e log
  • Equalsbuilder
  • Hashcodebuilder
  • Injecção de Objectos de spring
  • Criar FileOutputStream

Os modelos de código a seguir criarão um criador de logs e criarão 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

JUL

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

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

Formatar uma string

MessageFormat – envolve a seleção com um MessageFormat.

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

Isso me permite mover um cursor para uma string, expandir a seleção para a string inteira (Shift-Alt-Up) e depois Ctrl-Space duas vezes.

Bloquear a seleção

lock – rode as linhas selecionadas com uma tentativa, finalmente, bloquear. Assuma a presença de uma variável de bloqueio.

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

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

Eu sei que estou chutando um post morto, mas queria compartilhar isso por causa da conclusão:

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

Modelo de criação de singleton: nomeie esta criação

 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:

Modelo de Referência Singleton: Nomeie este getsingleton :

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

Para log , uma pequena ditty útil para adicionar a variável de membro.

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

Anexar 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 entry : properties.entrySet()) { String key = entry.getKey(); String value = entry.getValue(); | } 

Screenshot

Cheques nulos!

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

Crie um mock com Mockito (no contexto “Java statements”):

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

E em “membros do tipo Java”:

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

Mock um método vazio para lançar uma exceção:

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

Mock um método vazio para fazer alguma coisa:

 ${:import(org.mockito.invocation.InvocationOnMock,org.mockito.stubbing.Answer)}doAnswer(new Answer() { public Object answer(InvocationOnMock invocation) throws Throwable { Object arg1 = invocation.getArguments()[0]; return null; } }).when(${mock:localVar}).${mockedMethod}(${args}); 

Verifique o método de simulação 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 com burlar nunca é chamado:

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

Nova linked list usando o Google Goiaba (e similar 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 class de teste. Aqui está um pequeno fragment 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 

Um dos meus amados é foreach :

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

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

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

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

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

Uma pequena dica no sysout – eu gosto de renomeá-lo para “sop”. Nada mais no java libs começa com “sop” para que você possa rapidamente digitar “sop” e boom, ele insere.

Lançar um IllegalArgumentException com variável no escopo atual (illarg):

 throw new IllegalArgumentException(${var}); 

Melhor

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

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

Eu tenho meu template coderev low / med / high fazer o seguinte

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

E, na visão Tarefas, mostrarei todos os comentários de revisão de código que desejo abordar durante uma reunião.

Mais alguns modelos aqui .

Inclui:

  • Crie um object de data a partir de uma data específica
  • Crie uma nova ArrayList genérica
  • Configuração do registrador
  • Registre com nível especificado
  • Crie um novo HashMap genérico
  • Iterar através de um mapa, imprimir as chaves e valores
  • Analise uma hora usando SimpleDateFormat
  • Leia um arquivo linha por linha
  • Registre e reconteie uma exceção capturada
  • Tempo de execução de impressão de um bloco de código
  • Criar timer periódico
  • Escreva uma String para um arquivo

slf4j Logging

 ${imp:import(org.slf4j.Logger,org.slf4j.LoggerFactory)} private static final Logger LOGGER = LoggerFactory .getLogger(${enclosing_type}.class); 

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

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

Um trecho de exemplo para o SLF4J é:

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

Além de ser um snippet simples em qualquer IDE, também é menos frágil se você refatorar determinada funcionalidade em outra class, porque você não carregará acidentalmente o nome da class nela.

Invocar código no encadeamento da GUI

Eu vinculo o seguinte modelo ao atalho slater para rapidamente despachar código no thread da GUI.

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

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

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

Antes de compilar eu sempre verifico meus TODOs e nunca vou esquecer de excluir um System.out novamente.

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

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

Obter uma cor SWT da exibição atual:

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

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

E um equalsbuilder, adaptação 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); } 

O modelo para a declaração do registrador é ótimo.

Eu também criar linfo, ldebug, lwarn, lerror para os níveis de log que eu uso com mais freqüência.

lerror:

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

Crie tudo para um evento

Como os events são meio difíceis de criar em Java – todas essas interfaces, methods 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 você tiver events que compartilham um único EventObject , apenas exclua o personalizado inserido pelo modelo e altere as partes apropriadas de raise___() e on____() .

Eu tinha escrito um mecanismo de events pequeno, elegante e agradável usando uma interface genérica e uma class genérica, mas isso não funcionaria devido ao modo como o Java lida com os genéricos. = (

Edit : 1) Eu corri para o problema onde os tópicos foram adicionando / removendo ouvintes enquanto um evento estava ocorrendo. A List não pode ser modificada enquanto estiver em uso, então adicionei blocos synchronized onde a lista de ouvintes está sendo acessada ou usada, bloqueando a própria lista.

Inserir methods de teste deve-se-quando-então

Eu vi uma versão semelhante a esta recentemente enquanto programava em pares com um bom desenvolvedor e amigo, e eu acho que poderia ser uma boa adição a esta lista.

Esse modelo criará um novo método de teste em uma class, seguindo a abordagem Given-When-Then do paradigma de desenvolvimento orientado a comportamento (BDD) nos comentários, como um guia para a estruturação do 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 levará você diretamente para a // Given section , para que você possa começar a digitar suas pré-condições.

Eu tenho isso mapeado para as três letras “tst”, com a descrição “Métodos de teste deve-dado-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)} 

Injeção de Mola

Eu sei que isso é meio tarde para o jogo, mas aqui está um que eu uso para Spring Injection em uma class:

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

Aqui está um construtor para classs não instanciáveis:

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

Eu gosto de um comentário de class gerada como este:

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

O “eu …” imediatamente encoraja o desenvolvedor a descrever o que a class faz. Eu pareço melhorar o problema das classs não documentadas.

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

Eu tive um monte de uso desses trechos, procurando por valores null e strings vazias.

Eu uso o “argumento de teste” -templates como o primeiro código em meus methods para verificar argumentos recebidos.

testNullArgument

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

Você pode querer alterar a mensagem de exceção para se adequar ao padrão de sua empresa ou projeto. No entanto, eu recomendo ter alguma mensagem que inclua o nome do argumento ofensivo. Caso contrário, o chamador do seu método terá que procurar no código para entender o que deu errado. (Um NullPointerException sem mensagem produz uma exceção com a mensagem sem sentido “nulo”).

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 de nulos acima e implementar esse snippet para verificar apenas as strings 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ê terá que emendar o código produzido alguns (o ${varName} = ${varName}.trim() falhará).

Se você usar muitos argumentos finais e quiser verificar strings vazias, mas não precisar apará-las como parte do seu código, você poderá usar isto:

 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

Eu também criei alguns trechos para verificar variables ​​que não são enviadas como argumentos (a grande diferença é o tipo de exceção, agora sendo uma 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. Demorei alguns anos para realmente aprender a apreciar este, agora eu 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 emitirá uma IllegalArgumentException.

A razão para a cláusula if ligeiramente complicada, com toda a expressão envolvida em um “! ()”, É tornar possível reutilizar a condição de teste na mensagem de exceção.

Talvez isso confunda um colega, mas somente se eles tiverem que olhar para o código, o que eles podem não precisar 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 chamando o modelo, digitando “from.length” [TAB] “== to.length”.

O resultado é mais engraçado do que um “ArrayIndexOutOfBoundsException” ou similar e pode realmente dar aos seus usuários a chance de descobrir o problema.

Apreciar!

Eu uso isso para MessageFormat (usando o 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)); } 

Meus poucos favoritos são …

1: Javadoc, para inserir doc sobre o método ser um método de injeção de object Spring.

  Method to set the I${enclosing_type} implementation that this class will use. * * @param ${enclosing_method_arguments}I${enclosing_type} instance 

2: Janela de debugging, para criar um FileOutputStream e gravar o conteúdo do buffer em um arquivo. Usado para quando você quer comparar um buffer com uma execução passada (usando BeyondCompare), ou se você não pode ver o conteúdo de um buffer (via inspecionar) porque é muito grande …

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