Adding Custom Templates in Eclipse for Faster Java Development

As we saw in the last tutorial, Eclipse Templates for Faster Java Development,  Eclipse provides inbuilt templates that we can use to expedite the coding. Apart from that, we can create our own custom templates, as well as for the code, which we find repetitive in nature and can save us a lot of time.

So, to create a new custom template, you need to go to Windows->Preferences

First, you will type Java in the search box and then go to Editor ->Templates

You will see the list of inbuilt templates provided by Eclipse already. To add your own template, click on New:

You will provide your name to the shorthand that will be visible when you will press Ctrl + Space.

In Description, you can mention briefly what this shorthand is about — the context is Java.

If checked, it will automatically insert the code snippet for you by writing shorthand word and pressing Ctrl + space, if there is no other matching template is available.

For example, if you write sysout and press CRTL + Space, it will write System.out.println(); for you, when automatically insert is checked. However, if automatically insert is not checked, then a template proposal will be displayed, which you then need to select.

A pattern is a place where your template goes, below I have included four pattern examples:

1. List Iterator  
2. Map Iterator  
3. Logger  
4. NullCheck

List Iterator

Name: listIterator 
Description: iterate over list
Context: Java
Pattern:

Iterator<${type}> itr = listVar.iterator();
while(itr.hasNext()){
${type} str = (${type})itr.next();
}

Map Iterator

Name: mapIterator 
Description: iterate over map
Context: Java
Pattern:

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

Logger

Name: logger 
Description : logger Entry
Context : Java
Pattern:

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

Null Check

Name: NullCheck 
Description: check for null value
Context : Java
Pattern:

if (${var} != null) {
${line_selection}${cursor}
}

Java Editor Template Variables

There are two types of variables that can be used while writing patterns for Java code. These variables are resolved to their actual value when a template is evaluated.

Two types of variables:

1) General template variable
2) Java-specific template variable

We can use variables in two ways, as follows:

Simple variables as below :
${array}

This defines a variable with name array, which can be referenced multiple times and will resolve to an array. Also, we can use the following:

Full variables as below :
${array:var(java.util.iterator)}

This defines a variable with a name as an array that will resolve to a local variable of type  java.util.Iterator. It can be referenced multiple times by giving its name without type like  ${array} .

General Template Variable

${cursor}

${date}

${dollar}

${enclosing_method}

${enclosing_method_arguments}

${enclosing_package}

${enclosing_project}

${enclosing_type}

${file}

${line_selection}

${primary_type_name}

${return_type}

${time}

${user}

${word_selection}

${year}

2) Java-Specific Template Variables

${array}

${array_element}

${array_type}

${collection}

${exception_variable_name}

${index}

${iterator}

${iterable}

${iterable_element}

${todo}

Thanks for reading! Please share this post with someone to whom it might be helpful.