Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove Velocity support

Browse Source 
Issue: SPR-13795
This commit is contained in:
Juergen Hoeller
2016-07-04 23:30:58 +02:00
parent 4027bda168
commit ff6ead1fff
54 changed files with 135 additions and 4242 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
spring-webmvc/src/main/java/org/springframework/web/servlet/config/MvcNamespaceHandler.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2015 the original author or authors.
* Copyright 2002-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -41,7 +41,6 @@ public class MvcNamespaceHandler extends NamespaceHandlerSupport {
registerBeanDefinitionParser("view-resolvers", new ViewResolversBeanDefinitionParser());
registerBeanDefinitionParser("tiles-configurer", new TilesConfigurerBeanDefinitionParser());
registerBeanDefinitionParser("freemarker-configurer", new FreeMarkerConfigurerBeanDefinitionParser());
registerBeanDefinitionParser("velocity-configurer", new VelocityConfigurerBeanDefinitionParser());
registerBeanDefinitionParser("groovy-configurer", new GroovyMarkupConfigurerBeanDefinitionParser());
registerBeanDefinitionParser("script-template-configurer", new ScriptTemplateConfigurerBeanDefinitionParser());
registerBeanDefinitionParser("cors", new CorsBeanDefinitionParser());

59
spring-webmvc/src/main/java/org/springframework/web/servlet/config/VelocityConfigurerBeanDefinitionParser.java
View File

@@ -1,59 +0,0 @@
/*
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.servlet.config;
import org.w3c.dom.Element;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.AbstractSimpleBeanDefinitionParser;
import org.springframework.beans.factory.xml.ParserContext;
/**
* Parse the <mvc:velocity-configurer> MVC namespace element and register an
* VelocityConfigurer bean
*
* @author Rossen Stoyanchev
* @since 4.1
*/
public class VelocityConfigurerBeanDefinitionParser extends AbstractSimpleBeanDefinitionParser {
public static final String BEAN_NAME = "mvcVelocityConfigurer";
@Override
protected String resolveId(Element element, AbstractBeanDefinition definition, ParserContext parserContext) {
return BEAN_NAME;
}
@Override
protected String getBeanClassName(Element element) {
return "org.springframework.web.servlet.view.velocity.VelocityConfigurer";
}
@Override
protected boolean isEligibleAttribute(String attributeName) {
return attributeName.equals("resource-loader-path");
}
@Override
protected void postProcess(BeanDefinitionBuilder builder, Element element) {
if (!builder.getBeanDefinition().hasAttribute("resourceLoaderPath")) {
builder.getBeanDefinition().setAttribute("resourceLoaderPath", "/WEB-INF/");
}
}
}

6
spring-webmvc/src/main/java/org/springframework/web/servlet/config/ViewResolversBeanDefinitionParser.java
View File

@@ -58,7 +58,6 @@ import org.springframework.web.servlet.view.tiles3.TilesViewResolver;
* @since 4.1
* @see TilesConfigurerBeanDefinitionParser
* @see FreeMarkerConfigurerBeanDefinitionParser
* @see VelocityConfigurerBeanDefinitionParser
* @see GroovyMarkupConfigurerBeanDefinitionParser
* @see ScriptTemplateConfigurerBeanDefinitionParser
*/
@@ -98,11 +97,6 @@ public class ViewResolversBeanDefinitionParser implements BeanDefinitionParser {
resolverBeanDef.getPropertyValues().add("suffix", ".ftl");
addUrlBasedViewResolverProperties(resolverElement, resolverBeanDef);
}
else if ("velocity".equals(name)) {
resolverBeanDef = new RootBeanDefinition(org.springframework.web.servlet.view.velocity.VelocityViewResolver.class);
resolverBeanDef.getPropertyValues().add("suffix", ".vm");
addUrlBasedViewResolverProperties(resolverElement, resolverBeanDef);
}
else if ("groovy".equals(name)) {
resolverBeanDef = new RootBeanDefinition(GroovyMarkupViewResolver.class);
resolverBeanDef.getPropertyValues().add("suffix", ".tpl");

29
spring-webmvc/src/main/java/org/springframework/web/servlet/config/annotation/ViewResolverRegistry.java
View File

@@ -190,26 +190,6 @@ public class ViewResolverRegistry {
return registration;
}
/**
* Register Velocity view resolver with an empty default view name
* prefix and a default suffix of ".vm".
* <p><strong>Note</strong> that you must also configure Velocity by adding a
* {@link org.springframework.web.servlet.view.velocity.VelocityConfigurer} bean.
* @deprecated as of Spring 4.3, in favor of FreeMarker
*/
@Deprecated
public UrlBasedViewResolverRegistration velocity() {
if (this.applicationContext != null && !hasBeanOfType(org.springframework.web.servlet.view.velocity.VelocityConfigurer.class)) {
throw new BeanInitializationException("In addition to a Velocity view resolver " +
"there must also be a single VelocityConfig bean in this web application context " +
"(or its parent): VelocityConfigurer is the usual implementation. " +
"This bean may be given any name.");
}
VelocityRegistration registration = new VelocityRegistration();
this.viewResolvers.add(registration.getViewResolver());
return registration;
}
/**
* Register a Groovy markup view resolver with an empty default view name
* prefix and a default suffix of ".tpl".
@@ -309,15 +289,6 @@ public class ViewResolverRegistry {
}
}
private static class VelocityRegistration extends UrlBasedViewResolverRegistration {
@SuppressWarnings("deprecation")
public VelocityRegistration() {
super(new org.springframework.web.servlet.view.velocity.VelocityViewResolver());
getViewResolver().setSuffix(".vm");
}
}
private static class FreeMarkerRegistration extends UrlBasedViewResolverRegistration {
public FreeMarkerRegistration() {

2
spring-webmvc/src/main/java/org/springframework/web/servlet/support/BindStatus.java
View File

@@ -31,7 +31,7 @@ import org.springframework.web.util.HtmlUtils;
/**
* Simple adapter to expose the bind status of a field or object.
* Set as a variable both by the JSP bind tag and Velocity/FreeMarker macros.
* Set as a variable both by the JSP bind tag and FreeMarker macros.
*
* <p>Obviously, object status representations (i.e. errors at the object level
* rather than the field level) do not have an expression and a value but only

15
spring-webmvc/src/main/java/org/springframework/web/servlet/support/RequestContext.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2015 the original author or authors.
* Copyright 2002-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -53,17 +53,18 @@ import org.springframework.web.util.UrlPathHelper;
import org.springframework.web.util.WebUtils;
/**
* Context holder for request-specific state, like current web application context, current locale, current theme,
* and potential binding errors. Provides easy access to localized messages and Errors instances.
* Context holder for request-specific state, like current web application context, current locale,
* current theme, and potential binding errors. Provides easy access to localized messages and
* Errors instances.
*
* <p>Suitable for exposition to views, and usage within JSP's "useBean" tag, JSP scriptlets, JSTL EL, Velocity
* templates, etc. Necessary for views that do not have access to the servlet request, like Velocity templates.
* <p>Suitable for exposition to views, and usage within JSP's "useBean" tag, JSP scriptlets, JSTL EL,
* etc. Necessary for views that do not have access to the servlet request, like FreeMarker templates.
*
* <p>Can be instantiated manually, or automatically exposed to views as model attribute via AbstractView's
* "requestContextAttribute" property.
*
* <p>Will also work outside of DispatcherServlet requests, accessing the root WebApplicationContext and using
* an appropriate fallback for the locale (the HttpServletRequest's primary locale).
* <p>Will also work outside of DispatcherServlet requests, accessing the root WebApplicationContext
* and using an appropriate fallback for the locale (the HttpServletRequest's primary locale).
*
* @author Juergen Hoeller
* @author Rossen Stoyanchev

8
spring-webmvc/src/main/java/org/springframework/web/servlet/view/AbstractCachingViewResolver.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2013 the original author or authors.
* Copyright 2002-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -123,8 +123,8 @@ public abstract class AbstractCachingViewResolver extends WebApplicationObjectSu
* Note that this flag only applies if the general {@link #setCache "cache"}
* flag is kept at its default of "true" as well.
* <p>Of specific interest is the ability for some AbstractUrlBasedView
* implementations (FreeMarker, Velocity, Tiles) to check if an underlying
* resource exists via {@link AbstractUrlBasedView#checkResource(Locale)}.
* implementations (FreeMarker, Tiles) to check if an underlying resource
* exists via {@link AbstractUrlBasedView#checkResource(Locale)}.
* With this flag set to "false", an underlying resource that re-appears
* is noticed and used. With the flag set to "true", one check is made only.
*/
@@ -185,7 +185,7 @@ public abstract class AbstractCachingViewResolver extends WebApplicationObjectSu
/**
* Provides functionality to clear the cache for a certain view.
* <p>This can be handy in case developer are able to modify views
* (e.g. Velocity templates) at runtime after which you'd need to
* (e.g. FreeMarker templates) at runtime after which you'd need to
* clear the cache for the specified view.
* @param viewName the view name for which the cached view object
* (if any) needs to be removed

16
spring-webmvc/src/main/java/org/springframework/web/servlet/view/AbstractTemplateView.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2015 the original author or authors.
* Copyright 2002-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -26,10 +26,9 @@ import javax.servlet.http.HttpSession;
import org.springframework.web.servlet.support.RequestContext;
/**
* Adapter base class for template-based view technologies such as
* Velocity and FreeMarker, with the ability to use request and session
* attributes in their model and the option to expose helper objects
* for Spring's Velocity/FreeMarker macro library.
* Adapter base class for template-based view technologies such as FreeMarker,
* with the ability to use request and session attributes in their model and
* the option to expose helper objects for Spring's FreeMarker macro library.
*
* <p>JSP/JSTL and other view technologies automatically have access to the
* HttpServletRequest object and thereby the request/session attributes
@@ -40,7 +39,6 @@ import org.springframework.web.servlet.support.RequestContext;
* @author Darren Davison
* @since 1.0.2
* @see AbstractTemplateViewResolver
* @see org.springframework.web.servlet.view.velocity.VelocityView
* @see org.springframework.web.servlet.view.freemarker.FreeMarkerView
*/
public abstract class AbstractTemplateView extends AbstractUrlBasedView {
@@ -102,9 +100,9 @@ public abstract class AbstractTemplateView extends AbstractUrlBasedView {
/**
* Set whether to expose a RequestContext for use by Spring's macro library,
* under the name "springMacroRequestContext". Default is "true".
* <p>Currently needed for Spring's Velocity and FreeMarker default macros.
* Note that this is <i>not</i> required for templates that use HTML
* forms <i>unless</i> you wish to take advantage of the Spring helper macros.
* <p>Currently needed for Spring's FreeMarker default macros.
* Note that this is <i>not</i> required for templates that use HTML forms
* <i>unless</i> you wish to take advantage of the Spring helper macros.
* @see #SPRING_MACRO_REQUEST_CONTEXT_ATTRIBUTE
*/
public void setExposeSpringMacroHelpers(boolean exposeSpringMacroHelpers) {

11
spring-webmvc/src/main/java/org/springframework/web/servlet/view/AbstractTemplateViewResolver.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2007 the original author or authors.
* Copyright 2002-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -17,17 +17,14 @@
package org.springframework.web.servlet.view;
/**
* Abstract base class for template view resolvers,
* in particular for Velocity and FreeMarker views.
* Abstract base class for template view resolvers, in particular for FreeMarker views.
*
* <p>Provides a convenient way to specify {@link AbstractTemplateView}'s
* exposure flags for request attributes, session attributes,
* and Spring's macro helpers.
* <p>Provides a convenient way to specify {@link AbstractTemplateView}'s exposure
* flags for request attributes, session attributes, and Spring's macro helpers.
*
* @author Juergen Hoeller
* @since 1.1
* @see AbstractTemplateView
* @see org.springframework.web.servlet.view.velocity.VelocityViewResolver
* @see org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver
*/
public class AbstractTemplateViewResolver extends UrlBasedViewResolver {

6
spring-webmvc/src/main/java/org/springframework/web/servlet/view/UrlBasedViewResolver.java
View File

@@ -36,9 +36,8 @@ import org.springframework.web.servlet.View;
* (i.e. the symbolic name is the unique part of the resource's filename),
* without the need for a dedicated mapping to be defined for each view.
*
* <p>Supports {@link AbstractUrlBasedView} subclasses like {@link InternalResourceView},
* {@link org.springframework.web.servlet.view.velocity.VelocityView} and
* {@link org.springframework.web.servlet.view.freemarker.FreeMarkerView}.
* <p>Supports {@link AbstractUrlBasedView} subclasses like {@link InternalResourceView}
* and {@link org.springframework.web.servlet.view.freemarker.FreeMarkerView}.
* The view class for all views generated by this resolver can be specified
* via the "viewClass" property.
*
@@ -79,7 +78,6 @@ import org.springframework.web.servlet.View;
* @see #REDIRECT_URL_PREFIX
* @see AbstractUrlBasedView
* @see InternalResourceView
* @see org.springframework.web.servlet.view.velocity.VelocityView
* @see org.springframework.web.servlet.view.freemarker.FreeMarkerView
*/
public class UrlBasedViewResolver extends AbstractCachingViewResolver implements Ordered {

2
spring-webmvc/src/main/java/org/springframework/web/servlet/view/package-info.java
View File

@@ -3,7 +3,7 @@
* including abstract base classes for custom implementations.
*
* <p>Application developers don't usually need to implement views,
* as the framework provides standard views for JSPs, Velocity,
* as the framework provides standard views for JSPs, FreeMarker,
* XSLT, etc. However, the ability to implement custom views easily
* by subclassing the AbstractView class in this package can be
* very helpful if an application has unusual view requirements.

41
spring-webmvc/src/main/java/org/springframework/web/servlet/view/velocity/VelocityConfig.java
View File

@@ -1,41 +0,0 @@
/*
* Copyright 2002-2012 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.servlet.view.velocity;
import org.apache.velocity.app.VelocityEngine;
/**
* Interface to be implemented by objects that configure and manage a
* VelocityEngine for automatic lookup in a web environment. Detected
* and used by VelocityView.
*
* @author Rod Johnson
* @see VelocityConfigurer
* @see VelocityView
* @deprecated as of Spring 4.3, in favor of FreeMarker
*/
@Deprecated
public interface VelocityConfig {
/**
* Return the VelocityEngine for the current web application context.
* May be unique to one servlet, or shared in the root context.
* @return the VelocityEngine
*/
VelocityEngine getVelocityEngine();
}

151
spring-webmvc/src/main/java/org/springframework/web/servlet/view/velocity/VelocityConfigurer.java
View File

@@ -1,151 +0,0 @@
/*
* Copyright 2002-2012 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.servlet.view.velocity;
import java.io.IOException;
import javax.servlet.ServletContext;
import org.apache.velocity.app.VelocityEngine;
import org.apache.velocity.exception.VelocityException;
import org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.web.context.ServletContextAware;
/**
* JavaBean to configure Velocity for web usage, via the "configLocation"
* and/or "velocityProperties" and/or "resourceLoaderPath" bean properties.
* The simplest way to use this class is to specify just a "resourceLoaderPath";
* you do not need any further configuration then.
*
* <pre class="code">
* &lt;bean id="velocityConfig" class="org.springframework.web.servlet.view.velocity.VelocityConfigurer"&gt;
* &lt;property name="resourceLoaderPath">&lt;value&gt;/WEB-INF/velocity/&lt;/value>&lt;/property&gt;
* &lt;/bean&gt;</pre>
*
* This bean must be included in the application context of any application
* using Spring's {@link VelocityView} for web MVC. It exists purely to configure
* Velocity; it is not meant to be referenced by application components (just
* internally by VelocityView). This class implements {@link VelocityConfig}
* in order to be found by VelocityView without depending on the bean name of
* this configurer. Each DispatcherServlet may define its own VelocityConfigurer
* if desired, potentially with different template loader paths.
*
* <p>Note that you can also refer to a pre-configured VelocityEngine
* instance via the "velocityEngine" property, e.g. set up by
* {@link org.springframework.ui.velocity.VelocityEngineFactoryBean},
* This allows to share a VelocityEngine for web and email usage, for example.
*
* <p>This configurer registers the "spring.vm" Velocimacro library for web views
* (contained in this package and thus in {@code spring.jar}), which makes
* all of Spring's default Velocity macros available to the views.
* This allows for using the Spring-provided macros such as follows:
*
* <pre class="code">
* #springBind("person.age")
* age is ${status.value}</pre>
*
* @author Rod Johnson
* @author Juergen Hoeller
* @author Darren Davison
* @see #setConfigLocation
* @see #setVelocityProperties
* @see #setResourceLoaderPath
* @see #setVelocityEngine
* @see VelocityView
* @deprecated as of Spring 4.3, in favor of FreeMarker
*/
@Deprecated
public class VelocityConfigurer extends org.springframework.ui.velocity.VelocityEngineFactory
implements VelocityConfig, InitializingBean, ResourceLoaderAware, ServletContextAware {
/** the name of the resource loader for Spring's bind macros */
private static final String SPRING_MACRO_RESOURCE_LOADER_NAME = "springMacro";
/** the key for the class of Spring's bind macro resource loader */
private static final String SPRING_MACRO_RESOURCE_LOADER_CLASS = "springMacro.resource.loader.class";
/** the name of Spring's default bind macro library */
private static final String SPRING_MACRO_LIBRARY = "org/springframework/web/servlet/view/velocity/spring.vm";
private VelocityEngine velocityEngine;
private ServletContext servletContext;
/**
* Set a pre-configured VelocityEngine to use for the Velocity web
* configuration: e.g. a shared one for web and email usage, set up via
* {@link org.springframework.ui.velocity.VelocityEngineFactoryBean}.
* <p>Note that the Spring macros will <i>not</i> be enabled automatically in
* case of an external VelocityEngine passed in here. Make sure to include
* {@code spring.vm} in your template loader path in such a scenario
* (if there is an actual need to use those macros).
* <p>If this is not set, VelocityEngineFactory's properties
* (inherited by this class) have to be specified.
*/
public void setVelocityEngine(VelocityEngine velocityEngine) {
this.velocityEngine = velocityEngine;
}
@Override
public void setServletContext(ServletContext servletContext) {
this.servletContext = servletContext;
}
/**
* Initialize VelocityEngineFactory's VelocityEngine
* if not overridden by a pre-configured VelocityEngine.
* @see #createVelocityEngine
* @see #setVelocityEngine
*/
@Override
public void afterPropertiesSet() throws IOException, VelocityException {
if (this.velocityEngine == null) {
this.velocityEngine = createVelocityEngine();
}
}
/**
* Provides a ClasspathResourceLoader in addition to any default or user-defined
* loader in order to load the spring Velocity macros from the class path.
* @see org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader
*/
@Override
protected void postProcessVelocityEngine(VelocityEngine velocityEngine) {
velocityEngine.setApplicationAttribute(ServletContext.class.getName(), this.servletContext);
velocityEngine.setProperty(
SPRING_MACRO_RESOURCE_LOADER_CLASS, ClasspathResourceLoader.class.getName());
velocityEngine.addProperty(
VelocityEngine.RESOURCE_LOADER, SPRING_MACRO_RESOURCE_LOADER_NAME);
velocityEngine.addProperty(
VelocityEngine.VM_LIBRARY, SPRING_MACRO_LIBRARY);
if (logger.isInfoEnabled()) {
logger.info("ClasspathResourceLoader with name '" + SPRING_MACRO_RESOURCE_LOADER_NAME +
"' added to configured VelocityEngine");
}
}
@Override
public VelocityEngine getVelocityEngine() {
return this.velocityEngine;
}
}

188
spring-webmvc/src/main/java/org/springframework/web/servlet/view/velocity/VelocityLayoutView.java
View File

@@ -1,188 +0,0 @@
/*
* Copyright 2002-2012 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.servlet.view.velocity;
import java.io.StringWriter;
import java.util.Locale;
import javax.servlet.http.HttpServletResponse;
import org.apache.velocity.Template;
import org.apache.velocity.context.Context;
import org.apache.velocity.exception.ResourceNotFoundException;
import org.springframework.core.NestedIOException;
/**
* VelocityLayoutView emulates the functionality offered by Velocity's
* VelocityLayoutServlet to ease page composition from different templates.
*
* <p>The {@code url} property should be set to the content template
* for the view, and the layout template location should be specified as
* {@code layoutUrl} property. A view can override the configured
* layout template location by setting the appropriate key (the default
* is "layout") in the content template.
*
* <p>When the view is rendered, the VelocityContext is first merged with
* the content template (specified by the {@code url} property) and
* then merged with the layout template to produce the final output.
*
* <p>The layout template can include the screen content through a
* VelocityContext variable (the default is "screen_content").
* At runtime, this variable will contain the rendered content template.
*
* @author Darren Davison
* @author Juergen Hoeller
* @since 1.2
* @see #setLayoutUrl
* @see #setLayoutKey
* @see #setScreenContentKey
* @deprecated as of Spring 4.3, in favor of FreeMarker
*/
@Deprecated
public class VelocityLayoutView extends VelocityToolboxView {
/**
* The default {@link #setLayoutUrl(String) layout url}.
*/
public static final String DEFAULT_LAYOUT_URL = "layout.vm";
/**
* The default {@link #setLayoutKey(String) layout key}.
*/
public static final String DEFAULT_LAYOUT_KEY = "layout";
/**
* The default {@link #setScreenContentKey(String) screen content key}.
*/
public static final String DEFAULT_SCREEN_CONTENT_KEY = "screen_content";
private String layoutUrl = DEFAULT_LAYOUT_URL;
private String layoutKey = DEFAULT_LAYOUT_KEY;
private String screenContentKey = DEFAULT_SCREEN_CONTENT_KEY;
/**
* Set the layout template to use. Default is {@link #DEFAULT_LAYOUT_URL "layout.vm"}.
* @param layoutUrl the template location (relative to the template
* root directory)
*/
public void setLayoutUrl(String layoutUrl) {
this.layoutUrl = layoutUrl;
}
/**
* Set the context key used to specify an alternate layout to be used instead
* of the default layout. Screen content templates can override the layout
* template that they wish to be wrapped with by setting this value in the
* template, for example:<br>
* {@code #set($layout = "MyLayout.vm" )}
* <p>Default key is {@link #DEFAULT_LAYOUT_KEY "layout"}, as illustrated above.
* @param layoutKey the name of the key you wish to use in your
* screen content templates to override the layout template
*/
public void setLayoutKey(String layoutKey) {
this.layoutKey = layoutKey;
}
/**
* Set the name of the context key that will hold the content of
* the screen within the layout template. This key must be present
* in the layout template for the current screen to be rendered.
* <p>Default is {@link #DEFAULT_SCREEN_CONTENT_KEY "screen_content"}:
* accessed in VTL as {@code $screen_content}.
* @param screenContentKey the name of the screen content key to use
*/
public void setScreenContentKey(String screenContentKey) {
this.screenContentKey = screenContentKey;
}
/**
* Overrides {@code VelocityView.checkTemplate()} to additionally check
* that both the layout template and the screen content template can be loaded.
* Note that during rendering of the screen content, the layout template
* can be changed which may invalidate any early checking done here.
*/
@Override
public boolean checkResource(Locale locale) throws Exception {
if (!super.checkResource(locale)) {
return false;
}
try {
// Check that we can get the template, even if we might subsequently get it again.
getTemplate(this.layoutUrl);
return true;
}
catch (ResourceNotFoundException ex) {
throw new NestedIOException("Cannot find Velocity template for URL [" + this.layoutUrl +
"]: Did you specify the correct resource loader path?", ex);
}
catch (Exception ex) {
throw new NestedIOException(
"Could not load Velocity template for URL [" + this.layoutUrl + "]", ex);
}
}
/**
* Overrides the normal rendering process in order to pre-process the Context,
* merging it with the screen template into a single value (identified by the
* value of screenContentKey). The layout template is then merged with the
* modified Context in the super class.
*/
@Override
protected void doRender(Context context, HttpServletResponse response) throws Exception {
renderScreenContent(context);
// Velocity context now includes any mappings that were defined
// (via #set) in screen content template.
// The screen template can overrule the layout by doing
// #set( $layout = "MyLayout.vm" )
String layoutUrlToUse = (String) context.get(this.layoutKey);
if (layoutUrlToUse != null) {
if (logger.isDebugEnabled()) {
logger.debug("Screen content template has requested layout [" + layoutUrlToUse + "]");
}
}
else {
// No explicit layout URL given -> use default layout of this view.
layoutUrlToUse = this.layoutUrl;
}
mergeTemplate(getTemplate(layoutUrlToUse), context, response);
}
/**
* The resulting context contains any mappings from render, plus screen content.
*/
private void renderScreenContent(Context velocityContext) throws Exception {
if (logger.isDebugEnabled()) {
logger.debug("Rendering screen content template [" + getUrl() + "]");
}
StringWriter sw = new StringWriter();
Template screenContentTemplate = getTemplate(getUrl());
screenContentTemplate.merge(velocityContext, sw);
// Put rendered content into Velocity context.
velocityContext.put(this.screenContentKey, sw.toString());
}
}

110
spring-webmvc/src/main/java/org/springframework/web/servlet/view/velocity/VelocityLayoutViewResolver.java
View File

@@ -1,110 +0,0 @@
/*
* Copyright 2002-2012 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.servlet.view.velocity;
import org.springframework.web.servlet.view.AbstractUrlBasedView;
/**
* Convenience subclass of VelocityViewResolver, adding support
* for VelocityLayoutView and its properties.
*
* <p>See VelocityViewResolver's javadoc for general usage info.
*
* @author Juergen Hoeller
* @since 1.2.7
* @see VelocityViewResolver
* @see VelocityLayoutView
* @see #setLayoutUrl
* @see #setLayoutKey
* @see #setScreenContentKey
* @deprecated as of Spring 4.3, in favor of FreeMarker
*/
@Deprecated
public class VelocityLayoutViewResolver extends VelocityViewResolver {
private String layoutUrl;
private String layoutKey;
private String screenContentKey;
/**
* Requires VelocityLayoutView.
* @see VelocityLayoutView
*/
@Override
protected Class<?> requiredViewClass() {
return VelocityLayoutView.class;
}
/**
* Set the layout template to use. Default is "layout.vm".
* @param layoutUrl the template location (relative to the template
* root directory)
* @see VelocityLayoutView#setLayoutUrl
*/
public void setLayoutUrl(String layoutUrl) {
this.layoutUrl = layoutUrl;
}
/**
* Set the context key used to specify an alternate layout to be used instead
* of the default layout. Screen content templates can override the layout
* template that they wish to be wrapped with by setting this value in the
* template, for example:<br>
* {@code #set($layout = "MyLayout.vm" )}
* <p>The default key is "layout", as illustrated above.
* @param layoutKey the name of the key you wish to use in your
* screen content templates to override the layout template
* @see VelocityLayoutView#setLayoutKey
*/
public void setLayoutKey(String layoutKey) {
this.layoutKey = layoutKey;
}
/**
* Set the name of the context key that will hold the content of
* the screen within the layout template. This key must be present
* in the layout template for the current screen to be rendered.
* <p>Default is "screen_content": accessed in VTL as
* {@code $screen_content}.
* @param screenContentKey the name of the screen content key to use
* @see VelocityLayoutView#setScreenContentKey
*/
public void setScreenContentKey(String screenContentKey) {
this.screenContentKey = screenContentKey;
}
@Override
protected AbstractUrlBasedView buildView(String viewName) throws Exception {
VelocityLayoutView view = (VelocityLayoutView) super.buildView(viewName);
// Use not-null checks to preserve VelocityLayoutView's defaults.
if (this.layoutUrl != null) {
view.setLayoutUrl(this.layoutUrl);
}
if (this.layoutKey != null) {
view.setLayoutKey(this.layoutKey);
}
if (this.screenContentKey != null) {
view.setScreenContentKey(this.screenContentKey);
}
return view;
}
}

134
spring-webmvc/src/main/java/org/springframework/web/servlet/view/velocity/VelocityToolboxView.java
View File

@@ -1,134 +0,0 @@
/*
* Copyright 2002-2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.servlet.view.velocity;
import java.lang.reflect.Method;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.context.Context;
import org.apache.velocity.tools.view.ToolboxManager;
import org.apache.velocity.tools.view.context.ChainedContext;
import org.apache.velocity.tools.view.servlet.ServletToolboxManager;
import org.springframework.util.ClassUtils;
import org.springframework.util.ReflectionUtils;
/**
* {@link VelocityView} subclass which adds support for Velocity Tools toolboxes
* and Velocity Tools ViewTool callbacks / Velocity Tools 1.3 init methods.
*
* <p>Specify a "toolboxConfigLocation", for example "/WEB-INF/toolbox.xml",
* to automatically load a Velocity Tools toolbox definition file and expose
* all defined tools in the specified scopes. If no config location is
* specified, no toolbox will be loaded and exposed.
*
* <p>This view will always create a special Velocity context, namely an
* instance of the ChainedContext class which is part of the view package
* of Velocity tools. This allows to use tools from the view package of
* Velocity Tools, like LinkTool, which need to be initialized with a special
* context that implements the ViewContext interface (i.e. a ChainedContext).
*
* <p>This view also checks tools that are specified as "toolAttributes":
* If they implement the ViewTool interface, they will get initialized with
* the Velocity context. This allows tools from the view package of Velocity
* Tools, such as LinkTool, to be defined as
* {@link #setToolAttributes "toolAttributes"} on a VelocityToolboxView,
* instead of in a separate toolbox XML file.
*
* <p>This is a separate class mainly to avoid a required dependency on
* the view package of Velocity Tools in {@link VelocityView} itself.
* As of Spring 3.0, this class requires Velocity Tools 1.3 or higher.
*
* @author Juergen Hoeller
* @since 1.1.3
* @see #setToolboxConfigLocation
* @see #initTool
* @see org.apache.velocity.tools.view.context.ViewContext
* @see org.apache.velocity.tools.view.context.ChainedContext
* @deprecated as of Spring 4.3, in favor of FreeMarker
*/
@Deprecated
public class VelocityToolboxView extends VelocityView {
private String toolboxConfigLocation;
/**
* Set a Velocity Toolbox config location, for example "/WEB-INF/toolbox.xml",
* to automatically load a Velocity Tools toolbox definition file and expose
* all defined tools in the specified scopes. If no config location is
* specified, no toolbox will be loaded and exposed.
* <p>The specified location string needs to refer to a ServletContext
* resource, as expected by ServletToolboxManager which is part of
* the view package of Velocity Tools.
* @see org.apache.velocity.tools.view.servlet.ServletToolboxManager#getInstance
*/
public void setToolboxConfigLocation(String toolboxConfigLocation) {
this.toolboxConfigLocation = toolboxConfigLocation;
}
/**
* Return the Velocity Toolbox config location, if any.
*/
protected String getToolboxConfigLocation() {
return this.toolboxConfigLocation;
}
/**
* Overridden to create a ChainedContext, which is part of the view package
* of Velocity Tools, as special context. ChainedContext is needed for
* initialization of ViewTool instances.
* @see #initTool
*/
@Override
protected Context createVelocityContext(
Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
// Create a ChainedContext instance.
ChainedContext velocityContext = new ChainedContext(
new VelocityContext(model), getVelocityEngine(), request, response, getServletContext());
// Load a Velocity Tools toolbox, if necessary.
if (getToolboxConfigLocation() != null) {
ToolboxManager toolboxManager = ServletToolboxManager.getInstance(
getServletContext(), getToolboxConfigLocation());
Map<?, ?> toolboxContext = toolboxManager.getToolbox(velocityContext);
velocityContext.setToolbox(toolboxContext);
}
return velocityContext;
}
/**
* Overridden to check for the ViewContext interface which is part of the
* view package of Velocity Tools. This requires a special Velocity context,
* like ChainedContext as set up by {@link #createVelocityContext} in this class.
*/
@Override
protected void initTool(Object tool, Context velocityContext) throws Exception {
// Velocity Tools 1.3: a class-level "init(Object)" method.
Method initMethod = ClassUtils.getMethodIfAvailable(tool.getClass(), "init", Object.class);
if (initMethod != null) {
ReflectionUtils.invokeMethod(initMethod, tool, velocityContext);
}
}
}

578
spring-webmvc/src/main/java/org/springframework/web/servlet/view/velocity/VelocityView.java
View File

@@ -1,578 +0,0 @@
/*
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.servlet.view.velocity;
import java.util.Locale;
import java.util.Map;
import java.util.TimeZone;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.VelocityEngine;
import org.apache.velocity.context.Context;
import org.apache.velocity.exception.MethodInvocationException;
import org.apache.velocity.exception.ResourceNotFoundException;
import org.apache.velocity.tools.generic.DateTool;
import org.apache.velocity.tools.generic.NumberTool;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactoryUtils;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.context.ApplicationContextException;
import org.springframework.core.NestedIOException;
import org.springframework.web.servlet.support.RequestContextUtils;
import org.springframework.web.servlet.view.AbstractTemplateView;
import org.springframework.web.util.NestedServletException;
/**
* View using the Velocity template engine.
*
* <p>Exposes the following JavaBean properties:
* <ul>
* <li><b>url</b>: the location of the Velocity template to be wrapped,
* relative to the Velocity resource loader path (see VelocityConfigurer).
* <li><b>encoding</b> (optional, default is determined by Velocity configuration):
* the encoding of the Velocity template file
* <li><b>velocityFormatterAttribute</b> (optional, default=null): the name of
* the VelocityFormatter helper object to expose in the Velocity context of this
* view, or {@code null} if not needed. VelocityFormatter is part of standard Velocity.
* <li><b>dateToolAttribute</b> (optional, default=null): the name of the
* DateTool helper object to expose in the Velocity context of this view,
* or {@code null} if not needed. DateTool is part of Velocity Tools.
* <li><b>numberToolAttribute</b> (optional, default=null): the name of the
* NumberTool helper object to expose in the Velocity context of this view,
* or {@code null} if not needed. NumberTool is part of Velocity Tools.
* <li><b>cacheTemplate</b> (optional, default=false): whether or not the Velocity
* template should be cached. It should normally be true in production, but setting
* this to false enables us to modify Velocity templates without restarting the
* application (similar to JSPs). Note that this is a minor optimization only,
* as Velocity itself caches templates in a modification-aware fashion.
* </ul>
*
* <p>Depends on a VelocityConfig object such as VelocityConfigurer being
* accessible in the current web application context, with any bean name.
* Alternatively, you can set the VelocityEngine object as bean property.
*
* <p>Note: Spring 3.0's VelocityView requires Velocity 1.4 or higher, and optionally
* Velocity Tools 1.1 or higher (depending on the use of DateTool and/or NumberTool).
*
* @author Rod Johnson
* @author Juergen Hoeller
* @author Dave Syer
* @see VelocityConfig
* @see VelocityConfigurer
* @see #setUrl
* @see #setExposeSpringMacroHelpers
* @see #setEncoding
* @see #setVelocityEngine
* @see VelocityConfig
* @see VelocityConfigurer
* @deprecated as of Spring 4.3, in favor of FreeMarker
*/
@Deprecated
public class VelocityView extends AbstractTemplateView {
private Map<String, Class<?>> toolAttributes;
private String dateToolAttribute;
private String numberToolAttribute;
private String encoding;
private boolean cacheTemplate = false;
private VelocityEngine velocityEngine;
private Template template;
/**
* Set tool attributes to expose to the view, as attribute name / class name pairs.
* An instance of the given class will be added to the Velocity context for each
* rendering operation, under the given attribute name.
* <p>For example, an instance of MathTool, which is part of the generic package
* of Velocity Tools, can be bound under the attribute name "math", specifying the
* fully qualified class name "org.apache.velocity.tools.generic.MathTool" as value.
* <p>Note that VelocityView can only create simple generic tools or values, that is,
* classes with a public default constructor and no further initialization needs.
* This class does not do any further checks, to not introduce a required dependency
* on a specific tools package.
* <p>For tools that are part of the view package of Velocity Tools, a special
* Velocity context and a special init callback are needed. Use VelocityToolboxView
* in such a case, or override {@code createVelocityContext} and
* {@code initTool} accordingly.
* <p>For a simple VelocityFormatter instance or special locale-aware instances
* of DateTool/NumberTool, which are part of the generic package of Velocity Tools,
* specify the "velocityFormatterAttribute", "dateToolAttribute" or
* "numberToolAttribute" properties, respectively.
* @param toolAttributes attribute names as keys, and tool class names as values
* @see org.apache.velocity.tools.generic.MathTool
* @see VelocityToolboxView
* @see #createVelocityContext
* @see #initTool
* @see #setDateToolAttribute
* @see #setNumberToolAttribute
*/
public void setToolAttributes(Map<String, Class<?>> toolAttributes) {
this.toolAttributes = toolAttributes;
}
/**
* Set the name of the DateTool helper object to expose in the Velocity context
* of this view, or {@code null} if not needed. The exposed DateTool will be aware of
* the current locale, as determined by Spring's LocaleResolver.
* <p>DateTool is part of the generic package of Velocity Tools 1.0.
* Spring uses a special locale-aware subclass of DateTool.
* @see org.apache.velocity.tools.generic.DateTool
* @see org.springframework.web.servlet.support.RequestContextUtils#getLocale
* @see org.springframework.web.servlet.LocaleResolver
*/
public void setDateToolAttribute(String dateToolAttribute) {
this.dateToolAttribute = dateToolAttribute;
}
/**
* Set the name of the NumberTool helper object to expose in the Velocity context
* of this view, or {@code null} if not needed. The exposed NumberTool will be aware of
* the current locale, as determined by Spring's LocaleResolver.
* <p>NumberTool is part of the generic package of Velocity Tools 1.1.
* Spring uses a special locale-aware subclass of NumberTool.
* @see org.apache.velocity.tools.generic.NumberTool
* @see org.springframework.web.servlet.support.RequestContextUtils#getLocale
* @see org.springframework.web.servlet.LocaleResolver
*/
public void setNumberToolAttribute(String numberToolAttribute) {
this.numberToolAttribute = numberToolAttribute;
}
/**
* Set the encoding of the Velocity template file. Default is determined
* by the VelocityEngine: "ISO-8859-1" if not specified otherwise.
* <p>Specify the encoding in the VelocityEngine rather than per template
* if all your templates share a common encoding.
*/
public void setEncoding(String encoding) {
this.encoding = encoding;
}
/**
* Return the encoding for the Velocity template.
*/
protected String getEncoding() {
return this.encoding;
}
/**
* Set whether the Velocity template should be cached. Default is "false".
* It should normally be true in production, but setting this to false enables us to
* modify Velocity templates without restarting the application (similar to JSPs).
* <p>Note that this is a minor optimization only, as Velocity itself caches
* templates in a modification-aware fashion.
*/
public void setCacheTemplate(boolean cacheTemplate) {
this.cacheTemplate = cacheTemplate;
}
/**
* Return whether the Velocity template should be cached.
*/
protected boolean isCacheTemplate() {
return this.cacheTemplate;
}
/**
* Set the VelocityEngine to be used by this view.
* <p>If this is not set, the default lookup will occur: A single VelocityConfig
* is expected in the current web application context, with any bean name.
* @see VelocityConfig
*/
public void setVelocityEngine(VelocityEngine velocityEngine) {
this.velocityEngine = velocityEngine;
}
/**
* Return the VelocityEngine used by this view.
*/
protected VelocityEngine getVelocityEngine() {
return this.velocityEngine;
}
/**
* Invoked on startup. Looks for a single VelocityConfig bean to
* find the relevant VelocityEngine for this factory.
*/
@Override
protected void initApplicationContext() throws BeansException {
super.initApplicationContext();
if (getVelocityEngine() == null) {
// No explicit VelocityEngine: try to autodetect one.
setVelocityEngine(autodetectVelocityEngine());
}
}
/**
* Autodetect a VelocityEngine via the ApplicationContext.
* Called if no explicit VelocityEngine has been specified.
* @return the VelocityEngine to use for VelocityViews
* @throws BeansException if no VelocityEngine could be found
* @see #getApplicationContext
* @see #setVelocityEngine
*/
protected VelocityEngine autodetectVelocityEngine() throws BeansException {
try {
VelocityConfig velocityConfig = BeanFactoryUtils.beanOfTypeIncludingAncestors(
getApplicationContext(), VelocityConfig.class, true, false);
return velocityConfig.getVelocityEngine();
}
catch (NoSuchBeanDefinitionException ex) {
throw new ApplicationContextException(
"Must define a single VelocityConfig bean in this web application context " +
"(may be inherited): VelocityConfigurer is the usual implementation. " +
"This bean may be given any name.", ex);
}
}
/**
* Check that the Velocity template used for this view exists and is valid.
* <p>Can be overridden to customize the behavior, for example in case of
* multiple templates to be rendered into a single view.
*/
@Override
public boolean checkResource(Locale locale) throws Exception {
try {
// Check that we can get the template, even if we might subsequently get it again.
this.template = getTemplate(getUrl());
return true;
}
catch (ResourceNotFoundException ex) {
if (logger.isDebugEnabled()) {
logger.debug("No Velocity view found for URL: " + getUrl());
}
return false;
}
catch (Exception ex) {
throw new NestedIOException(
"Could not load Velocity template for URL [" + getUrl() + "]", ex);
}
}
/**
* Process the model map by merging it with the Velocity template.
* Output is directed to the servlet response.
* <p>This method can be overridden if custom behavior is needed.
*/
@Override
protected void renderMergedTemplateModel(
Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
exposeHelpers(model, request);
Context velocityContext = createVelocityContext(model, request, response);
exposeHelpers(velocityContext, request, response);
exposeToolAttributes(velocityContext, request);
doRender(velocityContext, response);
}
/**
* Expose helpers unique to each rendering operation. This is necessary so that
* different rendering operations can't overwrite each other's formats etc.
* <p>Called by {@code renderMergedTemplateModel}. The default implementation
* is empty. This method can be overridden to add custom helpers to the model.
* @param model the model that will be passed to the template for merging
* @param request current HTTP request
* @throws Exception if there's a fatal error while we're adding model attributes
* @see #renderMergedTemplateModel
*/
protected void exposeHelpers(Map<String, Object> model, HttpServletRequest request) throws Exception {
}
/**
* Create a Velocity Context instance for the given model,
* to be passed to the template for merging.
* <p>The default implementation delegates to {@link #createVelocityContext(Map)}.
* Can be overridden for a special context class, for example ChainedContext which
* is part of the view package of Velocity Tools. ChainedContext is needed for
* initialization of ViewTool instances.
* <p>Have a look at {@link VelocityToolboxView}, which pre-implements
* ChainedContext support. This is not part of the standard VelocityView class
* in order to avoid a required dependency on the view package of Velocity Tools.
* @param model the model Map, containing the model attributes to be exposed to the view
* @param request current HTTP request
* @param response current HTTP response
* @return the Velocity Context
* @throws Exception if there's a fatal error while creating the context
* @see #createVelocityContext(Map)
* @see #initTool
* @see org.apache.velocity.tools.view.context.ChainedContext
* @see VelocityToolboxView
*/
protected Context createVelocityContext(
Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
return createVelocityContext(model);
}
/**
* Create a Velocity Context instance for the given model,
* to be passed to the template for merging.
* <p>Default implementation creates an instance of Velocity's
* VelocityContext implementation class.
* @param model the model Map, containing the model attributes
* to be exposed to the view
* @return the Velocity Context
* @throws Exception if there's a fatal error while creating the context
* @see org.apache.velocity.VelocityContext
*/
protected Context createVelocityContext(Map<String, Object> model) throws Exception {
return new VelocityContext(model);
}
/**
* Expose helpers unique to each rendering operation. This is necessary so that
* different rendering operations can't overwrite each other's formats etc.
* <p>Called by {@code renderMergedTemplateModel}. Default implementation
* delegates to {@code exposeHelpers(velocityContext, request)}. This method
* can be overridden to add special tools to the context, needing the servlet response
* to initialize (see Velocity Tools, for example LinkTool and ViewTool/ChainedContext).
* @param velocityContext Velocity context that will be passed to the template
* @param request current HTTP request
* @param response current HTTP response
* @throws Exception if there's a fatal error while we're adding model attributes
* @see #exposeHelpers(org.apache.velocity.context.Context, HttpServletRequest)
*/
protected void exposeHelpers(
Context velocityContext, HttpServletRequest request, HttpServletResponse response) throws Exception {
exposeHelpers(velocityContext, request);
}
/**
* Expose helpers unique to each rendering operation. This is necessary so that
* different rendering operations can't overwrite each other's formats etc.
* <p>Default implementation is empty. This method can be overridden to add
* custom helpers to the Velocity context.
* @param velocityContext Velocity context that will be passed to the template
* @param request current HTTP request
* @throws Exception if there's a fatal error while we're adding model attributes
* @see #exposeHelpers(Map, HttpServletRequest)
*/
protected void exposeHelpers(Context velocityContext, HttpServletRequest request) throws Exception {
}
/**
* Expose the tool attributes, according to corresponding bean property settings.
* <p>Do not override this method unless for further tools driven by bean properties.
* Override one of the {@code exposeHelpers} methods to add custom helpers.
* @param velocityContext Velocity context that will be passed to the template
* @param request current HTTP request
* @throws Exception if there's a fatal error while we're adding model attributes
* @see #setDateToolAttribute
* @see #setNumberToolAttribute
* @see #exposeHelpers(Map, HttpServletRequest)
* @see #exposeHelpers(org.apache.velocity.context.Context, HttpServletRequest, HttpServletResponse)
*/
protected void exposeToolAttributes(Context velocityContext, HttpServletRequest request) throws Exception {
// Expose generic attributes.
if (this.toolAttributes != null) {
for (Map.Entry<String, Class<?>> entry : this.toolAttributes.entrySet()) {
String attributeName = entry.getKey();
Class<?> toolClass = entry.getValue();
try {
Object tool = toolClass.newInstance();
initTool(tool, velocityContext);
velocityContext.put(attributeName, tool);
}
catch (Exception ex) {
throw new NestedServletException("Could not instantiate Velocity tool '" + attributeName + "'", ex);
}
}
}
// Expose locale-aware DateTool/NumberTool attributes.
if (this.dateToolAttribute != null || this.numberToolAttribute != null) {
if (this.dateToolAttribute != null) {
velocityContext.put(this.dateToolAttribute, new LocaleAwareDateTool(request));
}
if (this.numberToolAttribute != null) {
velocityContext.put(this.numberToolAttribute, new LocaleAwareNumberTool(request));
}
}
}
/**
* Initialize the given tool instance. The default implementation is empty.
* <p>Can be overridden to check for special callback interfaces, for example
* the ViewContext interface which is part of the view package of Velocity Tools.
* In the particular case of ViewContext, you'll usually also need a special
* Velocity context, like ChainedContext which is part of Velocity Tools too.
* <p>Have a look at {@link VelocityToolboxView}, which pre-implements such a
* ViewTool check. This is not part of the standard VelocityView class in order
* to avoid a required dependency on the view package of Velocity Tools.
* @param tool the tool instance to initialize
* @param velocityContext the Velocity context
* @throws Exception if initializion of the tool failed
* @see #createVelocityContext
* @see org.apache.velocity.tools.view.context.ViewContext
* @see org.apache.velocity.tools.view.context.ChainedContext
* @see VelocityToolboxView
*/
protected void initTool(Object tool, Context velocityContext) throws Exception {
}
/**
* Render the Velocity view to the given response, using the given Velocity
* context which contains the complete template model to use.
* <p>The default implementation renders the template specified by the "url"
* bean property, retrieved via {@code getTemplate}. It delegates to the
* {@code mergeTemplate} method to merge the template instance with the
* given Velocity context.
* <p>Can be overridden to customize the behavior, for example to render
* multiple templates into a single view.
* @param context the Velocity context to use for rendering
* @param response servlet response (use this to get the OutputStream or Writer)
* @throws Exception if thrown by Velocity
* @see #setUrl
* @see #getTemplate()
* @see #mergeTemplate
*/
protected void doRender(Context context, HttpServletResponse response) throws Exception {
if (logger.isDebugEnabled()) {
logger.debug("Rendering Velocity template [" + getUrl() + "] in VelocityView '" + getBeanName() + "'");
}
mergeTemplate(getTemplate(), context, response);
}
/**
* Retrieve the Velocity template to be rendered by this view.
* <p>By default, the template specified by the "url" bean property will be
* retrieved: either returning a cached template instance or loading a fresh
* instance (according to the "cacheTemplate" bean property)
* @return the Velocity template to render
* @throws Exception if thrown by Velocity
* @see #setUrl
* @see #setCacheTemplate
* @see #getTemplate(String)
*/
protected Template getTemplate() throws Exception {
// We already hold a reference to the template, but we might want to load it
// if not caching. Velocity itself caches templates, so our ability to
// cache templates in this class is a minor optimization only.
if (isCacheTemplate() && this.template != null) {
return this.template;
}
else {
return getTemplate(getUrl());
}
}
/**
* Retrieve the Velocity template specified by the given name,
* using the encoding specified by the "encoding" bean property.
* <p>Can be called by subclasses to retrieve a specific template,
* for example to render multiple templates into a single view.
* @param name the file name of the desired template
* @return the Velocity template
* @throws Exception if thrown by Velocity
* @see org.apache.velocity.app.VelocityEngine#getTemplate
*/
protected Template getTemplate(String name) throws Exception {
return (getEncoding() != null ?
getVelocityEngine().getTemplate(name, getEncoding()) :
getVelocityEngine().getTemplate(name));
}
/**
* Merge the template with the context.
* Can be overridden to customize the behavior.
* @param template the template to merge
* @param context the Velocity context to use for rendering
* @param response servlet response (use this to get the OutputStream or Writer)
* @throws Exception if thrown by Velocity
* @see org.apache.velocity.Template#merge
*/
protected void mergeTemplate(
Template template, Context context, HttpServletResponse response) throws Exception {
try {
template.merge(context, response.getWriter());
}
catch (MethodInvocationException ex) {
Throwable cause = ex.getWrappedThrowable();
throw new NestedServletException(
"Method invocation failed during rendering of Velocity view with name '" +
getBeanName() + "': " + ex.getMessage() + "; reference [" + ex.getReferenceName() +
"], method '" + ex.getMethodName() + "'",
cause==null ? ex : cause);
}
}
/**
* Subclass of DateTool from Velocity Tools, using a Spring-resolved
* Locale and TimeZone instead of the default Locale.
* @see org.springframework.web.servlet.support.RequestContextUtils#getLocale
* @see org.springframework.web.servlet.support.RequestContextUtils#getTimeZone
*/
private static class LocaleAwareDateTool extends DateTool {
private final HttpServletRequest request;
public LocaleAwareDateTool(HttpServletRequest request) {
this.request = request;
}
@Override
public Locale getLocale() {
return RequestContextUtils.getLocale(this.request);
}
@Override
public TimeZone getTimeZone() {
TimeZone timeZone = RequestContextUtils.getTimeZone(this.request);
return (timeZone != null ? timeZone : super.getTimeZone());
}
}
/**
* Subclass of NumberTool from Velocity Tools, using a Spring-resolved
* Locale instead of the default Locale.
* @see org.springframework.web.servlet.support.RequestContextUtils#getLocale
*/
private static class LocaleAwareNumberTool extends NumberTool {
private final HttpServletRequest request;
public LocaleAwareNumberTool(HttpServletRequest request) {
this.request = request;
}
@Override
public Locale getLocale() {
return RequestContextUtils.getLocale(this.request);
}
}
}

137
spring-webmvc/src/main/java/org/springframework/web/servlet/view/velocity/VelocityViewResolver.java
View File

@@ -1,137 +0,0 @@
/*
* Copyright 2002-2012 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.servlet.view.velocity;
import org.springframework.web.servlet.view.AbstractTemplateViewResolver;
import org.springframework.web.servlet.view.AbstractUrlBasedView;
/**
* Convenience subclass of {@link org.springframework.web.servlet.view.UrlBasedViewResolver}
* that supports {@link VelocityView} (i.e. Velocity templates) and custom subclasses of it.
*
* <p>The view class for all views generated by this resolver can be specified
* via the "viewClass" property. See UrlBasedViewResolver's javadoc for details.
*
* <p><b>Note:</b> When chaining ViewResolvers, a VelocityViewResolver will
* check for the existence of the specified template resources and only return
* a non-null View object if the template was actually found.
*
* @author Juergen Hoeller
* @since 13.12.2003
* @see #setViewClass
* @see #setPrefix
* @see #setSuffix
* @see #setRequestContextAttribute
* @see #setExposeSpringMacroHelpers
* @see #setDateToolAttribute
* @see #setNumberToolAttribute
* @see VelocityView
* @deprecated as of Spring 4.3, in favor of FreeMarker
*/
@Deprecated
public class VelocityViewResolver extends AbstractTemplateViewResolver {
private String dateToolAttribute;
private String numberToolAttribute;
private String toolboxConfigLocation;
public VelocityViewResolver() {
setViewClass(requiredViewClass());
}
/**
* Requires {@link VelocityView}.
*/
@Override
protected Class<?> requiredViewClass() {
return VelocityView.class;
}
/**
* Set the name of the DateTool helper object to expose in the Velocity context
* of this view, or {@code null} if not needed. DateTool is part of Velocity Tools 1.0.
* @see org.apache.velocity.tools.generic.DateTool
* @see VelocityView#setDateToolAttribute
*/
public void setDateToolAttribute(String dateToolAttribute) {
this.dateToolAttribute = dateToolAttribute;
}
/**
* Set the name of the NumberTool helper object to expose in the Velocity context
* of this view, or {@code null} if not needed. NumberTool is part of Velocity Tools 1.1.
* @see org.apache.velocity.tools.generic.NumberTool
* @see VelocityView#setNumberToolAttribute
*/
public void setNumberToolAttribute(String numberToolAttribute) {
this.numberToolAttribute = numberToolAttribute;
}
/**
* Set a Velocity Toolbox config location, for example "/WEB-INF/toolbox.xml",
* to automatically load a Velocity Tools toolbox definition file and expose
* all defined tools in the specified scopes. If no config location is
* specified, no toolbox will be loaded and exposed.
* <p>The specified location string needs to refer to a ServletContext
* resource, as expected by ServletToolboxManager which is part of
* the view package of Velocity Tools.
* <p><b>Note:</b> Specifying a toolbox config location will lead to
* VelocityToolboxView instances being created.
* @see org.apache.velocity.tools.view.servlet.ServletToolboxManager#getInstance
* @see VelocityToolboxView#setToolboxConfigLocation
*/
public void setToolboxConfigLocation(String toolboxConfigLocation) {
this.toolboxConfigLocation = toolboxConfigLocation;
}
@Override
protected void initApplicationContext() {
super.initApplicationContext();
if (this.toolboxConfigLocation != null) {
if (VelocityView.class == getViewClass()) {
logger.info("Using VelocityToolboxView instead of default VelocityView " +
"due to specified toolboxConfigLocation");
setViewClass(VelocityToolboxView.class);
}
else if (!VelocityToolboxView.class.isAssignableFrom(getViewClass())) {
throw new IllegalArgumentException(
"Given view class [" + getViewClass().getName() +
"] is not of type [" + VelocityToolboxView.class.getName() +
"], which it needs to be in case of a specified toolboxConfigLocation");
}
}
}
@Override
protected AbstractUrlBasedView buildView(String viewName) throws Exception {
VelocityView view = (VelocityView) super.buildView(viewName);
view.setDateToolAttribute(this.dateToolAttribute);
view.setNumberToolAttribute(this.numberToolAttribute);
if (this.toolboxConfigLocation != null) {
((VelocityToolboxView) view).setToolboxConfigLocation(this.toolboxConfigLocation);
}
return view;
}
}

7
spring-webmvc/src/main/java/org/springframework/web/servlet/view/velocity/package-info.java
View File

@@ -1,7 +0,0 @@
/**
* Support classes for the integration of
* <a href="http://velocity.apache.org">Velocity</a>
* as Spring web view technology.
* Contains a View implementation for Velocity templates.
*/
package org.springframework.web.servlet.view.velocity;