sysout which expands to System.out.println();. All you have to do is type sysout followed by Ctrl+Space to insert the statement into your Java source file.
To see what templates are defined in Eclipse:
- Open your Preferences dialog by going to Windows > Preferences
- On the navigation tree on the left, go to Java > Editor > Templates
- You will see a list of pre-defined templates
- You can add new ones by pressing the "New..." button
| Name | if |
| Context | Java statements |
| Description | if null |
| Pattern | |
if (${var} == null){
${cursor}
}
| |
| Name | if |
| Context | Java statements |
| Description | if not null |
| Pattern | |
if (${var} != null){
${cursor}
}
| |
| Name | for |
| Context | Java statements |
| Description | iterate over map |
| Pattern | |
${:import(java.util.Map.Entry)}
for(Entry<${key:argType(map,0)},${value:argType(map,1)}> entry :
${map:var(java.util.Map)}.entrySet()) {
${key} key = entry.getKey();
${value} value = entry.getValue();
${cursor}
}
| |
| Name | strf |
| Context | Java |
| Description | format string |
| Pattern | |
String.format("${word_selection}${}",${var}${cursor})
| |
| Name | sysf |
| Context | Java statements |
| Description | print formatted string to standard out |
| Pattern | |
System.out.printf("${word_selection}${}",${var}${cursor});
| |
| Name | static_final |
| Context | Java type members |
| Description | static final field |
| Pattern | |
${visibility:link(
public,
protected,
private)} static final ${type} ${NAME} = ${word_selection}${};
| |
The following templates are useful for reading or writing files. They use Java 7 features such as try-with-resources to automatically close files. They also use methods from NIO2.0 to obtain a buffered reader and read the file.
| Name | readfile |
| Context | Java statements |
| Description | read text from file |
| Pattern | |
${: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
}
| |
| Name | readfile |
| Context | Java statements |
| Description | read all lines from file as a list |
| Pattern | |
${:import(java.nio.file.Files,
java.nio.file.Paths,
java.nio.charset.Charset,
java.util.List,
java.util.ArrayList)}
Lis<String> lines = new ArrayList<>();
try{
lines = Files.readAllLines(Paths.get(${fileName:var(String)}),
Charset.forName("UTF-8"));
}catch (IOException e) {
// ${todo}: handle exception
}
${cursor}
| |
| Name | writefile |
| Context | Java statements |
| Description | write text to file |
| Pattern | |
${:import(java.nio.file.Files,
java.nio.file.Paths,
java.nio.Charset,
java.io.IOException,
java.io.BufferedWriter)}
try (BufferedWriter out = Files.newBufferedWriter(Paths.get(${fileName:var(String)}),
Charset.forName("UTF-8"))) {
out.write(${string:var(String)});
out.newLine();
${cursor}
} catch (IOException e) {
// ${todo}: handle exception
}
| |
The following templates are used to read xml files or strings and return a DOM.
| Name | parsexml |
| Context | Java statements |
| Description | parse xml file as Document |
| Pattern | |
${:import(org.w3c.dom.Document,
javax.xml.parsers.DocumentBuilderFactory,
java.io.File,
java.io.IOException,
javax.xml.parsers.ParserConfigurationException,
org.xml.sax.SAXException)}
Document doc = null;
try {
doc = DocumentBuilderFactory.newInstance()
.newDocumentBuilder()
.parse(new File(${filename:var(String)}));
} catch (SAXException | IOException | ParserConfigurationException e) {
// ${todo}: handle exception
}
${cursor}
| |
| Name | parsexml |
| Context | Java statements |
| Description | parse xml string as Document |
| Pattern | |
${:import(org.w3c.dom.Document,
javax.xml.parsers.DocumentBuilderFactory,
org.xml.sax.InputSource,
java.io.StringReader,
java.io.IOException,
javax.xml.parsers.ParserConfigurationException,
org.xml.sax.SAXException)}
Document doc = null;
try {
doc = DocumentBuilderFactory.newInstance()
.newDocumentBuilder()
.parse(new InputSource(new StringReader(${str:var(String)})));
} catch (SAXException | IOException | ParserConfigurationException e) {
// ${todo}: handle exception
}
${cursor}
| |
The templates below are useful for creating a logger and logging messages. I use SLF4J, but they could easily be tweaked to use any other logging framework.
| Name | logger |
| Context | Java type members |
| Description | create new logger |
| Pattern | |
${:import(org.slf4j.Logger,
org.slf4j.LoggerFactory)}
private static final Logger LOGGER =
LoggerFactory.getLogger(${enclosing_type}.class);
| |
| Name | logd |
| Context | Java statements |
| Description | logger debug |
| Pattern | |
if(LOGGER.isDebugEnabled())
LOGGER.debug(${word_selection}${});
${cursor}
| |
| Name | logi |
| Context | Java statements |
| Description | logger info |
| Pattern | |
LOGGER.info(${word_selection}${});
${cursor}
| |
| Name | logerr |
| Context | Java statements |
| Description | logger error |
| Pattern | |
LOGGER.error(${word_selection}${}, ${exception_variable_name});
| |
| Name | logthrow |
| Context | Java statements |
| Description | log error and throw exception |
| Pattern | |
LOGGER.error(${word_selection}${}, ${exception_variable_name});
throw ${exception_variable_name};
${cursor}
| |
The templates below assist in writing JUnit tests.
| Name | before |
| Context | Java type members |
| Description | junit before method |
| Pattern | |
${:import (org.junit.Before)}
@Before
public void setUp() {
${cursor}
}
| |
| Name | after |
| Context | Java type members |
| Description | junit after method |
| Pattern | |
${:import (org.junit.After)}
@After
public void tearDown() {
${cursor}
}
| |
| Name | beforeclass |
| Context | Java type members |
| Description | junit beforeclass method |
| Pattern | |
${:import (org.junit.BeforeClass)}
@BeforeClass
public static void oneTimeSetUp() {
// one-time initialization code
${cursor}
}
| |
| Name | afterclass |
| Context | Java type members |
| Description | junit afterclass method |
| Pattern | |
${:import (org.junit.AfterClass)}
@AfterClass
public static void oneTimeTearDown() {
// one-time cleanup code
${cursor}
}
| |
Thank you!
ReplyDeleteThank you, this was quite helpful :)
ReplyDeleteJava 8? :)
ReplyDelete