Buscando útiles plantillas de código Eclipse Java [cerrado]

Puede crear varias plantillas de código Java en Eclipse a través de

Ventana> Preferencias> Java> Editor> Plantillas

p.ej

sysout se expande a:

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

Puede activar esto escribiendo sysoutseguido deCTRL+SPACE

¿Qué plantillas de código Java útiles utiliza actualmente? Incluya el nombre y la descripción del mismo y por qué es increíble.

Estoy buscando un uso original / novedoso de una plantilla en lugar de una función existente incorporada.

• Crear log4J logger
• Obtenga el color swt de la pantalla
• Syncexec - Marco Eclipse
• Patrón Singleton / Generación Singleton Singleton
• Readfile
• Const
• Trazar
• Cadena de formato
• Comentario de código de revisión
• Formato de cadena
• Intenta finalmente bloquear
• Formato de mensaje i18n y registro
• Equalsbuilder
• Hashcodebuilder
• Inyección de objetos de primavera
• Crear FileOutputStream

Las siguientes plantillas de código crearán un registrador y las importaciones correctas, si es necesario.

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

Fuente .

JUL

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

Algunas plantillas adicionales aquí: Enlace I - Enlace II

Me gusta este:

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} 

ACTUALIZACIÓN : La versión Java 7 de esta plantilla es:

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

Dar formato a una cadena

MessageFormat: rodea la selección con un MessageFormat.

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

Esto me permite mover un cursor a una cadena, expandir la selección a toda la cadena (Mayús-Alt-Arriba), luego Ctrl-Espacio dos veces.

Bloquear la selección

bloquear: rodea las líneas seleccionadas con un intento finalmente bloquear. Suponga la presencia de una variable de bloqueo.

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

Las ${line_selection}plantillas NB aparecen en el menú Surround con (Alt-Shift-Z).

Sé que estoy pateando una publicación muerta, pero quería compartir esto por el bien de la finalización:

Una versión correcta de la plantilla de generación de singleton, que supera el diseño de bloqueo de doble comprobación defectuoso (discutido anteriormente y mencionado en otro lugar)

Plantilla de creación Singleton: asígnele un nombrecreatesingleton

static enum Singleton {
    INSTANCE;

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

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

Para acceder a los singletons generados con el anterior:

Plantilla de referencia Singleton: Nombre esto getsingleton:

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

Agregar fragmento 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 generado:

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

Para log, un poco útil para agregar en la variable miembro.

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

Cree un simulacro con Mockito (en el contexto de "declaraciones Java"):

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

Y en "miembros de tipo Java":

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

Simula un método nulo para lanzar una excepción:

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

Simula un método nulo para hacer 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 el método simulado llamado exactamente una vez:

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

Verifique que el método burlado nunca se invoque:

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

Nueva lista vinculada con Google Guava (y similar para hashset y hashmap):

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

También uso una plantilla enorme que genera una clase de prueba. Aquí hay un fragmento acortado que todos los interesados ​​deben 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

Cheques nulos!

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

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

Uno de mis seres queridos es foreach :

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

Y rastrear , ya que lo estoy usando mucho para el seguimiento:

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

Acabo de pensar en otro y lo he encontrado en Internet algún día, const :

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

Un pequeño consejo sobre sysout: me gusta cambiarle el nombre a "sop". Nada más en las bibliotecas de Java comienza con "sop" para que pueda escribir rápidamente "sop" y boom, se inserta.

Lanza una IllegalArgumentException con variable en el alcance actual (illarg):

throw new IllegalArgumentException(${var});

Mejor

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

Nada sofisticado para la producción de código, pero bastante útil para las revisiones de código

Tengo mi plantilla coderev low / med / high hago lo siguiente

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

Y luego, en la vista Tareas, me mostrará todos los comentarios de revisión de código que quiero mencionar durante una reunión.

Algunas plantillas más aquí .

Incluye:

• Crear un objeto de fecha a partir de una fecha particular
• Cree una nueva ArrayList genérica
• Configuración del registrador
• Iniciar sesión con el nivel especificado
• Crea un nuevo HashMap genérico
• Iterar a través de un mapa, imprimir las claves y los valores.
• Analiza un tiempo usando SimpleDateFormat
• Leer un archivo línea por línea
• Registre y vuelva a lanzar una excepción capturada
• Imprimir el tiempo de ejecución de un bloque de código
• Crear temporizador periódico
• Escribir una cadena en un archivo

slf4j Logging

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

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

Propiedad de frijol

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

Después de Java 7, una excelente manera de configurar los registradores que necesitan (o prefieren) referencias estáticas a la clase adjunta es usar la API MethodHandles recientemente introducida para obtener la clase de tiempo de ejecución en un contexto estático.

Un fragmento de ejemplo para SLF4J es:

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

Además de ser un simple fragmento en cualquier IDE, también es menos frágil si refactoriza cierta funcionalidad en otra clase porque accidentalmente no llevará el nombre de la clase.

Invocar código en el hilo de la GUI

Ato la siguiente plantilla al acceso directo slaterpara enviar rápidamente el código en el hilo de la GUI.

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

Al probar con código, a veces me perdí la eliminación de algunos sistemas . Entonces me hice una plantilla llamada syt .

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

Antes de compilar, siempre reviso mis TODO y nunca me olvidaré de eliminar System.out nuevamente.

strf -> String.format("msg", args) bastante simple pero ahorra un poco de tipeo.

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

Obtenga un color SWT de la pantalla actual:

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

Suround con syncexec

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

Use el patrón de diseño 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;
}

Y una adaptación de igual constructor, 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);
}

La plantilla para la declaración del registrador es excelente.

También creo linfo, ldebug, lwarn, lerror para los niveles de registro que uso con más frecuencia.

lerror:

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

Crea todo para un evento

Como los eventos son un poco difíciles de crear en Java, todas esas interfaces, métodos y cosas para escribir solo para 1 evento, hice una plantilla simple para crear todo lo necesario para 1 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);
    }
}

Si tiene eventos que comparten uno solo EventObject, simplemente elimine el personalizado insertado por la plantilla y cambie las partes apropiadas de raise___()y on____().

Había escrito un mecanismo de eventos agradable, pequeño y elegante usando una interfaz genérica y una clase genérica, pero no funcionaría debido a la forma en que Java maneja los genéricos. = (

Editar : 1) Me encontré con el problema de que los hilos agregaban / eliminaban oyentes mientras se producía un evento. No Listse puede modificar mientras está en uso, por lo que agregué synchronizedbloques donde se accede o usa la lista de oyentes, bloqueando la lista misma.

Insertar los métodos de prueba deberían darse cuando

Vi una versión similar a esta recientemente mientras emparejé la programación con un muy buen desarrollador y amigo, y creo que podría ser una buena adición a esta lista.

Esta plantilla creará un nuevo método de prueba en una clase, siguiendo el enfoque Given - When - Then del paradigma de desarrollo basado en el comportamiento (BDD) en los comentarios, como una guía para estructurar el código. Comenzará el nombre del método con "should" y le permitirá reemplazar el resto del nombre del método ficticio "CheckThisAndThat" con la mejor descripción posible de la responsabilidad del método de prueba. Después de completar el nombre, TAB lo llevará directamente al // Given section, para que pueda comenzar a escribir sus condiciones previas.

Lo he mapeado a las tres letras "tst", con la descripción "Métodos de prueba debería-dado-cuando-entonces";)

Espero que lo encuentres tan útil como lo hice cuando lo vi:

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

    // When


    // Then

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

Inyección de primavera

Sé que esto es un poco tarde para el juego, pero aquí hay uno que uso para Spring Injection en una clase:

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

Aquí hay un constructor para clases no instanciables:

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

Este es para excepciones 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);
    }
}

Me gusta un comentario de clase generado como este:

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

El "yo ..." inmediatamente anima al desarrollador a describir lo que hace la clase. Parece mejorar el problema de las clases indocumentadas.

Y, por supuesto, $ Id $ es una palabra clave CVS útil.

He usado mucho estos fragmentos, buscando nullvalores y cadenas vacías.

Utilizo las plantillas de "prueba de argumento" como primer código en mis métodos para verificar los argumentos recibidos.

testNullArgument

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

Es posible que desee cambiar el mensaje de excepción para que se ajuste al estándar de su empresa o proyecto. Sin embargo, recomiendo tener algún mensaje que incluya el nombre del argumento ofensivo. De lo contrario, la persona que llama de su método tendrá que buscar en el código para entender qué salió mal. (A NullPointerExceptionsin mensaje produce una excepción con el mensaje "sin valor" bastante absurdo).

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

También puede reutilizar la plantilla de comprobación nula desde arriba e implementar este fragmento para verificar solo las cadenas vacías. Luego usaría esas dos plantillas para producir el código anterior.

Sin embargo, la plantilla anterior tiene el problema de que si el argumento in es definitivo, tendrá que modificar el código producido (el ${varName} = ${varName}.trim()error fallará).

Si usa muchos argumentos finales y desea verificar las cadenas vacías pero no tiene que recortarlos como parte de su código, puede ir con esto en su lugar:

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

También creé algunos fragmentos para verificar variables que no se envían como argumentos (la gran diferencia es el tipo de excepción, ahora es un IllegalStateExceptionlugar).

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

pruebaArgumento

Esta es una plantilla general para probar una variable. Me tomó algunos años aprender realmente a apreciar este, ahora lo uso mucho (¡en combinación con las plantillas anteriores, por supuesto!)

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

Ingrese un nombre de variable o una condición que devuelva un valor, seguido de un operando ("==", "<", ">" etc.) y otro valor o variable y si la prueba falla, el código resultante arrojará una IllegalArgumentException.

La razón de la cláusula if un poco complicada, con toda la expresión envuelta en un "! ()" Es para que sea posible reutilizar la condición de prueba en el mensaje de excepción.

Tal vez confundirá a un colega, pero solo si tiene que mirar el código, lo que podría no tener que hacer si arroja este tipo de excepciones ...

Aquí hay un ejemplo con matrices:

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

Obtiene este resultado llamando la plantilla, escribiendo "from.length" [TAB] "== to.length".

El resultado es mucho más divertido que una "ArrayIndexOutOfBoundsException" o similar y puede darles a los usuarios la oportunidad de resolver el problema.

¡Disfrutar!

Lo uso para MessageFormat (usando Java 1.4). De esa manera, estoy seguro de que no tengo concatenaciones que son difíciles de extraer al hacer la internacionalización.

i18n

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

También para iniciar sesión:

Iniciar sesión

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

Mis pocos favoritos son ...

1: Javadoc, para insertar un documento sobre el método que es un método de inyección de objetos 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: Ventana de depuración, para crear un FileOutputStream y escribir el contenido del búfer en un archivo. Se usa para cuando desea comparar un búfer con una ejecución anterior (usando BeyondCompare), o si no puede ver el contenido de un búfer (mediante inspección) porque es demasiado 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();