The same way I try to avoid the redundancy in my code, the same way I try to avoid the redundancy in my writing. I am lazy and templates do the most writing for me. Eclipse comes bundled with predefined templates, but they are too general and not all of them are too useful. The real power is in custom templates. In this article I would like to show you how to create them and list a few useful pieces for inspiration.
What are templates
Exactly as the name suggests, templates are little pieces of code with defined placeholders. An example of simple template is
1.System.out.println(${text});
Each template has a name, which serves as a shortcut to the template itself. You type the name, press CTRL + SPACE and it will be expanded.
Our first template would expand to
I will not explain here what it all means, I already did this in my previous post on templates. What is important now, is that the ${text} placeholder (variable) was highlighted and can be edited immediately.
The true power of templates can be fully seen in more complex templates. The first power point lies in the fact, that you can have more than one variable with same name. Our second template will have more variables:
1.int ${increment} = ${value};
2.y = ${increment} + ${increment};
and will expand to
When you start typing now, all occurrences of increment variable will be changed. You can then switch to the next variable by pressing TAB key. In the end, you can have
in just three key presses - one for i, one for TAB and one for 2.
To make it even better, the template system provides predefined variables, which will be expanded depending on their context. I will not list them, you can find them under the Insert variable button.
Notice, that you are not getting only a list, you are also getting a description and an usage example.
To make it clear, I will illustrate one builtin variable - ${enclosing_type}. When this one is expanded you will get a name of the class (or interface, enum) in which your template was expanded.
"But how can I use it?", I hear you asking. I have prepared few templates just for inspiration, I believe that after reading this you will find thousands others and I believe that you will create them and share them with us.
Custom templates
Open Window -> Preferences and type Templates into the search box.
You will get a list of all editors, and their respective template settings. This is because templates are closely bound to editors - you will get different builtin variables in different editors. Also note, that your list may vary from my list, it all depends on installed plugins.
Now you must decide what type of template you would like to create. If it is a Java template, which will be applicable in context of classes, interfaces and enums, then choose Java -> Editor -> Templates. If you create a Java template you won't be able to use it in XML editor, that's quite expected.
So click on the New button, to get a dialog. Here it is, in all its glory:
Name is the name of the template. Choose it well, because it will serve as a shortcut to your template. After you type the name of the template (or at least a few characters from its name) and hit CTRL+SPACE it will be expanded.
Description is what you will see next to the template name when the template name is ambiguous.
Pattern is the template body. And the Context? This varies in every editor. If you look in the combobox in Java templates, you will see Java and Javadoc. It is simple a context within the respective editor in which the template would be applicable.
Check Automatically insert if you want the template to expand automatically on ctrl-space when there is no other matching template available. It is usually good idea to leave the checkbox checked, otherwise you would get a template proposal "popup". See what happens when I uncheck it on sysout template.
If I would have checked it, it would automatically expand, as there is no other template matching sysout* pattern.
My list
So here is the list I promised. I have categorized it.
Java (
Java->Editor->Templates)
- logger - create new Logger
1.private static final Logger logger = Logger.getLogger(${enclosing_type}.class.getName());
- loglevel - log with specified level
1.if(${logger:var(java.util.logging.Logger)}.isLoggable(Level.${LEVEL})) {
2. ${logger:var(java.util.logging.Logger)}.${level}(${});
3.}
4.${cursor}
You might wonder what is the purpose of the if. It is there only for performance gain. If specified level is not allowed the logging method will never be called and we can spare JVM some string manipulation to build the message. - readfile - read text from file
Never can remember how to open that pesky file and read from it? Nor can I, so I have a template for it.
01.BufferedReader in;
02.try {
03. in = new BufferedReader(new FileReader(${file_name}));
04. String str;
05. while ((str = in.readLine()) != null) {
06. ${process}
07. }
08.} catch (IOException e) {
09. ${handle}
10.} finally {
11. in.close();
12.}
13.${cursor}
Maven (
Web and XML -> XML Files -> Templates)
- dependency - maven dependency
1. <groupId>${groupId}groupId>
2. <artifactId>${artifactId}artifactId>
3. <version>${version}version>
4.dependency>
5.${cursor}
- parent - maven parent project definition
1.<parent>
2. <artifactId>${artifactId}artifactId>
3. <groupId>${groupId}groupId>
4. <version>${version}version>
5. <relativePath>{$path}/pom.xmlrelativePath>
6.parent>
7.${cursor}
web.xml (
Web and XML -> XML Files -> Templates)
- servlet - new servlet definition
01.<servlet>
02. <servlet-name>${servlet_name}servlet-name>
03. <servlet-class>${servlet_class}servlet-class>
04. <load-on-startup>${0}load-on-startup>
05. servlet>
06.
07.<servlet-mapping>
08. <servlet-name>${servlet_name}servlet-name>
09. <url-pattern>*.htmlurl-pattern>
10.servlet-mapping>
11.${cursor}
JSP pages (
Web and XML -> JSP Files -> Templates)
- spring-text - spring text field with label and error
1.<label for="${path}" class="${label_class}"><fmt:message key="${path}"/>label>
2.<spring:input path="${path}" cssClass="${input_class}"/>
3.<spring:errors path="${path}"/>
4.
5.${cursor}
- spring-checkbox
1.<label for="${path}" class="${label_class}"><fmt:message key="${path}"/>label>
2.<spring:checkbox path="${path}" cssClass="${input_class}"/>
3.
4.${cursor}
- spring-select
1.<label for="${path}" class="${label_class}"><fmt:message key="${path}"/>label>
2.<spring:select path="${path}" cssClass="${input_class}">
3.<spring:options items="${items}" itemLabel="${label}" itemValue="${value}"/>
4.spring:select>
5.<spring:errors path="${path}"/>
6.
7.${cursor}
- spring-generic
1.<label for="${path}" class="${label_class}"><fmt:message key="${path}"/>label>
2.<spring:${type} path="${path}" cssClass="${input_class}"/>
3.<spring:errors path="${path}"/>
4.
5.${cursor}
In some editor types you can set the template to 'new', for example, in XML editor it is new XML. This is really useful, as you can prepare the skeleton of a new file. For example, this is what I use to create new Spring servlet configuration for freemarker application.
01.xml version="1.0" encoding="UTF-8"?>
09.
10.<context:component-scan base-package="" />
11.
12.<bean id="freemarkerConfig" class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
13.<property name="templateLoaderPath" value="/"/>
14.bean>
15.
16.<bean id="viewResolver" class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver">
17.<property name="viewClass" value="org.springframework.web.servlet.view.freemarker.FreeMarkerView"/>
18.<property name="exposeSpringMacroHelpers"><value>truevalue>property>
19.<property name="cache" value="true"/>
20. <property name="prefix" value="/pages/"/>
21. <property name="suffix" value=".ftl"/>
22.bean>
23.
24.<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
25. <property name="basename"><value>messagesvalue>property>
26.bean>
27.beans>
Now, I can create new XML file from template and it will be ready to use. Before I knew about templates, I used to copy this from an older project, or search for it in Spring documentation. Now I don't have to..
If you can overcome the initial laziness and create your own templates from the pieces of code you really use, than this investment will shortly return in form of less typing. If you have some interesting templates, please, share them with us.
