寻找有用的 Eclipse Java 代码模板 [已关闭]

对于 ，一个有用的小曲子，可以添加到成员变量中。log

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

我心爱的人之一是 foreach：

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

还有追踪，因为我经常使用它进行跟踪：

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

我只是想了另一个，有一天在互联网上找到了它，const：

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

日志4J 2

${:import(org.apache.logging.log4j.LogManager,org.apache.logging.log4j.Logger)} 
private static final Logger LOG = LogManager.getLogger(${enclosing_type}.class); 

日志4J

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

从当前显示中获取 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;
}

以下是一些其他模板： 链接 I - 链接 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
}

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

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

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

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

我喜欢这样的生成类评论：

/**
 * 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-空格键两次。

锁定所选内容

锁定 - 用 Try finally Lock 包围所选行。假设存在锁定变量。

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

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

还有一个 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），或者由于缓冲区太大而无法查看缓冲区的内容（通过检查）时...

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

这里还有更多模板。

包括：

• 从特定日期创建日期对象
• 创建新的泛型 ArrayList
• 记录仪设置
• 指定级别的日志
• 创建一个新的泛型 HashMap
• 遍历地图，打印键和值
• 使用 SimpleDateFormat 分析时间
• 逐行读取文件
• 记录并重新抛出捕获的 exeption
• 打印代码块的执行时间
• 创建定期计时器
• 将 String 写入文件

为事件创建一切

由于在 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);
    }
}

如果您有共享单个事件的事件，只需删除模板插入的自定义事件并更改 和 的相应部分。EventObjectraise___()on____()

我使用泛型接口和泛型类编写了一个不错的、小巧的、优雅的事件机制，但由于 Java 处理泛型的方式，它不起作用。=(

编辑： 1） 我遇到了线程在事件发生时添加/删除侦听器的问题。使用时无法修改，因此我在访问或使用侦听器列表的地方添加了块，锁定了列表本身。Listsynchronized

空检查！

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

弹簧注射

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

PropertyChange支持

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

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

在 GUI 线程上调用代码

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

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

下面是不可实例化类的构造函数：

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

您可能需要更改异常消息以符合公司或项目的标准。但是，我确实建议有一些消息包含违规参数的名称。否则，方法的调用方将不得不查看代码以了解出了什么问题。（没有消息的 A 会生成异常，其中包含相当荒谬的消息“null”）。NullPointerException

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

test参数

这是用于测试变量的通用模板。我花了几年时间才真正学会欣赏这个，现在我经常使用它（当然要结合上面的模板！

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”或类似方法更有趣，实际上可能让您的用户有机会找出问题所在。

享受！

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

SLF4J 的示例代码片段如下：

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

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

插入测试方法 should-given-when-then

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

此模板将按照行为驱动开发 （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)}

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

在使用代码进行测试时，我有时会错过删除一些 syso s。所以我给自己做了一个叫做 syt 的模板。

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

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