java.lang.Object
- org.springframework.ui.velocity.VelocityEngineFactory

直接已知子类:
VelocityConfigurer, VelocityEngineFactoryBean
```
@Deprecated
public class VelocityEngineFactory
extends Object
```
已过时。
as of Spring 4.3, in favor of FreeMarker
Factory that configures a VelocityEngine. Can be used standalone, but typically you will either use VelocityEngineFactoryBean for preparing a VelocityEngine as bean reference, or 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.
If "overrideLogging" is true (the default), the VelocityEngine will be configured to log via Commons Logging, that is, using CommonsLogLogChute as log system.
The simplest way to use this class is to specify a "resourceLoaderPath"; the VelocityEngine typically then does not need any further configuration.
作者:
Juergen Hoeller
另请参阅:
setConfigLocation(org.springframework.core.io.Resource), setVelocityProperties(java.util.Properties), setResourceLoaderPath(java.lang.String), setOverrideLogging(boolean), createVelocityEngine(), VelocityEngineFactoryBean, VelocityConfigurer, VelocityEngine

字段概要
字段
修饰符和类型字段说明
protected Log logger
已过时。

构造器概要
构造器
构造器说明
VelocityEngineFactory()
已过时。

方法概要

所有方法实例方法具体方法已过时的方法
修饰符和类型	方法	说明
`org.apache.velocity.app.VelocityEngine`	`createVelocityEngine()`	已过时。 Prepare the VelocityEngine instance and return it.
`protected ResourceLoader`	`getResourceLoader()`	已过时。 Return the Spring ResourceLoader to use for loading Velocity template files.
`protected void`	`initSpringResourceLoader(org.apache.velocity.app.VelocityEngine velocityEngine, String resourceLoaderPath)`	已过时。 Initialize a SpringResourceLoader for the given VelocityEngine.
`protected void`	`initVelocityResourceLoader(org.apache.velocity.app.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 org.apache.velocity.app.VelocityEngine`	`newVelocityEngine()`	已过时。 Return a new VelocityEngine.
`protected void`	`postProcessVelocityEngine(org.apache.velocity.app.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(Resource configLocation)`	已过时。 Set the location of the Velocity config file.
`void`	`setOverrideLogging(boolean overrideLogging)`	已过时。 Set whether Velocity should log via Commons Logging, i.e. whether Velocity's log system should be set to `CommonsLogLogChute`.
`void`	`setPreferFileSystemAccess(boolean preferFileSystemAccess)`	已过时。 Set whether to prefer file system access for template loading.
`void`	`setResourceLoader(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".

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详细资料
  - logger
```
protected final Log logger
```
    已过时。
- 构造器详细资料
  - VelocityEngineFactory
```
public VelocityEngineFactory()
```
    已过时。
- 方法详细资料
  - setConfigLocation
```
public void setConfigLocation(Resource configLocation)
```
    已过时。
    Set the location of the Velocity config file. Alternatively, you can specify all properties locally.
    另请参阅:
    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.
    另请参阅:
    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".
    另请参阅:
    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.
    另请参阅:
    setResourceLoader(org.springframework.core.io.ResourceLoader), setVelocityProperties(java.util.Properties), setPreferFileSystemAccess(boolean), SpringResourceLoader, FileResourceLoader
  - setResourceLoader
```
public void setResourceLoader(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.
    另请参阅:
    DefaultResourceLoader, ApplicationContext
  - getResourceLoader
```
protected ResourceLoader getResourceLoader()
```
    已过时。
    Return the Spring ResourceLoader to use for loading Velocity template files.
  - 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 resource (which will work for expanded class path resources and ServletContext resources too).
    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.
    另请参阅:
    setResourceLoaderPath(java.lang.String)
  - isPreferFileSystemAccess
```
protected boolean isPreferFileSystemAccess()
```
    已过时。
    Return whether to prefer file system access for template loading.
  - setOverrideLogging
```
public void setOverrideLogging(boolean overrideLogging)
```
    已过时。
    Set whether Velocity should log via Commons Logging, i.e. whether Velocity's log system should be set to CommonsLogLogChute. Default is "true".
  - createVelocityEngine
```
public org.apache.velocity.app.VelocityEngine createVelocityEngine()
                                                            throws IOException,
                                                                   org.apache.velocity.exception.VelocityException
```
    已过时。
    Prepare the VelocityEngine instance and return it.
    返回:
    the VelocityEngine instance
    抛出:
    IOException - if the config file wasn't found
    org.apache.velocity.exception.VelocityException - on Velocity initialization failure
  - newVelocityEngine
```
protected org.apache.velocity.app.VelocityEngine newVelocityEngine()
                                                            throws IOException,
                                                                   org.apache.velocity.exception.VelocityException
```
    已过时。
    Return a new VelocityEngine. Subclasses can override this for custom initialization, or for using a mock object for testing.
    Called by createVelocityEngine().
    返回:
    the VelocityEngine instance
    抛出:
    IOException - if a config file wasn't found
    org.apache.velocity.exception.VelocityException - on Velocity initialization failure
    另请参阅:
    createVelocityEngine()
  - initVelocityResourceLoader
```
protected void initVelocityResourceLoader(org.apache.velocity.app.VelocityEngine velocityEngine,
                                          String resourceLoaderPath)
```
    已过时。
    Initialize a Velocity resource loader for the given VelocityEngine: either a standard Velocity FileResourceLoader or a SpringResourceLoader.
    Called by createVelocityEngine().
    参数:
    velocityEngine - the VelocityEngine to configure
    resourceLoaderPath - the path to load Velocity resources from
    另请参阅:
    FileResourceLoader, SpringResourceLoader, initSpringResourceLoader(org.apache.velocity.app.VelocityEngine, java.lang.String), createVelocityEngine()
  - initSpringResourceLoader
```
protected void initSpringResourceLoader(org.apache.velocity.app.VelocityEngine velocityEngine,
                                        String resourceLoaderPath)
```
    已过时。
    Initialize a SpringResourceLoader for the given VelocityEngine.
    Called by initVelocityResourceLoader.
    参数:
    velocityEngine - the VelocityEngine to configure
    resourceLoaderPath - the path to load Velocity resources from
    另请参阅:
    SpringResourceLoader, initVelocityResourceLoader(org.apache.velocity.app.VelocityEngine, java.lang.String)
  - postProcessVelocityEngine
```
protected void postProcessVelocityEngine(org.apache.velocity.app.VelocityEngine velocityEngine)
                                  throws IOException,
                                         org.apache.velocity.exception.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().
    参数:
    velocityEngine - the current VelocityEngine
    抛出:
    IOException - if a config file wasn't found
    org.apache.velocity.exception.VelocityException - on Velocity initialization failure
    另请参阅:
    createVelocityEngine(), VelocityEngine.init()

类 VelocityEngineFactory

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

字段详细资料

logger

构造器详细资料

VelocityEngineFactory

方法详细资料

setConfigLocation

setVelocityProperties

setVelocityPropertiesMap

setResourceLoaderPath

setResourceLoader

getResourceLoader

setPreferFileSystemAccess

isPreferFileSystemAccess

setOverrideLogging

createVelocityEngine

newVelocityEngine

initVelocityResourceLoader

initSpringResourceLoader

postProcessVelocityEngine