# Java Template Engine \[JTE]
The Java Template Engine (jte) is a secure and lightweight template engine designed for Java and Kotlin applications. It emphasizes minimal syntax, leveraging existing language features to make templates intuitive and maintainable.
{% hint style="info" %}
for more info visit official doc - [https://jte.gg](https://jte.gg/syntax/)
{% endhint %}
### Some of the features of JTE -
1. **Performance**: JTE compiles templates to Java bytecode, resulting in efficient runtime execution.
2. **Compile-time checking**: Catch errors at compile time rather than runtime.
3. **Lightweight**: Minimal overhead and dependencies.
4. **Hot reloading**: See changes immediately without restarting your application.
5. **Pre-compilation**: Improve startup times by pre-compiling templates.
### Integrating jte into a Spring Boot Application
1. Create spring boot project with web starter.
2. add the following dependency to use jte
```xml
gg.jtejte3.1.12gg.jtejte-spring-boot-starter-33.1.12
```
It will also create jte folder in application, in which we need to store our templetes.
3. Add the following plugin along with spring boot maven plugin
```xml
gg.jtejte-maven-plugin3.1.12jte-generategenerate-sourcesgenerate${project.basedir}/src/main/jteHtmltrue${project.build.outputDirectory}
```
4. Create a template in jte directory with extension of .jte.
template - index.jte in src/main/jte
```java
@param String name // for parameters from model map
Hello JTE
Hello, ${name}!
```
5. To view this on browser we need to create a controller also
```java
@Controller
public class HomeController {
@GetMapping("/")
public String home(Model model) {
model.addAttribute("name", "Dan"); // sending name parameter to jte
return "index";
}
}
```
### Properties available for JTE
```properties
# determine the jte template locations
gg.jte.templateLocation=src/main/jte # default is same
# configure template suffix
gg.jte.templateSuffix=.jte # default is same
# precompile the templates for faster startup and rendering, recommended in prod
gg.jte.usePrecompiledTemplates=true #dafault is false
# used for development as watcher will watch for changes in templates and recompile them
gg.jte.developmentMode=true
```
### Template Syntax
### ${}
* To display data from variable , can be used with general data types along with Any class implementing `gg.jte.Content`
### <%-- ... --%>
* To display comments
### @import
* Used to import direcly from app like classes, records etc.
* Need to use fully qualified name e.g. **`@import com.app.Sample` **
### **@Param**
* It used to declare the parameter that is passed to this template. e.g. **`@param Sample sample`**
* The datatype could be premitive or the custom dto , models or records etc.
* For any classes we need to either import them first or need to use fully qualified name with @param.
* we can also assign default values
### `@if`/`@endif`
* Used for flow control in the template
* for nesting we can also use @elseif
### `@for` and `@endfor`
* Used to loop over variable
* loop can be both fori or for in
* we can also use @else with for , as in case of no data else part will get executed.
### !{}
* used to declare local variable
* that can be used with ${}
### Content
* `gg.jte.Content` is a special parameter type, that is used to pass template code to other templates, much like lambdas in Java.
* They are handy for sharing structures between different templates.
### Example -
```html
@import org.example.Page # imports custom class
@import gg.jte.Content # imports content
@import my.Model
@param Page page
@param Content content
@param Content footer = null # asigning default value
@param String param;
@param Model model
@param Task task
${param}
@if(page.getDescription() != null)
@endif
${page.getTitle()}