Useful Eclipse Java Code Templates [closed]

问题:

You can create various Java code templates in Eclipse via

Window > Preferences > Java > Editor > Templates

e.g.

sysout is expanded to:

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

You can activate this by typing sysout followed by CTRL+SPACE

What useful Java code templates do you currently use?
Include the name and description of it and why it\'s awesome.

There\'s an open bounty on this for an original/novel use of a template rather than a built-in existing feature.

• Create Log4J logger
• Get swt color from display
• Syncexec - Eclipse Framework
• Singleton Pattern/Enum Singleton Generation
• Readfile
• Const
• Traceout
• Format String
• Comment Code Review
• String format
• Try Finally Lock
• Message Format i18n and log
• Equalsbuilder
• Hashcodebuilder
• Spring Object Injection
• Create FileOutputStream

回答1:

The following code templates will both create a logger and create the right imports, if needed.

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

Source.

JUL

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

回答2:

Some additional templates here: Link I - Link II

I like this one:

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: The Java 7 version of this template is:

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

回答3:

Format a string

MessageFormat - surround the selection with a MessageFormat.

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

This lets me move a cursor to a string, expand the selection to the entire string (Shift-Alt-Up), then Ctrl-Space twice.

Lock the selection

lock - surround the selected lines with a try finally lock. Assume the presence of a lock variable.

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

NB ${line_selection} templates show up in the Surround With menu (Alt-Shift-Z).

回答4:

I know I am kicking a dead post, but wanted to share this for completion sake:

A correct version of singleton generation template, that overcomes the flawed double-checked locking design (discussed above and mentioned else where)

Singleton Creation Template: Name this createsingleton

static enum Singleton {
    INSTANCE;

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

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

To access singletons generated using above:

Singleton reference Template: Name this getsingleton:

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

回答5:

Append code snippet to iterate over Map.entrySet():

Template:

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

Generated Code:

for (Entry<String, String> entry : properties.entrySet())
{
    String key = entry.getKey();
    String value = entry.getValue();
    |
}

回答6:

For log, a helpful little ditty to add in the member variable.

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

回答7:

Create a mock with Mockito (in \"Java statements\" context):

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

And in \"Java type members\":

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

Mock a void method to throw an exception:

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

Mock a void method to do something:

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

Verify mocked method called exactly once:

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

Verify mocked method is never invoked:

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

New linked list using Google Guava (and similar for hashset and hashmap):

${import:import(java.util.List,com.google.common.collect.Lists)}List<${T}> ${newName} = Lists.newLinkedList();

Also I use a huge template that generates a Test class. Here is a shortened fragment of it that everyone interested should customize:

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

回答8:

Null Checks!

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

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

回答9:

One of my beloved is foreach:

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

And traceout, since I\'m using it a lot for tracking:

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

I just thought about another one and have found it over the Internet some day, const:

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

回答10:

A little tip on sysout -- I like to renamed it to \"sop\". Nothing else in the java libs starts with \"sop\" so you can quickly type \"sop\" and boom, it inserts.

回答11:

Throw an IllegalArgumentException with variable in current scope (illarg):

throw new IllegalArgumentException(${var});

Better

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

回答12:

Nothing fancy for code production - but quite useful for code reviews

I have my template coderev low/med/high do the following

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

And then in the Tasks view - will show me all of the code review comments I want to bring up during a meeting.

回答13:

Some more templates here.

Includes:

• Create a date object from a particular date
• Create a new generic ArrayList
• Logger setup
• Log with specified level
• Create a new generic HashMap
• Iterate through a map, print the keys and values
• Parse a time using SimpleDateFormat
• Read a file line by line
• Log and rethrow a caught exeption
• Print execution time of a block of code
• Create periodic Timer
• Write a String to a file

回答14:

slf4j Logging

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

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

回答15:

Bean Property

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

回答16:

Post Java 7, a great way to set up loggers which need (or prefer) static references to the enclosing class is to use the newly introduced MethodHandles API to get the runtime class in a static context.

An example snippet for SLF4J is:

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

Aside from being a simple snippet in any IDE, it is also less brittle if you refactor certain functionality into another class because you won\'t accidentally carry the class name with it.

回答17:

Invoke code on the GUI thread

I bind the following template to the shortcut slater to quickly dispatch code on the GUI thread.

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

回答18:

When testing around with code I sometimes missed out on deleting some syso s. So I made myself a template called syt.

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

Before I compile I always check my TODOs and will never forget to delete a System.out again.

回答19:

strf -> String.format(\"msg\", args) pretty simple but saves a bit of typing.

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

回答20:

Get an SWT color from current display:

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

Suround with syncexec

PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable(){
    public void run(){
        ${line_selection}${cursor}
    }
});

Use the singleton design pattern:

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

回答21:

And an equalsbuilder, hashcodebuilder adaptation:

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

回答22:

The template for the logger declaration is great.

I also create linfo, ldebug, lwarn, lerror for the log levels that I use more often.

lerror:

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

回答23:

Create everything for an event

Since events are kinda a pain to create in Java--all those interfaces, methods, and stuff to write just for 1 event--I made a simple template to create everything needed for 1 event.

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

If you have events that share a single EventObject, just delete the customized one inserted by the template and change the appropriate parts of raise___() and on____().

I had written a nice, little, elegant eventing mechanism using a generic interface and generic class, but it wouldn\'t work due to the way Java handles generics. =(

Edit: 1) I ran into the issue where threads were adding/removing listeners while an event was taking place. The List can\'t be modified while in use, so I added synchronized blocks where the list of listeners is being accessed or used, locking on the list itself.

回答24:

Insert test methods should-given-when-then

I saw a similar version to this one recently while pair programming with a very good developer and friend, and I think it could be a nice addition to this list.

This template will create a new test method on a class, following the Given - When - Then approach from the behavior-driven development (BDD) paradigm on the comments, as a guide for structuring the code. It will start the method name with \"should\" and let you replace the rest of the dummy method name \"CheckThisAndThat\" with the best possible description of the test method responsibility. After filling the name, TAB will take you straight to the // Given section, so you can start typing your preconditions.

I have it mapped to the three letters \"tst\", with description \"Test methods should-given-when-then\" ;)

I hope you find it as useful as I did when I saw it:

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

    // When


    // Then

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

回答25:

Spring Injection

I know this is sort of late to the game, but here is one I use for Spring Injection in a class:

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

回答26:

Here is a constructor for non-instantiable classes:

// Suppress default constructor for noninstantiability
@SuppressWarnings(\"unused\")
private ${enclosing_type}() {
    throw new AssertionError();
}

This one is for custom exceptions:

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

回答27:

I like a generated class comment like this:

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

The \"I...\" immediately encourages the developer to describe what the class does. I does seem to improve the problem of undocumented classes.

And of course the $Id$ is a useful CVS keyword.

回答28:

I\'ve had a lot of use of these snippets, looking for null values and empty strings.

I use the \"argument test\"-templates as the first code in my methods to check received arguments.

testNullArgument

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

You may want to change the exception message to fit your company\'s or project\'s standard. However, I do recommend having some message that includes the name of the offending argument. Otherwise the caller of your method will have to look in the code to understand what went wrong. (A NullPointerException with no message produces an exception with the fairly nonsensical message \"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}\");
}

You can also reuse the null checking template from above and implement this snippet to only check for empty strings. You would then use those two templates to produce the above code.

The above template, however, has the problem that if the in argument is final you will have to amend the produced code some (the ${varName} = ${varName}.trim() will fail).

If you use a lot of final arguments and want to check for empty strings but doesn\'t have to trim them as part of your code, you could go with this instead:

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

I also created some snippets for checking variables that is not sent as arguments (the big difference is the exception type, now being an IllegalStateException instead).

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

This is a general template for testing a variable. It took me a few years to really learn to appreciate this one, now I use it a lot (in combination with the above templates of course!)

if (!(${varName} ${testExpression})) {
    throw new IllegalArgumentException(
        \"Illegal argument. The argument ${varName} (\" + ${varName} + \") \" +
        \"did not pass the test: ${varName} ${testExpression}\");
}

You enter a variable name or a condition that returns a value, followed by an operand (\"==\", \"<\", \">\" etc) and another value or variable and if the test fails the resulting code will throw an IllegalArgumentException.

The reason for the slightly complicated if clause, with the whole expression wrapped in a \"!()\" is to make it possible to reuse the test condition in the exception message.

Perhaps it will confuse a colleague, but only if they have to look at the code, which they might not have to if you throw these kind of exceptions...

Here\'s an example with arrays:

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

You get this result by calling up the template, typing \"from.length\" [TAB] \"== to.length\".

The result is way funnier than an \"ArrayIndexOutOfBoundsException\" or similar and may actually give your users a chance to figure out the problem.

Enjoy!

回答29:

I use this for MessageFormat (using Java 1.4). That way I am sure that I have no concatenations that are hard to extract when doing internationalization

i18n

String msg = \"${message}\";
Object[] params = {${params}};
MessageFormat.format(msg, params);

Also for logging:

log

if(logger.isDebugEnabled()){
  String msg = \"${message}\"; //NLS-1
  Object[] params = {${params}};
  logger.debug(MessageFormat.format(msg, params));
}

回答30:

My favorite few are...

1: Javadoc, to insert doc about the method being a Spring object injection method.

 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: Debug window, to create a FileOutputStream and write the buffer\'s content\'s to a file. Used for when you want to compare a buffer with a past run (using BeyondCompare), or if you can\'t view the contents of a buffer (via inspect) because its too large...

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