This version is still in development and is not considered stable yet. For the latest stable version, please use Spring Framework 7.0.2!

Script Views

See equivalent in the Reactive stack

The Spring Framework has a built-in integration for using Spring MVC with any templating library that can run on top of the JSR-223 Java scripting engine. We have tested the following templating libraries on different script engines:

Scripting Library Scripting Engine

ERB

JRuby

String templates

Jython
The basic rule for integrating any other script engine is that it must implement the ScriptEngine and Invocable interfaces.

Requirements

See equivalent in the Reactive stack

You need to have the script engine on your classpath, the details of which vary by script engine:

  • JRuby should be added as a dependency for Ruby support.

  • Jython should be added as a dependency for Python support.

Script Templates

See equivalent in the Reactive stack

You can declare a ScriptTemplateConfigurer bean to specify the script engine to use, the script files to load, what function to call to render templates, and so on. The following example uses the Jython Python engine:

  • Java

  • Kotlin

  • XML

@Configuration
public class WebConfig implements WebMvcConfigurer {

	@Override
	public void configureViewResolvers(ViewResolverRegistry registry) {
		registry.scriptTemplate();
	}

	@Bean
	public ScriptTemplateConfigurer configurer() {
		ScriptTemplateConfigurer configurer = new ScriptTemplateConfigurer();
		configurer.setEngineName("jython");
		configurer.setScripts("render.py");
		configurer.setRenderFunction("render");
		return configurer;
	}
}
@Configuration
class WebConfig : WebMvcConfigurer {

	override fun configureViewResolvers(registry: ViewResolverRegistry) {
		registry.scriptTemplate()
	}

	@Bean
	fun configurer() = ScriptTemplateConfigurer().apply {
		engineName = "jython"
		setScripts("render.py")
		renderFunction = "render"
	}
}
<mvc:annotation-driven/>

<mvc:view-resolvers>
	<mvc:script-template/>
</mvc:view-resolvers>

<mvc:script-template-configurer engine-name="jython" render-function="render">
	<mvc:script location="render.py"/>
</mvc:script-template-configurer>

The render function is called with the following parameters:

  • String template: The template content

  • Map model: The view model

  • RenderingContext renderingContext: The RenderingContext that gives access to the application context, the locale, the template loader, and the URL

The controller is used to populate the model attributes and specify the view name, as the following example shows:

  • Java

  • Kotlin

@Controller
public class SampleController {

	@GetMapping("/sample")
	public String test(Model model) {
		model.addAttribute("title", "Sample title");
		model.addAttribute("body", "Sample body");
		return "template";
	}
}
@Controller
class SampleController {

	@GetMapping("/sample")
	fun test(model: Model): String {
		model["title"] = "Sample title"
		model["body"] = "Sample body"
		return "template"
	}
}

Check out the Spring Framework unit tests, Java, and resources, for more configuration examples.