org.springframework.web.servlet.view.groovy

Class GroovyMarkupConfigurer

java.lang.Object

TemplateConfiguration

org.springframework.web.servlet.view.groovy.GroovyMarkupConfigurer

All Implemented Interfaces:

Aware, InitializingBean, ApplicationContextAware, GroovyMarkupConfig

public class GroovyMarkupConfigurer
extends TemplateConfiguration
implements GroovyMarkupConfig, ApplicationContextAware, InitializingBean

An extension of Groovy's groovy.text.markup.TemplateConfiguration and an implementation of Spring MVC's GroovyMarkupConfig for creating a MarkupTemplateEngine for use in a web application. The most basic way to configure this class is to set the "resourceLoaderPath". For example:

 // Add the following to an @Configuration class

 @Bean
 public GroovyMarkupConfig groovyMarkupConfigurer() {
     GroovyMarkupConfigurer configurer = new GroovyMarkupConfigurer();
     configurer.setResourceLoaderPath("classpath:/WEB-INF/groovymarkup/");
     return configurer;
 }
 

By default this bean will create a MarkupTemplateEngine with:

• a parent ClassLoader for loading Groovy templates with their references
• the default configuration in the base class TemplateConfiguration
• a groovy.text.markup.TemplateResolver for resolving template files

You can provide the MarkupTemplateEngine instance directly to this bean in which case all other properties will not be effectively ignored.

This bean must be included in the application context of any application using the Spring MVC GroovyMarkupView for rendering. It exists purely for the purpose of configuring Groovy's Markup templates. It is not meant to be referenced by application components directly. It implements GroovyMarkupConfig to be found by GroovyMarkupView without depending on a bean name. Each DispatcherServlet can define its own GroovyMarkupConfigurer if desired.

Note that resource caching is enabled by default in MarkupTemplateEngine. Use the #setCacheTemplates(boolean) to configure that as necessary.

Spring's Groovy Markup template support requires Groovy 2.3.1 or higher.

Since:

4.1

Author:

Brian Clozel, Rossen Stoyanchev

See Also:

GroovyMarkupView, Groovy Markup Template engine documentation

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private class	GroovyMarkupConfigurer.LocaleTemplateResolver Custom template resolver that simply delegates to resolveTemplate(ClassLoader, String)..

Field Summary

Fields

Modifier and Type	Field and Description
private ApplicationContext	applicationContext
private java.lang.String	resourceLoaderPath
private MarkupTemplateEngine	templateEngine

Constructor Summary

Constructors

Constructor and Description
GroovyMarkupConfigurer()

Method Summary

Modifier and Type	Method and Description
void	afterPropertiesSet() Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).
protected java.lang.ClassLoader	createTemplateClassLoader() Create a parent ClassLoader for Groovy to use as parent ClassLoader when loading and compiling templates.
protected MarkupTemplateEngine	createTemplateEngine()
protected ApplicationContext	getApplicationContext()
java.lang.String	getResourceLoaderPath()
MarkupTemplateEngine	getTemplateEngine() Return the Groovy MarkupTemplateEngine for the current web application context.
protected java.net.URL	resolveTemplate(java.lang.ClassLoader classLoader, java.lang.String templatePath) Resolve a template from the given template path.
void	setApplicationContext(ApplicationContext applicationContext) Set the ApplicationContext that this object runs in.
void	setLocale(java.util.Locale locale) This method should not be used, since the considered Locale for resolving templates is the Locale for the current HTTP request.
void	setResourceLoaderPath(java.lang.String resourceLoaderPath) Set the Groovy Markup Template resource loader path(s) via a Spring resource location.
void	setTemplateEngine(MarkupTemplateEngine templateEngine) Set a pre-configured MarkupTemplateEngine to use for the Groovy Markup Template web configuration.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

resourceLoaderPath

private java.lang.String resourceLoaderPath

templateEngine

private MarkupTemplateEngine templateEngine

applicationContext

private ApplicationContext applicationContext

Constructor Detail

GroovyMarkupConfigurer

public GroovyMarkupConfigurer()

Method Detail

setResourceLoaderPath

public void setResourceLoaderPath(java.lang.String resourceLoaderPath)

Set the Groovy Markup Template resource loader path(s) via a Spring resource location. Accepts multiple locations as a comma-separated list of paths. Standard URLs like "file:" and "classpath:" and pseudo URLs are supported as understood by Spring's ResourceLoader. Relative paths are allowed when running in an ApplicationContext.

getResourceLoaderPath

public java.lang.String getResourceLoaderPath()

setTemplateEngine

public void setTemplateEngine(MarkupTemplateEngine templateEngine)

Set a pre-configured MarkupTemplateEngine to use for the Groovy Markup Template web configuration.

Note that this engine instance has to be manually configured, since all other bean properties of this configurer will be ignored.

getTemplateEngine

public MarkupTemplateEngine getTemplateEngine()

Description copied from interface: GroovyMarkupConfig

Return the Groovy MarkupTemplateEngine for the current web application context. May be unique to one servlet, or shared in the root context.

Specified by:

getTemplateEngine in interface GroovyMarkupConfig

Returns:

the Groovy MarkupTemplateEngine engine

setApplicationContext

public void setApplicationContext(ApplicationContext applicationContext)

Description copied from interface: ApplicationContextAware

Set the ApplicationContext that this object runs in. Normally this call will be used to initialize the object.

Invoked after population of normal bean properties but before an init callback such as InitializingBean.afterPropertiesSet() or a custom init-method. Invoked after ResourceLoaderAware.setResourceLoader(org.springframework.core.io.ResourceLoader), ApplicationEventPublisherAware.setApplicationEventPublisher(org.springframework.context.ApplicationEventPublisher) and MessageSourceAware, if applicable.

Specified by:

setApplicationContext in interface ApplicationContextAware

Parameters:

applicationContext - the ApplicationContext object to be used by this object

See Also:

BeanInitializationException

getApplicationContext

protected ApplicationContext getApplicationContext()

setLocale

public void setLocale(java.util.Locale locale)

This method should not be used, since the considered Locale for resolving templates is the Locale for the current HTTP request.

afterPropertiesSet

public void afterPropertiesSet()
                        throws java.lang.Exception

Description copied from interface: InitializingBean

Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).

This method allows the bean instance to perform initialization only possible when all bean properties have been set and to throw an exception in the event of misconfiguration.

Specified by:

afterPropertiesSet in interface InitializingBean

Throws:

java.lang.Exception - in the event of misconfiguration (such as failure to set an essential property) or if initialization fails.

createTemplateEngine

protected MarkupTemplateEngine createTemplateEngine()
                                             throws java.io.IOException

Throws:

java.io.IOException

createTemplateClassLoader

protected java.lang.ClassLoader createTemplateClassLoader()
                                                   throws java.io.IOException

Create a parent ClassLoader for Groovy to use as parent ClassLoader when loading and compiling templates.

Throws:

java.io.IOException

resolveTemplate

protected java.net.URL resolveTemplate(java.lang.ClassLoader classLoader,
                                       java.lang.String templatePath)
                                throws java.io.IOException

Resolve a template from the given template path.

The default implementation uses the Locale associated with the current request, as obtained through LocaleContextHolder, to find the template file. Effectively the locale configured at the engine level is ignored.

Throws:

java.io.IOException

See Also:

LocaleContextHolder, setLocale(java.util.Locale)