Вы можете создавать различные шаблоны Java-кода в Eclipse через
Window->Preferences->Java -> Editor -> Templates
например.
sysout
расширяется до:
System.out.println(${word_selection}${});${cursor}
Вы можете активировать это, набрав sysout
, а затем CTRL+SPACE
Какие полезные шаблоны Java-кода вы используете в настоящее время?
Включите имя и описание и почему это потрясающе.
Там есть открытая щедрость для оригинального/нового использования шаблона, а не встроенной существующей функции.
Следующие шаблоны кода будут создавать журнал регистрации и при необходимости создать правильный импорт.
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);
июля
${:import(java.util.logging.Logger)}
private static final Logger LOG = Logger.getLogger(${enclosing_type}.class.getName());
Некоторые дополнительные шаблоны здесь: Ссылка I - Ссылка II
Мне нравится этот:
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}
UPDATE. Версия этого шаблона Java 7:
${: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
}
MessageFormat - окружает выделение с помощью MessageFormat.
${:import(java.text.MessageFormat)}
MessageFormat.format(${word_selection}, ${cursor})
Это позволяет мне перемещать курсор в строку, расширять выделение до всей строки (Shift-Alt-Up), затем дважды Ctrl-Space.
lock - объединить выбранные строки с помощью попытки окончательно заблокировать. Предположим, что имеется блокирующая переменная.
${lock}.acquire();
try {
${line_selection}
${cursor}
} finally {
${lock}.release();
}
NB ${line_selection}
шаблоны отображаются в меню Surround With (Alt-Shift-Z).
unlock
lock
называются lock
и unlock
. acquire
и release
используются для семафоров, и их использование в блоке try-finally не так настоятельно рекомендуется, как с блокировками .
Я знаю, что я пинаю мертвую почту, но хотел поделиться этим ради завершения:
Правильная версия шаблона генерации одноэлементного кода, которая преодолевает ошибочную конструкцию блокировки с двойной проверкой (обсуждается выше и упоминается где-то еще)
Шаблон создания Singleton:
Назовите это createsingleton
static enum Singleton {
INSTANCE;
private static final ${enclosing_type} singleton = new ${enclosing_type}();
public ${enclosing_type} getSingleton() {
return singleton;
}
}
${cursor}
Чтобы получить доступ к синглонам, сгенерированным с использованием вышеперечисленного:
Шаблон ссылки Singleton:
Назовите это getsingleton
:
${type} ${newName} = ${type}.Singleton.INSTANCE.getSingleton();
Для log
, полезной маленькой мелодии для добавления в переменную-член.
private static Log log = LogFactory.getLog(${enclosing_type}.class);
Добавить фрагмент кода для итерации по Map.entrySet()
:
${: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}
}
for (Entry<String, String> entry : properties.entrySet())
{
String key = entry.getKey();
String value = entry.getValue();
|
}
${}
и вместо ${cursor}
включает итерацию табуляции между полями. Благодарю.
Создайте макет с Mockito (в контексте Java-инструкций):
${:importStatic('org.mockito.Mockito.mock')}${Type} ${mockName} = mock(${Type}.class);
И в "членах типа Java":
${:import(org.mockito.Mock)}@Mock
${Type} ${mockName};
Отметьте метод void для исключения исключения: $ {: Импорт (org.mockito.invocation.InvocationOnMock, org.mockito.stubbing.Answer)} doThrow ($ {} RuntimeException.class).При ($ {издеваться: localVar}). ${MockedMethod} ($ {арг });
Откажитесь от метода void, чтобы что-то сделать:
${: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});
Подтвердить метод mocked, который вызывается ровно один раз: $ {: importStatic (org.mockito.Mockito.verify, org.mockito.Mockito.times)} verify ($ {mock: localVar}, times (1)). ${mockMethod} ($ {args});
Проверить, что метод mocked никогда не вызывается:
${:importStatic(org.mockito.Mockito.verify,org.mockito.Mockito.never)}verify(${mock:localVar}, never()).${mockMethod}(${args});
Новый связанный список с помощью Google Guava (и аналогичный для hashset и hashmap):
${import:import(java.util.List,com.google.common.collect.Lists)}List<${T}> ${newName} = Lists.newLinkedList();
Также я использую огромный шаблон, который генерирует класс Test. Вот укороченный фрагмент, который все заинтересованные должны настроить:
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
if( ${word_selection} != null ){
${cursor}
}
if( ${word_selection} == null ){
${cursor}
}
PreConditions.checkNotNull(...)
в Гуаве является очень удобочитаемой альтернативой (особенно при статическом импорте).
Один из моих любимых foreach:
for (${iterable_type} ${iterable_element} : ${iterable}) {
${cursor}
}
И трассировка, так как я много использую для отслеживания:
System.out.println("${enclosing_type}.${enclosing_method}()");
Я только подумал о другом и нашел его через Интернет, const:
private static final ${type} ${name} = new ${type} ${cursor};
Небольшой совет по sysout - мне нравится переименовывать его в "sop" . Ничто другое в java libs не начинается с "sop" , поэтому вы можете быстро ввести "sop" и boom, он вставляет.
Выбросить исключение IllegalArgumentException с переменной в текущей области (illarg):
throw new IllegalArgumentException(${var});
лучше
throw new IllegalArgumentException("Invalid ${var} " + ${var});
Еще несколько шаблонов здесь.
Включает:
Ничего особенного для создания кода - но весьма полезно для обзоров кода
У меня есть мой шаблон coderev low/med/high, сделайте следующее
/**
* Code Review: Low Importance
*
*
* TODO: Insert problem with code here
*
*/
И затем в представлении "Задачи" отобразятся все комментарии к обзору кода, которые я хочу воспитывать во время собрания.
${imp:import(org.slf4j.Logger,org.slf4j.LoggerFactory)}
private static final Logger LOGGER = LoggerFactory
.getLogger(${enclosing_type}.class);
Опубликовать Java 7, отличный способ настроить регистраторы, которые нуждаются (или предпочитают) статические ссылки на класс-класс, - это использовать недавно введенный API MethodHandles, чтобы получить класс выполнения в статическом контексте.
Примерный фрагмент для SLF4J:
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
Помимо простого фрагмента в любой среде IDE, он также менее хрупкий, если вы реорганизовываете определенные функции в другой класс, потому что вы не будете случайно носить с ним имя класса.
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);
}
При тестировании кода я иногда пропустил удаление некоторых syso. Поэтому я сделал себе шаблон с именем syt.
System.out.println(${word_selection}${});//${todo}:remove${cursor}
Прежде чем компилировать, я всегда проверяю свои TODO и никогда не забуду снова удалить System.out.
Вызвать код в потоке графического интерфейса пользователя
Я связываю следующий шаблон с ярлыком slater
, чтобы быстро отправить код в поток графического интерфейса.
${:import(javax.swing.SwingUtilities)}
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
${cursor}
}
});
strf -> String.format("msg", args)
довольно простой, но сохраняет немного ввода.
String.format("${cursor}",)
String.format("${string}",${objects})
потому что Eclipse позволяет мне переключаться между моей строкой и моим списком объектов.
String.format(${word_selection}${},)${cursor}
, сначала выберите строку, а затем используйте 'sf' на ней. Добавьте% s и так далее ...
Я видел аналогичную версию этой недавно, в то время как парное программирование с очень хорошим разработчиком и другом, и я думаю, что это может быть хорошим дополнением к этому списку.
Этот шаблон создаст новый метод тестирования для класса, следуя "Дано - когда - тогда" из поведенческая разработка (BDD) парадигма комментариев, как руководство для структурирования кода. Он запустит имя метода с именем "should" и позволит вам заменить остальную часть имени метода "CheckThisAndThat" с наилучшим описанием ответственности тестового метода. После заполнения имени TAB приведет вас прямо к // Given section
, чтобы вы могли начать вводить свои предварительные условия.
Я сопоставил его с тремя буквами "tst", с описанием "Методы тестирования should-given-when-then";)
Надеюсь, вы сочтете это полезным, как я это сделал, когда увидел:
@Test
public void should${CheckThisAndThat}() {
Assert.fail("Not yet implemented");
// Given
${cursor}
// When
// Then
}${:import(org.junit.Test, org.junit.Assert)}
Так как события кажутся больными для создания в Java - все эти интерфейсы, методы и прочее писать только для одного события - я создал простой шаблон для создания всего, что необходимо для 1 события.
${: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);
}
}
Если у вас есть события, совместно использующие один EventObject
, просто удалите настраиваемый, вставленный шаблоном, и измените соответствующие части raise___()
и on____()
.
Я написал красивый, маленький, элегантный механизм событий, используя общий интерфейс и общий класс, но он не будет работать из-за того, как Java обрабатывает дженерики. = (
Edit:
1) Я столкнулся с проблемой, когда потоки добавляли/удаляли прослушиватели во время события. List
не может быть изменен во время использования, поэтому я добавил блоки synchronized
, в которых осуществляется просмотр или использование списка прослушивателей, блокировка самого списка.
Шаблон для объявления регистратора велик.
Я также создаю linfo, ldebug, lwarn, lerror для уровней журналов, которые я использую чаще.
lerror:
logger.error(${word_selection}${});${cursor}
И 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);
}
Получите цвет SWT с текущего дисплея:
Display.getCurrent().getSystemColor(SWT.COLOR_${cursor})
Suround with syncexec
PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable(){
public void run(){
${line_selection}${cursor}
}
});
Используйте шаблон дизайна синглтона:
/**
* 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;
}
Вот конструктор для неинтересных классов:
// Suppress default constructor for noninstantiability
@SuppressWarnings("unused")
private ${enclosing_type}() {
throw new AssertionError();
}
Это для пользовательских исключений:
/**
* ${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);
}
}
Мне очень понравились эти фрагменты, ища значения null
и пустые строки.
Я использую "test test" -templates в качестве первого кода в моих методах для проверки полученных аргументов.
testNullArgument
if (${varName} == null) {
throw new NullPointerException(
"Illegal argument. The argument cannot be null: ${varName}");
}
Вы можете изменить сообщение об исключении, чтобы оно соответствовало вашей компании или стандарту проекта. Тем не менее, я рекомендую иметь какое-то сообщение, которое включает имя аргумента, вызывающего нарушение. В противном случае вызывающий ваш метод должен будет посмотреть в коде, чтобы понять, что пошло не так. (A NullPointerException
без сообщения создает исключение с довольно бессмысленным сообщением "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}");
}
Вы также можете повторно использовать шаблон проверки нуля сверху и реализовать этот фрагмент, чтобы проверять только пустые строки. Затем вы использовали бы эти два шаблона для создания вышеуказанного кода.
Однако в приведенном выше шаблоне имеется проблема, заключающаяся в том, что если аргумент in final является окончательным, вам придется внести исправление в полученный код (сбой ${varName} = ${varName}.trim()
).
Если вы используете множество окончательных аргументов и хотите проверить пустые строки, но не нужно обрезать их как часть вашего кода, вы можете пойти с этим:
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
Я также создал некоторые фрагменты для проверки переменных, которые не отправляются как аргументы (большая разница - это тип исключения, теперь вместо 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
Это общий шаблон для тестирования переменной. Мне потребовалось несколько лет, чтобы научиться ценить этот, теперь я использую его много (в сочетании с вышеупомянутыми шаблонами, конечно!)
if (!(${varName} ${testExpression})) {
throw new IllegalArgumentException(
"Illegal argument. The argument ${varName} (" + ${varName} + ") " +
"did not pass the test: ${varName} ${testExpression}");
}
Вводите имя переменной или условие, которое возвращает значение, за которым следует операнд ( "==", "<", " > " и т.д.) и другое значение или переменная, и если в результате теста не получается результирующий код бросить исключение IllegalArgumentException.
Причиной немного сложного предложения if с полным выражением, заключенным в "!()", является возможность повторного использования условия теста в сообщении об исключении.
Возможно, это смутит коллегу, но только если им придется посмотреть на код, который им может не понадобиться, если вы выбросите эти исключения...
Вот пример с массивами:
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");
}
}
Вы получаете этот результат, вызывая шаблон, набрав "from.length" [TAB] "== to.length".
Результат намного смелее, чем "ArrayIndexOutOfBoundsException" или аналогичный, и может фактически дать вашим пользователям возможность выяснить проблему.
Наслаждайтесь!
Spring Инъекция
Я знаю, что это довольно поздно в игре, но вот один, который я использую для Spring Injection в классе:
${: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};
}
Мне нравится сгенерированный комментарий класса следующим образом:
/**
* I...
*
* $Id$
*/
"Я..." немедленно побуждает разработчика описать, что делает класс. Кажется, я улучшаю проблему недокументированных классов.
И, конечно, $Id $- полезное ключевое слово CVS.
Использование явных тестов, а не отражение, которое медленнее и может завершиться с ошибкой под диспетчером безопасности (EqualsBuilder javadoc).
Шаблон содержит 20 членов. Вы можете перемещаться по ним с помощью TAB. После завершения оставшиеся вызовы apppend()
должны быть удалены.
${:import(org.apache.commons.lang.builder.HashCodeBuilder, org.apache.commons.lang.builder.EqualsBuilder)}
@Override
public int hashCode() {
return new HashCodeBuilder()
.append(${field1:field})
.append(${field2:field})
.append(${field3:field})
.append(${field4:field})
.append(${field5:field})
.append(${field6:field})
.append(${field7:field})
.append(${field8:field})
.append(${field9:field})
.append(${field10:field})
.append(${field11:field})
.append(${field12:field})
.append(${field13:field})
.append(${field14:field})
.append(${field15:field})
.append(${field16:field})
.append(${field17:field})
.append(${field18:field})
.append(${field19:field})
.append(${field20:field})
.toHashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (obj == this) {
return true;
}
if (obj.getClass() != getClass()) {
return false;
}
${enclosing_type} rhs = (${enclosing_type}) obj;
return new EqualsBuilder()
.append(${field1}, rhs.${field1})
.append(${field2}, rhs.${field2})
.append(${field3}, rhs.${field3})
.append(${field4}, rhs.${field4})
.append(${field5}, rhs.${field5})
.append(${field6}, rhs.${field6})
.append(${field7}, rhs.${field7})
.append(${field8}, rhs.${field8})
.append(${field9}, rhs.${field9})
.append(${field10}, rhs.${field10})
.append(${field11}, rhs.${field11})
.append(${field12}, rhs.${field12})
.append(${field13}, rhs.${field13})
.append(${field14}, rhs.${field14})
.append(${field15}, rhs.${field15})
.append(${field16}, rhs.${field16})
.append(${field17}, rhs.${field17})
.append(${field18}, rhs.${field18})
.append(${field19}, rhs.${field19})
.append(${field20}, rhs.${field20})${cursor}
.isEquals();
}
Мои любимые немногие...
1: Javadoc, чтобы вставить документ о методе, являющемся методом инъекции объекта 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: окно отладки, чтобы создать FileOutputStream и записать содержимое буфера в файл. Используется для сравнения буфера с прошлым запуском (с использованием BeyondCompare) или если вы не можете просматривать содержимое буфера (через проверку), потому что его слишком большой...
java.io.FileOutputStream fos = new java.io.FileOutputStream( new java.io.File("c:\\x.x"));
fos.write(buffer.toString().getBytes());
fos.flush();
fos.close();
Я использую это для MessageFormat (используя Java 1.4). Таким образом, я уверен, что у меня нет конкатенаций, которые трудно извлечь при интернационализации.
i18n
String msg = "${message}";
Object[] params = {${params}};
MessageFormat.format(msg, params);
Также для ведения журнала:
войти
if(logger.isDebugEnabled()){
String msg = "${message}"; //NLS-1
Object[] params = {${params}};
logger.debug(MessageFormat.format(msg, params));
}
Я использую следующие шаблоны для разработки Android:
Подробный (Logv)
Log.v(TAG, ${word_selection}${});${cursor}
Отладка (Logd)
Log.d(TAG, ${word_selection}${});${cursor}
Информация (Logi)
Log.i(TAG, ${word_selection}${});${cursor}
Предупреждение (Logw)
Log.w(TAG, ${word_selection}${});${cursor}
Ошибка (Loge)
Log.e(TAG, ${word_selection}${});${cursor}
Assert (Loga)
Log.a(TAG, ${word_selection}${});${cursor}
TAG - это константа, которую я определяю в каждом действии.
${type:newType(android.util.Log)}
вместо просто Log
он будет обрабатывать импорт для вас, если у вас его еще нет. Также можно шаблонизировать константу TAG
: private static final String TAG = "${enclosing_type}";
С помощью плагина: http://code.google.com/p/eclipse-log-param/
Можно добавить следующий шаблон:
logger.trace("${enclosing_method}. ${formatted_method_parameters});
И получить результат:
public static void saveUserPreferences(String userName, String[] preferences) {
logger.trace("saveUserPreferences. userName: " + userName + " preferences: " + preferences);
}
Здесь шаблон для генерации методов @Test с необходимым импортом hamcrest, если вы хотите использовать новые функции JUnit 4.8.2 (assertThat, is, hasItems и т.д.)
@${testType:newType(org.junit.Test)}
public void ${testName}() throws Exception {
// Arrange
${staticImport:importStatic('org.hamcrest.MatcherAssert.*','org.hamcrest.Matchers.*')}${cursor}
// Act
// Assert
}
Я уже много раз использовал его при написании теста.
Это требует много усилий, чтобы печатать/регистрировать локальные значения. Он автоматически фиксирует имя переменной внутри строки. Это экономит много типизации и опечатки.
Шаблон:
+ ", ${1:var}: " + ${1:var}
У этого есть две подводные камни:
Хотя вам предлагается выбрать локальное/параметрическое/поле, это не включает примитивы: (
Подсказка происходит чаще всего, когда код компилируется без ошибок. Часто использование этого макроса приводит к временному нарушению синтаксиса, поэтому для вставки нескольких переменных требуется некоторое жонглирование. Ничто не близко к удобству отсутствия опечаток в именах переменных.
Я просто заметил, что @Duncan Jones уже имеет этот шаблон, но добавление ${line_selection}
и использование Shift + Alt + Z - полезная тактика.
Это, может быть, полезно только в качестве хакерского исправления для плохого дизайна в проекте, над которым я работаю, но у меня есть много ситуаций, когда какой-то старый код изменяет компоненты Swing из потока AWT и вызывает прерывистый ошибок, поэтому, чтобы быстро исправить их, я использую:
${:import(javax.swing.SwingUtilities)}
// Ensure that any Swing components will be invoked only from the AWT thread
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
${line_selection}${cursor}
}
});
Поэтому я могу выделить заявления о нарушении и использовать Shift + Alt + Z для окружения. Я вызываю этот шаблон swinvoke
.
Раздел кода
//--------------------------------------------------------------
// ${title}
//--------------------------------------------------------------
${cursor}
Используйте этот шаблон, чтобы упростить комментирование разделов кода. он не очень сложный, но сэкономил много времени:)
Создайте новый JUnit тестовый пример из выбранного слова:
Для этого требуется регистратор (называемый _logger: в этом потоке есть очень хороший шаблон).
Я большой поклонник этого шаблона, потому что мне очень легко создать незавершенные тестовые примеры быстро, как только я думаю о них. Они будут сидеть там, не на меня, как напоминание о том, что мне нужно проверить.
${:import(org.junit.Test, org.junit.Assert)}
@Test
public void fooTest() throws Throwable {
try {
${cursor}
Assert.fail("Not Implemented");
} catch (Throwable e) {
_logger.error("Failed test", e);
throw e;
}
}
Чтобы использовать его, введите имя тестового примера (скажем, testSerializeObject), выделите слово и нажмите Ctrl + Space (или все, что вы настроили для помощи по коду).
Моим любимым шаблоном для тестового примера является тот, который регистрирует исключения, а затем пересказывает их, поскольку мне нравится видеть исключения в консоли, а не в средстве просмотра исключений JUnit.
Если вы предпочитаете System.out в своих тестах над файлами журнала, вы всегда можете использовать что-то похожее, например:
${:import(org.junit.Test, org.junit.Assert)}
@Test
public void ${word_selection}() throws Exception {
try {
${cursor}
Assert.fail("Not Implemented");
} catch (Exception e) {
System.out.println("Failed test");
e.printStackTrace();
throw e;
}
}
Здесь a foreach
, который будет работать для итерации над List<Stuff>
. Дополнительный контент внутри цикла - это поиск элемента в списке и его возврат.
for (${t:elemType(w)} elem: ${w:collection}) {
if (elem.get.equals(${localVar})){
return elem;
}
}
return null;
Шаблоны EasyMock
Создать макет
${:importStatic(org.easymock.EasyMock.createMock)}
${type} ${name} = createMock(${type}.class);
Reset Mock
${:importStatic(org.easymock.EasyMock.reset)}
reset(${var});
Replay Mock
${:importStatic(org.easymock.EasyMock.replay)}
replay(${var});
Проверить макет
${:importStatic(org.easymock.EasyMock.verify)}
verify(${var});
Новый метод тестирования JUnit:
@${testType:newType(org.junit.Test)}
public void ${testname}() throws Exception {
${staticImport:importStatic('org.junit.Assert.*')}${cursor}
String expected = "" ;
String actual = "" ;
Assert.assertEquals(expected, actual);
}
Это печатает весь объект (предполагается, что вы уже создали объект LOG4j LOGGER):
${:import(org.codehaus.jackson.map.ObjectMapper)}
// If check to avoid argument evaluation costs
if (LOGGER.isDebugEnabled()) {
try {
LOGGER.debug("Object ${Object}: " + "\n"
+ new ObjectMapper().writeValueAsString(${Object}));
} catch (JsonGenerationException e) {
LOGGER.info(e.toString());
} catch (JsonMappingException e) {
LOGGER.info(e.toString());
} catch (IOException e) {
LOGGER.info(e.toString());
}
}
Я видел ответ для шаблона, создающего базовый тестовый класс, и вот некоторые индивидуальные вызовы, если вы предпочитаете этот подход:
Создать метод setUp с @Before import
${:import(org.junit.Before)}
@Before
public final void setUp() {
${cursor}
}
Создать новый метод тестирования с помощью импорта @Test
${:import(org.junit.Test)}
@Test
public final void test${newName} () {
${cursor}
}
Я использую следующее для помощи с конверсиями JAXB между типами и DTOs:
Шаблон для преобразования существующей переменной в тип возвращаемого значения (работает с параметром)
${return_type} ${name} = null;
if (${var} != null) {
${name} = new ${return_type}();
${cursor}
}
return ${name};
list_methods - генерирует методы добавления, удаления, подсчета и содержит для списка
public void add${listname}(${listtype} toAdd){
get${listname}s().add(toAdd);
}
public void remove${listname}(${listtype} toRemove){
get${listname}s().remove(toRemove);
}
public ${listtype} get${listname}(int index){
return get${listname}s().get(index);
}
public int get${listname}Count(){
return get${listname}s().size();
}
public boolean contains${listname}(${listtype} toFind){
return get${listname}s().contains(toFind);
}
${cursor}
id - вставляет аннотации, импорт, поле и геттер для простого JPA @Id
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
public Long getId(){
return id;
}
${cursor}
${:import (javax.persistence.GenerationType,javax.persistence.GeneratedValue,javax.persistence.Id)}
Внутренний класс слушателя для разработки SWT и плагинов:
${imports:import(org.eclipse.swt.widgets.Listener)}
private class ${className} implements Listener{
@Override
public void handleEvent(Event e) {
final Widget w = e.widget;
}
}
${array_type}[] ${v:var(Vector)}Array = new ${array_type}[${v}.size()];
${v}.copyInto(${v}Array);
System.out.println(${word_selection}${});${cursor}
? Похоже, есть способ выбрать слово и автоматически заключить его в вызовsysout
, я прав? Как?