Class VelocityEngineFactory
- java.lang.Object
-
- org.apache.velocity.spring.VelocityEngineFactory
-
- Direct Known Subclasses:
VelocityEngineFactoryBean
public class VelocityEngineFactory extends Object
Factory that configures a VelocityEngine. Can be used standalone, but typically you will either useVelocityEngineFactoryBean
for preparing a VelocityEngine as bean reference, or org.springframework.web.servlet.view.velocity.VelocityConfigurer for web views.The optional "configLocation" property sets the location of the Velocity properties file, within the current application. Velocity properties can be overridden via "velocityProperties", or even completely specified locally, avoiding the need for an external properties file.
The "resourceLoaderPath" property can be used to specify the Velocity resource loader path via Spring's Resource abstraction, possibly relative to the Spring application context.
The simplest way to use this class is to specify a
"resourceLoaderPath"
; the VelocityEngine typically then does not need any further configuration.- Since:
- 2020-05-29
- Author:
- Juergen Hoeller, Claude Brisson
- See Also:
setConfigLocation(org.springframework.core.io.Resource)
,setVelocityProperties(java.util.Properties)
,setResourceLoaderPath(java.lang.String)
,createVelocityEngine()
,VelocityEngineFactoryBean
, org.springframework.web.servlet.view.velocity.VelocityConfigurer,VelocityEngine
-
-
Field Summary
Fields Modifier and Type Field Description protected static org.slf4j.Logger
logger
-
Constructor Summary
Constructors Constructor Description VelocityEngineFactory()
-
Method Summary
All Methods Instance Methods Concrete Methods Modifier and Type Method Description VelocityEngine
createVelocityEngine()
Prepare the VelocityEngine instance and return it.protected org.springframework.core.io.ResourceLoader
getResourceLoader()
Return the Spring ResourceLoader to use for loading Velocity template files.protected void
initSpringResourceLoader(VelocityEngine velocityEngine, String resourceLoaderPath)
Initialize a SpringResourceLoader for the given VelocityEngine.protected void
initVelocityResourceLoader(VelocityEngine velocityEngine, String resourceLoaderPath)
Initialize a Velocity resource loader for the given VelocityEngine: either a standard Velocity FileResourceLoader or a SpringResourceLoader.protected boolean
isPreferFileSystemAccess()
Return whether to prefer file system access for template loading.protected VelocityEngine
newVelocityEngine()
Return a new VelocityEngine.protected void
postProcessVelocityEngine(VelocityEngine velocityEngine)
To be implemented by subclasses that want to perform custom post-processing of the VelocityEngine after this FactoryBean performed its default configuration (but before VelocityEngine.init).void
setConfigLocation(org.springframework.core.io.Resource configLocation)
Set the location of the Velocity config file.void
setPreferFileSystemAccess(boolean preferFileSystemAccess)
Set whether to prefer file system access for template loading.void
setResourceLoader(org.springframework.core.io.ResourceLoader resourceLoader)
Set the Spring ResourceLoader to use for loading Velocity template files.void
setResourceLoaderPath(String resourceLoaderPath)
Set the Velocity resource loader path via a Spring resource location.void
setVelocityProperties(Properties velocityProperties)
Set Velocity properties, like "file.resource.loader.path".void
setVelocityPropertiesMap(Map<String,Object> velocityPropertiesMap)
Set Velocity properties as Map, to allow for non-String values like "ds.resource.loader.instance".
-
-
-
Method Detail
-
setConfigLocation
public void setConfigLocation(org.springframework.core.io.Resource configLocation)
Set the location of the Velocity config file. Alternatively, you can specify all properties locally.- Parameters:
configLocation
- config resource- See Also:
setVelocityProperties(java.util.Properties)
,setResourceLoaderPath(java.lang.String)
-
setVelocityProperties
public void setVelocityProperties(Properties velocityProperties)
Set Velocity properties, like "file.resource.loader.path". Can be used to override values in a Velocity config file, or to specify all necessary properties locally.Note that the Velocity resource loader path also be set to any Spring resource location via the "resourceLoaderPath" property. Setting it here is just necessary when using a non-file-based resource loader.
- Parameters:
velocityProperties
- engine properties to include- See Also:
setVelocityPropertiesMap(java.util.Map<java.lang.String, java.lang.Object>)
,setConfigLocation(org.springframework.core.io.Resource)
,setResourceLoaderPath(java.lang.String)
-
setVelocityPropertiesMap
public void setVelocityPropertiesMap(Map<String,Object> velocityPropertiesMap)
Set Velocity properties as Map, to allow for non-String values like "ds.resource.loader.instance".- Parameters:
velocityPropertiesMap
- engine properties to include- See Also:
setVelocityProperties(java.util.Properties)
-
setResourceLoaderPath
public void setResourceLoaderPath(String resourceLoaderPath)
Set the Velocity resource loader path via a Spring resource location. Accepts multiple locations in Velocity's comma-separated path style.When populated via a String, standard URLs like "file:" and "classpath:" pseudo URLs are supported, as understood by ResourceLoader. Allows for relative paths when running in an ApplicationContext.
Will define a path for the default Velocity resource loader with the name "file". If the specified resource cannot be resolved to a
java.io.File
, a generic SpringResourceLoader will be used under the name "spring", without modification detection.Note that resource caching will be enabled in any case. With the file resource loader, the last-modified timestamp will be checked on access to detect changes. With SpringResourceLoader, the resource will be cached forever (for example for class path resources).
To specify a modification check interval for files, use Velocity's standard "file.resource.loader.modificationCheckInterval" property. By default, the file timestamp is checked on every access (which is surprisingly fast). Of course, this just applies when loading resources from the file system.
To enforce the use of SpringResourceLoader, i.e. to not resolve a path as file system resource in any case, turn off the "preferFileSystemAccess" flag. See the latter's javadoc for details.
- Parameters:
resourceLoaderPath
- comma-separated resource paths- See Also:
setResourceLoader(org.springframework.core.io.ResourceLoader)
,setVelocityProperties(java.util.Properties)
,setPreferFileSystemAccess(boolean)
,SpringResourceLoader
,FileResourceLoader
-
setResourceLoader
public void setResourceLoader(org.springframework.core.io.ResourceLoader resourceLoader)
Set the Spring ResourceLoader to use for loading Velocity template files.The default is DefaultResourceLoader. Will get overridden by the ApplicationContext if running in a context.
- Parameters:
resourceLoader
- Spring resource loader to ue- See Also:
DefaultResourceLoader
,ApplicationContext
-
getResourceLoader
protected org.springframework.core.io.ResourceLoader getResourceLoader()
Return the Spring ResourceLoader to use for loading Velocity template files.- Returns:
- Spring resource loader to use
-
setPreferFileSystemAccess
public void setPreferFileSystemAccess(boolean preferFileSystemAccess)
Set whether to prefer file system access for template loading. File system access enables hot detection of template changes.If this is enabled, VelocityEngineFactory will try to resolve the specified "resourceLoaderPath" as file system resources, but only when non-classpath resource paths are included.
Default is "true". Turn this off to always load via SpringResourceLoader (i.e. as stream, without hot detection of template changes), which might be necessary if some of your templates reside in an expanded classes directory while others reside in jar files.
- Parameters:
preferFileSystemAccess
- whether to rely on file-based loading when possible- See Also:
setResourceLoaderPath(java.lang.String)
-
isPreferFileSystemAccess
protected boolean isPreferFileSystemAccess()
Return whether to prefer file system access for template loading.- Returns:
- whether to prefer file system access for template loading
-
createVelocityEngine
public VelocityEngine createVelocityEngine() throws IOException, VelocityException
Prepare the VelocityEngine instance and return it.- Returns:
- the VelocityEngine instance
- Throws:
IOException
- if the config file wasn't foundVelocityException
- on Velocity initialization failure
-
newVelocityEngine
protected VelocityEngine newVelocityEngine() throws IOException, VelocityException
Return a new VelocityEngine. Subclasses can override this for custom initialization, or for using a mock object for testing.Called by
createVelocityEngine()
.- Returns:
- the VelocityEngine instance
- Throws:
IOException
- if a config file wasn't foundVelocityException
- on Velocity initialization failure- See Also:
createVelocityEngine()
-
initVelocityResourceLoader
protected void initVelocityResourceLoader(VelocityEngine velocityEngine, String resourceLoaderPath)
Initialize a Velocity resource loader for the given VelocityEngine: either a standard Velocity FileResourceLoader or a SpringResourceLoader.Called by
createVelocityEngine()
.- Parameters:
velocityEngine
- the VelocityEngine to configureresourceLoaderPath
- the path to load Velocity resources from- See Also:
FileResourceLoader
,SpringResourceLoader
,initSpringResourceLoader(org.apache.velocity.app.VelocityEngine, java.lang.String)
,createVelocityEngine()
-
initSpringResourceLoader
protected void initSpringResourceLoader(VelocityEngine velocityEngine, String resourceLoaderPath)
Initialize a SpringResourceLoader for the given VelocityEngine.Called by
initVelocityResourceLoader
.- Parameters:
velocityEngine
- the VelocityEngine to configureresourceLoaderPath
- the path to load Velocity resources from- See Also:
SpringResourceLoader
,initVelocityResourceLoader(org.apache.velocity.app.VelocityEngine, java.lang.String)
-
postProcessVelocityEngine
protected void postProcessVelocityEngine(VelocityEngine velocityEngine) throws IOException, VelocityException
To be implemented by subclasses that want to perform custom post-processing of the VelocityEngine after this FactoryBean performed its default configuration (but before VelocityEngine.init).Called by
createVelocityEngine()
.- Parameters:
velocityEngine
- the current VelocityEngine- Throws:
IOException
- if a config file wasn't foundVelocityException
- on Velocity initialization failure- See Also:
createVelocityEngine()
,VelocityEngine.init()
-
-