java - oxygen - eclipse linux
Plantillas útiles de código Java de Eclipse (30)
¡Cheques nulos!
if( ${word_selection} != null ){
${cursor}
}
if( ${word_selection} == null ){
${cursor}
}
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 activarlo escribiendo sysout seguido de CTRL+SPACE
¿Qué plantillas de código Java útiles utilizas actualmente?
Incluya el nombre y la descripción del mismo y por qué es increíble.
Hay una recompensa abierta sobre esto para un uso original / novedoso de una plantilla en lugar de una característica existente incorporada.
- Crear log4J logger
- Obtener color swt de la pantalla
- Syncexec - Eclipse Framework
- Patrón Singleton / Enum Singleton Generation
- Archivo de lectura
- Const
- Trazar
- Cadena de formato
- Comentario del código de comentario
- Formato de cadena
- Probar finalmente bloquear
- Formato de mensaje i18n y registro
- Constructor de iguales
- Hashcodebuilder
- Inyección de objetos de primavera
- Crear FileOutputStream
Crea todo para un evento.
Dado que 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 un único 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 utilizando una interfaz genérica y una clase genérica, pero no funcionaría debido a la forma en que Java maneja los genéricos. = (
Edición : 1) Me encontré con el problema en el que los hilos agregaban / eliminaban escuchas mientras se estaba produciendo un evento. La List no se puede modificar mientras está en uso, así que agregué bloques synchronized donde se accede o se usa la lista de escuchas, bloqueando la lista en sí.
Formatear 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 (Shift-Alt-Up), luego Ctrl-Space dos veces.
Bloquear la selección
bloqueo - rodear las líneas seleccionadas con un intento de bloquear finalmente. Supongamos la presencia de una variable de bloqueo.
${lock}.acquire();
try {
${line_selection}
${cursor}
} finally {
${lock}.release();
}
NB ${line_selection} aparecen plantillas en el menú Surround With (Alt-Shift-Z).
Insertar métodos de prueba debería-dado-cuando-entonces
Hace poco vi una versión similar a esta con la programación en pareja 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 Dados - Cuándo - Luego del paradigma de desarrollo impulsado por el comportamiento (BDD) en los comentarios, como una guía para estructurar el código. Comenzará el nombre del método con "debería" 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 a la // Given section , para que pueda comenzar a escribir sus condiciones previas.
Lo tengo asignado a las tres letras "tst", con la descripción "Métodos de prueba deberían ser dados cuando", "
Espero que lo encuentre 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)}
slf4j logging
${imp:import(org.slf4j.Logger,org.slf4j.LoggerFactory)}
private static final Logger LOGGER = LoggerFactory
.getLogger(${enclosing_type}.class);
Adjunte el 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();
|
}
Al realizar pruebas con el código, a veces me perdía la eliminación de algunos sistemas . Así que me hice una plantilla llamada syt .
System.out.println(${word_selection}${});//${todo}:remove${cursor}
Antes de compilar, siempre verifico mis TODOs y nunca olvidaré eliminar un System.out nuevamente.
Algunas plantillas adicionales aquí: Enlace I - Enlace II
Me gusta este:
archivo de lectura
${: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 de 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
}
Algunas plantillas más here .
Incluye:
- Crear un objeto de fecha a partir de una fecha en particular
- Crear una nueva ArrayList genérica
- Configuración del registrador
- Iniciar sesión con el nivel especificado
- Crear un nuevo HashMap genérico.
- Iterar a través de un mapa, imprimir las claves y valores
- Analizar un tiempo usando SimpleDateFormat
- Leer un archivo línea por línea
- Registrar y volver 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 a un archivo
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);
}
}
Cree un simulacro con Mockito (en el contexto de "declaraciones de 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 vacío 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 vacío 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});
Verificar que el método simulado nunca se invoca:
${:importStatic(org.mockito.Mockito.verify,org.mockito.Mockito.never)}verify(${mock:localVar}, never()).${mockMethod}(${args});
Nueva lista enlazada 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 utilizo una plantilla enorme que genera una clase de prueba. Aquí hay un fragmento reducido de él 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
He usado mucho estos fragmentos, buscando valores null y cadenas vacías.
Utilizo las "pruebas de argumento" como el 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 a su método tendrá que buscar en el código para entender qué salió mal. (Una excepción NullPointerException sin mensaje produce una excepción con el mensaje bastante nulo "null").
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 de código para verificar solo las cadenas vacías. Luego usarías 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 enmendar el código producido (el ${varName} = ${varName}.trim() fallará).
Si usa muchos argumentos finales y desea verificar si hay cadenas vacías pero no tiene que recortarlas como parte de su código, podría usar 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, que ahora es una 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
Esta es una plantilla general para probar una variable. Me tomó unos años aprender realmente a apreciarlo, 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}");
}
Usted ingresa un nombre de variable o una condición que devuelve un valor, seguido de un operando ("==", "<", ">", etc.) y otro valor o variable, y si la prueba falla, el código resultante generará una excepción IllegalArgumentException.
El motivo de la cláusula if, ligeramente complicada, con la expresión completa envuelta en "! ()" Es permitir reutilizar la condición de prueba en el mensaje de excepción.
Tal vez confundirá a un colega, pero solo si tienen que mirar el código, lo que quizás no tengan que hacerlo si lanza 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 a la plantilla, escribiendo "from.length" [TAB] "== to.length".
El resultado es mucho más divertido que una "ArrayIndexOutOfBoundsException" o similar y puede dar a sus usuarios la oportunidad de resolver el problema.
¡Disfrutar!
La plantilla para la declaración del registrador es genial.
También creo linfo, ldebug, lwarn, lerror para los niveles de registro que uso con más frecuencia.
señor
logger.error(${word_selection}${});${cursor}
Lanzar una excepción IllegalArgument con la variable en el alcance actual (illarg):
throw new IllegalArgumentException(${var});
Mejor
throw new IllegalArgumentException("Invalid ${var} " + ${var});
Las siguientes plantillas de código crearán un registrador y crearán 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);
JUL
${:import(java.util.logging.Logger)}
private static final Logger LOG = Logger.getLogger(${enclosing_type}.class.getName());
Lo uso para MessageFormat (utilizando Java 1.4). De esa manera estoy seguro de que no tengo concatenaciones que sean difíciles de extraer al hacer la internacionalización
i18n
String msg = "${message}";
Object[] params = {${params}};
MessageFormat.format(msg, params);
También para el registro:
Iniciar sesión
if(logger.isDebugEnabled()){
String msg = "${message}"; //NLS-1
Object[] params = {${params}};
logger.debug(MessageFormat.format(msg, params));
}
Me gusta un comentario de clase generado como este:
/**
* I...
*
* $Id$
*/
El "yo ..." alienta inmediatamente al desarrollador a describir lo que hace la clase. Parece que mejoro el problema de las clases indocumentadas.
Y, por supuesto, el $ Id $ es una palabra clave de CVS útil.
Nada especial para la producción de códigos, pero bastante útil para las revisiones de códigos.
Tengo mi plantilla coderev low / med / high hacer 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.
Obtén 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}
}
});
Utilice 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;
}
Para log , un ditty poco útil para agregar en la variable miembro.
private static Log log = LogFactory.getLog(${enclosing_type}.class);
Post Java 7, una excelente manera de configurar 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 de código en cualquier IDE, también es menos frágil si refactorizas cierta funcionalidad en otra clase porque no llevarás accidentalmente el nombre de la clase.
Sé que estoy pateando un post muerto, pero quería compartir esto para completar:
Una versión correcta de la plantilla de generación de singleton, que supera el diseño de bloqueo con doble comprobación defectuoso (descrito anteriormente y mencionado en otra parte)
Plantilla de creación de Singleton: nombre este createsingleton
static enum Singleton {
INSTANCE;
private static final ${enclosing_type} singleton = new ${enclosing_type}();
public ${enclosing_type} getSingleton() {
return singleton;
}
}
${cursor}
Para acceder a singletons generados utilizando arriba:
Plantilla de referencia de Singleton: Nombre este getsingleton :
${type} ${newName} = ${type}.Singleton.INSTANCE.getSingleton();
Un pequeño consejo sobre sysout: me gusta cambiarle el nombre a "sop". Nada más en las bibliotecas de Java comienza con "sop", por lo que puede escribir rápidamente "sop" y boom, se inserta.
Uno de mis amados es foreach :
for (${iterable_type} ${iterable_element} : ${iterable}) {
${cursor}
}
Y traceout , ya que lo estoy usando mucho para el seguimiento:
System.out.println("${enclosing_type}.${enclosing_method}()");
Solo pensé en otro y lo encontré en Internet algún día, const :
private static final ${type} ${name} = new ${type} ${cursor};
Y una adaptación de 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);
}
strf -> String.format("msg", args) bastante simple pero ahorra un poco de escritura.
String.format("${cursor}",)
Invocar código en el hilo GUI
Enlace la siguiente plantilla a la lista de accesos directos para 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}
}
});
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};
}
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);
}
Mis pocos favoritos son ...
1: Javadoc, para insertar doc 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 pasada (usando BeyondCompare), o si no puede ver el contenido de un búfer (a través de 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();