寻求有用的Eclipse Java代码模板

您可以通过以下方式在Eclipse中创建各种Java代码模板：

窗口>首选项> Java>编辑器>模板

例如

sysout 扩展为：

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

您可以通过输入激活此sysout之后CTRL+SPACE

您当前使用哪些有用的Java代码模板？包括它的名称和描述，以及它为什么很棒。

我正在寻找模板的原始/新颖用法，而不是内置的现有功能。

• 创建Log4J记录器
• 从显示器获取swt颜色
• Syncexec-Eclipse框架
• 单例模式/枚举单例生成
• 读文件
• 康斯特
• 追踪
• 格式字符串
• 注释代码审查
• 字串格式
• 尝试最后锁定
• 消息格式i18n和日志
• Equalsbuilder
• Hashcodebuilder
• 弹簧物体注入
• 创建FileOutputStream

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

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

一些额外的模板在这里：链接我 - 链接II

我喜欢这一个：

读文件

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

格式化字符串

MessageFormat-用MessageFormat包围所选内容。

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

这使我可以将光标移动到字符串，将选择范围扩展到整个字符串（Shift-Alt-Up），然后按Ctrl-空格键两次。

锁定选择

锁定-尝试最终锁定以包围选定的行。假设存在一个锁变量。

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

NB ${line_selection}模板显示在“ 环绕声”菜单中（Alt-Shift-Z）。

我知道我要踢死人了，但为了完成此事，我想分享一下：

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

单例创建模板： 为此命名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();

附加代码段以进行迭代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();
    |
}

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

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

使用Mockito创建一个模拟（在“ 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});

验证从未调用模拟方法：

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

使用Google Guava的新链表（对于哈希集和哈希图也是如此）：

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

我心爱的人之一是foreach：

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

和traceout，因为我经常使用它进行跟踪：

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

我刚刚想到了另一个，并且有一天在互联网上找到了const：

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

关于sysout的小技巧-我想将其重命名为“ sop”。Java库中的其他内容都没有以“ sop”开头，因此您可以快速键入“ sop”并插入繁荣。

在当前作用域（illarg）中抛出一个IllegalArgumentException与变量：

throw new IllegalArgumentException(${var});

更好

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

没什么花哨的代码生产-但是对代码审查非常有用

我的模板coderev低/中/高执行以下操作

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

然后在“任务”视图中-将向我显示我想在会议期间提出的所有代码审阅注释。

这里还有更多模板。

包括：

• 从特定日期创建日期对象
• 创建一个新的通用ArrayList
• 记录仪设置
• 以指定级别登录
• 创建一个新的通用HashMap
• 遍历地图，打印键和值
• 使用SimpleDateFormat解析时间
• 逐行读取文件
• 记录并抛出捕获的异常
• 打印一段代码的执行时间
• 创建定期计时器
• 将字符串写入文件

slf4j记录

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

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

豆属性

private ${Type} ${property};

public ${Type} get${Property}() {
    return ${property};
}

public void set${Property}(${Type} ${property}) {
    ${propertyChangeSupport}.firePropertyChange("${property}", this.${property},     this.${property} = ${property});
}

物业变更支持

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

在Java 7之后，设置需要（或希望）对封装类进行静态引用的记录器的一种好方法是使用新引入的MethodHandles API在静态上下文中获取运行时类。

SLF4J的示例片段为：

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

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

在GUI线程上调用代码

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

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

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

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

在编译之前，我总是检查我的TODO，并且永远不会忘记再次删除System.out。

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

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

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

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

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

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

记录器声明的模板很棒。

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

恐怖：

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

为事件创建一切

由于事件在Java中很难创建-所有这些接口，方法和东西都只为1个事件编写-我制作了一个简单的模板来创建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处理泛型的方式而无法使用。=（

编辑：1）我遇到了一个事件发生时线程正在添加/删除侦听器的问题。的List同时在使用中，所以我增加不能被修改synchronized，其中侦听器列表被访问或使用的块，锁定列表本身上。

然后插入测试方法

最近，我与一位非常好的开发人员和朋友结对编程时，看到了与此版本类似的版本，我认为这可能是该列表的不错补充。

该模板将根据注释中的行为驱动开发（BDD）范式，按照给定-时间-然后方法，在类上创建新的测试方法，以作为构建代码的指南。它将以“应该”开头的方法名称，并让您用测试方法职责的最佳描述替换其余的虚拟方法名称“ 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)}

弹簧注射

我知道这有点晚了，但是这是我在课堂上用于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};
}

这是非实例化类的构造函数：

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

我喜欢这样生成的类注释：

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

“ I ...”立即鼓励开发人员描述该类的功能。我似乎确实改善了未记录的类的问题。

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

我已经大量使用了这些片段，寻找null值和空字符串。

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

testNullArgument

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

您可能需要更改例外消息以适合您公司或项目的标准。但是，我建议您添加一些消息，其中应包含有问题的参数的名称。否则，方法的调用者将不得不查看代码以了解出了什么问题。（NullPointerException没有消息的A 会产生相当荒谬的消息“ 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}");
}

您还可以从上方重用null检查模板，并实现此代码段以仅检查空字符串。然后，您将使用这两个模板来生成上面的代码。

但是，上面的模板存在一个问题，如果in参数是最终参数，则必须修改产生的代码。 ${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”或类似方法更有趣的方法，实际上可能使您的用户有机会找出问题所在。

请享用！

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

我最喜欢的几个是...

1：Javadoc，插入有关该方法为Spring对象注入方法的doc。

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