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


516

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

55
¿Hay alguno que genere una declaración de cambio de Enum con todos los casos posibles? Sé que puedes hacer esto con CTRL + 1, pero prefiero usar cmd complete.
GreenKiwi

44
¿Puedes explicar qué System.out.println(${word_selection}${});${cursor}significa? Parece que hay una manera de seleccionar una palabra y encerrarla automáticamente dentro de una sysoutllamada, ¿estoy en lo cierto? ¿Cómo?
CodyBugstein

3
resalta la palabra que desea rodeada por sysout call y presiona Ctrl-Space (luego escribe el nombre de la plantilla si tiene muchas plantillas destacadas)
JReader

@JReader, ¿qué hace el $ {}?
Roland

Respuestas:


423

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

31
Frio. No sabía sobre la cosa $ {: import ...}.
JesperE

3
Creo que $ {: import ...} solo funciona en versiones más nuevas de Eclipse. Estoy atascado con 3.2 y no me funciona.
Adam Crume

Tampoco en mi versión (3.5). ¿Alguien sabe en qué versión se introdujo?
finnw

55
¡Me encanta! Pero puse el $ {import ...} debajo de la declaración del registrador, para que no agregue una nueva línea.
Dario Seidl

1
@TMS - agregado, ¡gracias!
Robert Munteanu

49

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
}

48
Creo que esto es lo que un método es para :)
benmmurphy

3
Err Creo que has perdido el punto ... diciendo que en realidad no sé lo que su punto es ... se trata de la generación de código no modularidad ...
Jon

20
Creo que el punto es que agregar tanto código en una plantilla es una programación de cortar y pegar para una situación muy común.
Scott McIntyre

55
Sí, debe usar un método de utilidad para leer un archivo en lugar de pegar bloques de código. Escriba un método usted mismo o use Apache commons-io IOUtils. Aún así, si realiza muchos proyectos descartables con diferentes classpaths, puede ser difícil agregar un JAR o un enlace en su clase de utilidad solo para leer un archivo. A veces solo necesitas escribir un código desechable que lea un archivo y seguir con tu vida.
Mike Clark

1
En Java 7, prefiero StandardCharsets.UTF_8sobre Charset.forName("UTF-8").
Mike Clark

33

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


Utilizo este combinado con declaraciones de registro: logger.info (MessageFormat.format ($ {word_selection}, $ {cursor});
Pierre Henry

Los métodos para adquirir y liberar bloqueos se llaman locky unlock. acquirey releasese usan para semáforos y su uso dentro de un bloque try-finally no es tan recomendable como con las cerraduras .
Marco Lackovic

Ctrl + Espacio dos veces ya no parece funcionar, muestra plantillas SWT. ¿Hay un reemplazo?
Noumenon

28

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

44
No está muerto, es una wiki comunitaria, por lo que tiene sentido agregarle más plantillas a medida que las encuentre. No hay realmente un conjunto completo de estos en ningún otro lugar ...
Jon

Jon, el intervalo de tiempo entre la publicación anterior y mi publicación fue de casi 8 meses, eso es lo que obligó a citarlo. No podría expresarlo mejor que tu comentario :)
questzen

Cuando creo esto como parte de una clase (una enumeración anidada en una clase) obtengo el nombre de la clase como estaba ${enclosing_type}previsto.
Mr_and_Mrs_D

1
@Mr_and_Mrs_D, creo que ese es el punto. Obtiene una instancia singleton de la clase en la que coloca esta plantilla. Ahora todo lo que necesita hacer es hacer que los constructores de tipo envolvente sean privados y tener un generador de singleton bastante seguro.
Mike Adler

Si desea utilizar esto para crear un ${primary_type_name}ejemplo de uso de enumeración :public enum ${primary_type_name} { INSTANCE; private ${return_type} ${name} = new ${return_type}(); public ${return_type} ${getName}(${}) { return ${name}; } ${cursor} }
Robert Smit

28

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

Captura de pantalla


1
Al igual que su imagen, me muestra que puede usar una variable ${}y que, en lugar de ${cursor}habilitar la "iteración de tabulación" entre campos. Gracias.
WesternGun

25

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

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

Para escribir en un archivo de registro manualmente: $ {: import (java.io.PrintWriter, java.io.BufferedWriter, java.io.FileWriter)} intente {PrintWriter out = new PrintWriter (new BufferedWriter (new FileWriter ($ {logFile: var (String)}, verdadero))); out.println ($ {logLine: var (String)} $ {cursor}); out.close (); } catch (IOException e) {/ * TODO: manejo de excepciones * / e.printStackTrace (); }
Jack Miller

24

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

1
Tengo curiosidad: ¿por qué necesitarías burlarte del registrador?
Vladimir Sizikov

66
puede verificar que se haya llamado al registrador simulado en caso de que se detectara una excepción (escenario de falla). eso es espacialmente útil si no tiene la intención de volver a lanzarlo pero quiere afirmar que no se ignora en silencio.
mantrid

23

Cheques nulos!

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

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

El PreConditions.checkNotNull(...)método en Guayaba es una alternativa muy legible (especialmente con importaciones estáticas)
Thorbjørn Ravn Andersen

Es una buena práctica verificar nulo (== nulo) primero antes de verificar no nulo.
KrishPrabakar

21

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

11
foreach está disponible como código estándar de asistencia en Eclipse, no veo que la plantilla hace algo adicional a la versión estándar
Rich vendedor

44
Correcto, y sysout es una plantilla muy innovadora. La pregunta era sobre las plantillas útiles que estamos utilizando.
Artem Barger el

44
tu traceoutya está disponible en Eclipse como systrace.
dogbane

77
Bien, quiero creer que aparece ahora en Eclipse debido a esta pregunta.
Artem Barger

const está disponible como un asistente de código estándar como static_final (aunque no estoy seguro de cuándo se agregó)
Armand

20

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.


11
Por defecto, solo escribir syso hará lo mismo que sysout.
MasterScrat

99
Sin embargo, te venció un 25% con sop ...;)
Scott Stanchfield

2
Desde Eclipse Mars, hay un paso hacia atrás pobre en el atajo "syso" + Ctrl + Space : enumerará algunas clases que tienen los caracteres s, y, s y o en su nombre (debido al nuevo hallazgo de CamelCase). Entonces, ahora tiene que elegir adicionalmente sysout de la lista y presionar Volver.
bobbel

17

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

throw new IllegalArgumentException(${var});

Mejor

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

14

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.


14

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

agregó un enlace de máquina wayback
berezovskyi

12

slf4j Logging

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

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

10

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

10

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.


9

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

9

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.


9

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

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

66
Lo uso String.format("${string}",${objects})porque Eclipse me permite tabular entre mi cadena y mi lista de objetos.
Duncan Jones

Yo uso esta versión: String.format(${word_selection}${},)${cursor}primero seleccione una cadena y luego use 'sf' en ella. Agregue el% sy así sucesivamente ...
Christophe Roussy

8

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

3
Solo una nota rápida: según el Maestro conocido como Joshua Bloch, usar un Enum debería ser el método preferido para crear singletons en Java.
Pablojim el

Hola Pablojim, desde que publiqué esta plantilla, comencé a leer Java efectivo y cambié mis implementaciones de singletons a enum. Sin embargo, no encontré una manera de tener la plantilla generando la enumeración y modificando así la declaración de clase. ¿Tienes esta plantilla? Gracias Manu
Manuel Selva

FYI: Aquí está el patrón enton singleton electrotek.wordpress.com/2008/08/06/… . No me gusta particularmente, pero no tengo muchos singletons. Es fácil convertir esto en una plantilla Java.
pjp

1
Para el enfoque de enumeración, espero que todos sus singletons tengan sentido como objetos comparables y serializables, porque muchos Singletons no lo hacen (y se pregunta por qué este "... enfoque aún no se ha adoptado ampliamente", porque la comparabilidad y la serialización no ¡No tiene sentido para algunas clases de singleton!)
MetroidFan2002

Serializable? Si. Considere la serialización de un objeto con una referencia a su Singleton. Si no es serializable, puede encontrar un NPE. Si es así (y no agrega métodos para sobrescribir la deserialización predeterminada), es posible que obtenga otra instancia de su "Singleton".
Johannes Kuhn el

8

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

Para una solución sin reflexión, vea mi respuesta debajo del enlace
gswierczynski

8

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}

8

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.


Enviar eventos mientras está en un bloqueo (sincronizado o no) es un punto muerto a punto de ocurrir. En este caso, sería mejor copiar los oyentes mientras está en un bloque sincronizado e iterando la nueva lista.
ssindelar

Use un ConcurrentLinkedQueue . No requiere bloqueo, porque tiene un iterador débilmente consistente, que nunca arroja una ConcurrentModificationException.
Stefan Dollase

8

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

Me gusta esa plantilla Agregué una "excepción de tiros" para facilitar un poco más la comodidad de la prueba.
Torsten

Me gusta el paradigma BDD. Muy buena plantilla para eso. Y solo una nota: ¡su muy buen desarrollador y amigo se ha ido!
bobbel

7

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

7

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

5

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.


5

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!


4

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

4

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();
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.