寻找有用的Eclipse Java代码模板

对于log，在成员变量中添加一个有用的小调。

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

我最喜欢的一个是foreach:

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

和traceout，因为我经常使用它来跟踪:

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

我刚刚想到了另一个，有一天在网上找到了它，常量:

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

以下代码模板将创建记录器，并根据需要创建正确的导入。

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

源。

7月

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

从当前显示中获取SWT颜色:

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

周围都是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;
}

我喜欢这个:

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}

更新:这个模板的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
}

对于代码生产来说没什么特别的，但是对于代码审查来说非常有用

我有我的模板coderev low/med/high执行以下操作

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

然后在Tasks视图中-将显示我想在会议期间提出的所有代码审查注释。

我喜欢这样生成类注释:

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

“I…”立即鼓励开发人员描述类的功能。我似乎确实改善了没有文档的类的问题。

当然，$Id$是一个有用的CVS关键字。

我将此用于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));
}

strf -> String.format("msg", args)非常简单，但节省了一些输入。

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

关于sysout的一个小提示——我喜欢将它重命名为“sop”。java库中没有其他以“sop”开头的东西，因此您可以快速键入“sop”，然后插入。

格式化字符串

MessageFormat -用MessageFormat包围选区。

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

这让我可以将光标移动到字符串上，将选择范围扩展到整个字符串(Shift-Alt-Up)，然后按住Ctrl-Space两次。

锁定选区

锁定-环绕选定的行，最后尝试锁定。假设存在一个锁变量。

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

NB ${line_selection}模板显示在与周围菜单(Alt-Shift-Z)中。

和一个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);
}

在当前范围内抛出一个变量IllegalArgumentException (illarg):

throw new IllegalArgumentException(${var});

更好的

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

日志记录器声明的模板很棒。

我还为我经常使用的日志级别创建了linfo、ldebug、lwarn和lerror。

lerror:

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

我最喜欢的几个是……

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)，或者如果你不能查看缓冲区的内容(通过inspect)，因为它太大了

java.io.FileOutputStream fos = new java.io.FileOutputStream( new java.io.File("c:\\x.x"));
fos.write(buffer.toString().getBytes());
fos.flush();
fos.close();

我知道我是在找死，但为了完成起见，我想分享这个:

单例生成模板的正确版本，克服了有缺陷的双重检查锁定设计(上面讨论过，其他地方也提到过)

创建模板: 命名为createsingleton

static enum Singleton {
INSTANCE;


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


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

单例引用模板 命名这个getsingleton:

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

更多的模板在这里。

包括:

• 从特定的日期创建一个日期对象
• 创建一个新的泛型数组列表
• 日志设置
• 指定级别的日志
• 创建一个新的通用HashMap
• 遍历映射，打印键和值
• 使用SimpleDateFormat解析时间
• 逐行读取文件
• 记录并重新抛出捕获的异常
• 打印代码块的执行时间
• 创建定时定时器
• 将字符串写入文件

为一个事件创造一切

因为在Java中创建事件有点麻烦——所有这些接口、方法和东西都要为一个事件编写——我制作了一个简单的模板来创建一个事件所需的一切。

${: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处理泛型的方式，它无法工作。= (

Null检查!

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


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

slf4j日志

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


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

从向量到数组

${array_type}[] ${v:var(Vector)}Array = new ${array_type}[${v}.size()];
${v}.copyInto(${v}Array);

春天注入

我知道这有点晚了，但这里是我在一个类中使用的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};
}

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

静态导入Hamcrest测试

如果你想使用JUnit 4.8.2的新特性(assertThat, is, hasItems，等等…)，这里有一个模板来生成带有必要hamcrest导入的@Test方法。

@${testType:newType(org.junit.Test)}
public void ${testName}() throws Exception {
// Arrange
${staticImport:importStatic('org.hamcrest.MatcherAssert.*','org.hamcrest.Matchers.*')}${cursor}
// Act


// Assert


}

在写测试的时候，我已经用过很多次了。

什么是Arrange-Act-Assert?< / >

使用Mockito创建一个mock(在“Java语句”上下文中):

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

在“Java类型成员”中:

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

模拟void方法抛出异常:

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

模拟一个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});

验证被模拟的方法被精确地调用一次:

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

验证mock方法从未被调用:

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

使用谷歌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

通过plugin: 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);
}

在GUI线程上调用代码

我将下面的模板绑定到快捷方式slater，以便在GUI线程上快速分派代码。

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

EasyMock模板

创建模拟

${:importStatic(org.easymock.EasyMock.createMock)}
${type} ${name} = createMock(${type}.class);

重置模拟

${:importStatic(org.easymock.EasyMock.reset)}
reset(${var});

回放模拟

${:importStatic(org.easymock.EasyMock.replay)}
replay(${var});

验证模拟

${:importStatic(org.easymock.EasyMock.verify)}
verify(${var});

下面是一个非实例化类的构造函数:

// 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值和空字符串。

我使用“参数测试”模板作为方法中的第一个代码来检查接收到的参数。

testNullArgument

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

您可能希望更改异常消息以符合公司或项目的标准。但是，我确实建议有一些消息，其中包括冒犯参数的名称。否则，方法的调用者将不得不查看代码以了解哪里出了问题。(没有消息的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()将失败)。

如果你使用了很多final参数，想要检查空字符串，但不需要在代码中修饰它们，你可以这样做:

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”，就可以得到这个结果。长度" [TAB] "== to.length"。

结果比“ArrayIndexOutOfBoundsException”或类似的方法更有趣，实际上可能会给用户一个机会来找出问题。

享受吧!

下面是一个foreach，它将用于迭代List<Stuff>。循环中的可选内容用于查找列表中的元素并返回它。

for (${t:elemType(w)} elem: ${w:collection}) {
if (elem.get.equals(${localVar})){
return elem;
}
}
return null;

根据所选单词创建一个新的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 + 空间(或您为代码辅助配置的任何东西)。

我最喜欢的测试用例模板是记录异常然后重新抛出它们的模板，因为我喜欢在控制台中而不是在JUnit的异常查看器中查看异常。

你喜欢系统吗?在你的测试日志文件中，你总是可以使用类似的东西:

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

在Java 7之后，设置需要(或更喜欢)对外围类的静态引用的记录器的一个好方法是使用新引入的MethodHandles API在静态上下文中获取运行时类。

SLF4J的一个示例片段是:

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

除了在任何IDE中都是一个简单的代码片段外，如果您将某些功能重构到另一个类中，它也不会那么脆弱，因为您不会意外地携带类名。

我使用以下模板进行Android开发:

详细(Logv)

Log.v(TAG, ${word_selection}${});${cursor}

调试(Logd)

Log.d(TAG, ${word_selection}${});${cursor}

信息(罗技)

Log.i(TAG, ${word_selection}${});${cursor}

警告(Logw)

Log.w(TAG, ${word_selection}${});${cursor}

错误(包厢)

Log.e(TAG, ${word_selection}${});${cursor}

断言(Loga)

Log.a(TAG, ${word_selection}${});${cursor}

TAG是我在每个活动中定义的常量。

我刚刚注意到@Duncan Jones已经有了这个模板，但添加${line_selection}并使用转变 + Alt + Z是一个有用的策略。

这可能只是我正在从事的项目中一些糟糕设计的一点hack fix，但我有很多情况下，一些遗留代码正在修改AWT线程之外的Swing组件，并导致间歇性错误，所以为了快速修补这些问题，我使用:

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

因此，我可以突出显示违规语句，并使用转变 + Alt + Z来包围。我称这个模板为swinvoke。

插入测试方法时应给出

我最近在与一个非常优秀的开发人员和朋友结对编程时看到了一个类似的版本，我认为它可以成为这个列表的一个很好的补充。

这个模板将在一个类上创建一个新的测试方法，遵循注释上的行为驱动开发 (BDD)范例中的给定-何时-然后接近，作为构建代码的指南。它将以“should”开始方法名称，并允许您用测试方法职责的最佳描述替换其余的虚拟方法名称“CheckThisAndThat”。在填写名称后，TAB将直接带您到// Given section，因此您可以开始输入先决条件。

我把它映射到三个字母“tst”，描述为“测试方法应该在什么时候给出”;)

我希望你能像我看到它时一样觉得它很有用:

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


// When




// Then


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

这省去了大量打印/记录本地值的繁琐工作。它自动捕获字符串中的变量名。这节省了大量的打字和错字改正。

模板:

+ ", ${1:var}: " + ${1:var}

它有两个陷阱:

尽管会提示您选择一个本地/参数/字段，但这并不包括原语:(

只要编译代码时没有错误，就会出现大多数提示。使用这个宏通常会导致语法暂时被破坏，因此需要使用一些杂耍来插入多个变量。没有什么比在变量名中没有错别字更方便的了。

附加代码片段遍历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();
|
}

用于SWT和插件开发的内部侦听器类:

${imports:import(org.eclipse.swt.widgets.Listener)}
private class ${className} implements Listener{


@Override
public void handleEvent(Event e) {
final Widget w = e.widget;
}
}

代码部分

//--------------------------------------------------------------
//                       ${title}
//--------------------------------------------------------------
${cursor}

使用此模板可以更容易地注释代码部分。它不是很复杂，但为我节省了很多时间:)

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插入注释、导入、字段和getter

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;


public Long getId(){
return id;
}


${cursor}
${:import (javax.persistence.GenerationType,javax.persistence.GeneratedValue,javax.persistence.Id)}

在测试代码时，我有时会错过删除一些syso。所以我给自己做了一个名为syt的模板。

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

在我编译之前，我总是检查我的todo，永远不会忘记删除一个系统。出来。

我看到了一个创建基本测试类的模板的答案，如果你更喜欢这种方法，这里有一些单独的调用:

使用@Before import创建setUp方法

${:import(org.junit.Before)}
@Before
public final void setUp() {
${cursor}
}

使用@Test import创建新的测试方法

${:import(org.junit.Test)}
@Test
public final void test${newName} () {
${cursor}
}

我使用以下方法来帮助在类型和dto之间进行JAXB转换:

将现有变量转换为返回值类型的模板(与形参一起使用)

${return_type} ${name} = null;


if (${var} != null) {
${name} = new ${return_type}();
${cursor}
}
return ${name};

这将打印整个对象(假设你已经初始化了一个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());
}
}

一种新的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);
}

• hashCode()
• 公共布尔值等于(对象)

使用显式测试而不是反射，反射速度较慢，并且可能在安全管理器(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();
}