001: /*
002: * Copyright 2002-2006 the original author or authors.
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License");
005: * you may not use this file except in compliance with the License.
006: * You may obtain a copy of the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS,
012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013: * See the License for the specific language governing permissions and
014: * limitations under the License.
015: */
016:
017: package org.springframework.web.multipart.support;
018:
019: import java.io.IOException;
020:
021: import javax.servlet.FilterChain;
022: import javax.servlet.ServletException;
023: import javax.servlet.http.HttpServletRequest;
024: import javax.servlet.http.HttpServletResponse;
025:
026: import org.springframework.web.context.WebApplicationContext;
027: import org.springframework.web.context.support.WebApplicationContextUtils;
028: import org.springframework.web.filter.OncePerRequestFilter;
029: import org.springframework.web.multipart.MultipartHttpServletRequest;
030: import org.springframework.web.multipart.MultipartResolver;
031:
032: /**
033: * Servlet 2.3 Filter that resolves multipart requests via a MultipartResolver.
034: * in the root web application context.
035: *
036: * <p>Looks up the MultipartResolver in Spring's root web application context.
037: * Supports a "multipartResolverBeanName" filter init-param in <code>web.xml</code>;
038: * the default bean name is "filterMultipartResolver". Looks up the MultipartResolver
039: * on each request, to avoid initialization order issues (when using ContextLoaderServlet,
040: * the root application context will get initialized <i>after</i> this filter).
041: *
042: * <p>MultipartResolver lookup is customizable: Override this filter's
043: * <code>lookupMultipartResolver</code> method to use a custom MultipartResolver
044: * instance, for example if not using a Spring web application context.
045: * Note that the lookup method should not create a new MultipartResolver instance
046: * for each call but rather return a reference to a pre-built instance.
047: *
048: * <p>Note: This filter is an <b>alternative</b> to using DispatcherServlet's
049: * MultipartResolver support, for example for web applications with custom
050: * web views that do not use Spring's web MVC. It should not be combined with
051: * servlet-specific multipart resolution.
052: *
053: * @author Juergen Hoeller
054: * @since 08.10.2003
055: * @see #setMultipartResolverBeanName
056: * @see #lookupMultipartResolver
057: * @see org.springframework.web.multipart.MultipartResolver
058: * @see org.springframework.web.servlet.DispatcherServlet
059: */
060: public class MultipartFilter extends OncePerRequestFilter {
061:
062: public static final String DEFAULT_MULTIPART_RESOLVER_BEAN_NAME = "filterMultipartResolver";
063:
064: private String multipartResolverBeanName = DEFAULT_MULTIPART_RESOLVER_BEAN_NAME;
065:
066: /**
067: * Set the bean name of the MultipartResolver to fetch from Spring's
068: * root application context. Default is "filterMultipartResolver".
069: */
070: public void setMultipartResolverBeanName(
071: String multipartResolverBeanName) {
072: this .multipartResolverBeanName = multipartResolverBeanName;
073: }
074:
075: /**
076: * Return the bean name of the MultipartResolver to fetch from Spring's
077: * root application context.
078: */
079: protected String getMultipartResolverBeanName() {
080: return multipartResolverBeanName;
081: }
082:
083: /**
084: * Check for a multipart request via this filter's MultipartResolver,
085: * and wrap the original request with a MultipartHttpServletRequest if appropriate.
086: * <p>All later elements in the filter chain, most importantly servlets, benefit
087: * from proper parameter extraction in the multipart case, and are able to cast to
088: * MultipartHttpServletRequest if they need to.
089: */
090: protected void doFilterInternal(HttpServletRequest request,
091: HttpServletResponse response, FilterChain filterChain)
092: throws ServletException, IOException {
093:
094: MultipartResolver multipartResolver = lookupMultipartResolver(request);
095:
096: HttpServletRequest processedRequest = request;
097: if (multipartResolver.isMultipart(processedRequest)) {
098: if (logger.isDebugEnabled()) {
099: logger.debug("Resolving multipart request ["
100: + processedRequest.getRequestURI()
101: + "] with MultipartFilter");
102: }
103: processedRequest = multipartResolver
104: .resolveMultipart(processedRequest);
105: } else {
106: if (logger.isDebugEnabled()) {
107: logger.debug("Request ["
108: + processedRequest.getRequestURI()
109: + "] is not a multipart request");
110: }
111: }
112:
113: try {
114: filterChain.doFilter(processedRequest, response);
115: } finally {
116: if (processedRequest instanceof MultipartHttpServletRequest) {
117: multipartResolver
118: .cleanupMultipart((MultipartHttpServletRequest) processedRequest);
119: }
120: }
121: }
122:
123: /**
124: * Look up the MultipartResolver that this filter should use,
125: * taking the current HTTP request as argument.
126: * <p>Default implementation delegates to the <code>lookupMultipartResolver</code>
127: * without arguments.
128: * @return the MultipartResolver to use
129: * @see #lookupMultipartResolver()
130: */
131: protected MultipartResolver lookupMultipartResolver(
132: HttpServletRequest request) {
133: return lookupMultipartResolver();
134: }
135:
136: /**
137: * Look for a MultipartResolver bean in the root web application context.
138: * Supports a "multipartResolverBeanName" filter init param; the default
139: * bean name is "filterMultipartResolver".
140: * <p>This can be overridden to use a custom MultipartResolver instance,
141: * for example if not using a Spring web application context.
142: * @return the MultipartResolver instance, or <code>null</code> if none found
143: */
144: protected MultipartResolver lookupMultipartResolver() {
145: if (logger.isDebugEnabled()) {
146: logger.debug("Using MultipartResolver '"
147: + getMultipartResolverBeanName()
148: + "' for MultipartFilter");
149: }
150: WebApplicationContext wac = WebApplicationContextUtils
151: .getRequiredWebApplicationContext(getServletContext());
152: return (MultipartResolver) wac
153: .getBean(getMultipartResolverBeanName(),
154: MultipartResolver.class);
155: }
156:
157: }
|