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

É 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

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

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
}

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

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

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

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

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

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

Verificações nulas!

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

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

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

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.

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

throw new IllegalArgumentException(${var});

Melhor

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

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.

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

log do slf4j

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

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

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

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.

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

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.

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

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

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

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

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}

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.

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

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

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

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.

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!

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

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