KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > springframework > web > multipart > support > MultipartFilter


1 /*
2  * Copyright 2002-2006 the original author or authors.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package org.springframework.web.multipart.support;
18
19 import java.io.IOException JavaDoc;
20
21 import javax.servlet.FilterChain JavaDoc;
22 import javax.servlet.ServletException JavaDoc;
23 import javax.servlet.http.HttpServletRequest JavaDoc;
24 import javax.servlet.http.HttpServletResponse JavaDoc;
25
26 import org.springframework.web.context.WebApplicationContext;
27 import org.springframework.web.context.support.WebApplicationContextUtils;
28 import org.springframework.web.filter.OncePerRequestFilter;
29 import org.springframework.web.multipart.MultipartHttpServletRequest;
30 import org.springframework.web.multipart.MultipartResolver;
31
32 /**
33  * Servlet 2.3 Filter that resolves multipart requests via a MultipartResolver.
34  * in the root web application context.
35  *
36  * <p>Looks up the MultipartResolver in Spring's root web application context.
37  * Supports a "multipartResolverBeanName" filter init-param in <code>web.xml</code>;
38  * the default bean name is "filterMultipartResolver". Looks up the MultipartResolver
39  * on each request, to avoid initialization order issues (when using ContextLoaderServlet,
40  * the root application context will get initialized <i>after</i> this filter).
41  *
42  * <p>MultipartResolver lookup is customizable: Override this filter's
43  * <code>lookupMultipartResolver</code> method to use a custom MultipartResolver
44  * instance, for example if not using a Spring web application context.
45  * Note that the lookup method should not create a new MultipartResolver instance
46  * for each call but rather return a reference to a pre-built instance.
47  *
48  * <p>Note: This filter is an <b>alternative</b> to using DispatcherServlet's
49  * MultipartResolver support, for example for web applications with custom
50  * web views that do not use Spring's web MVC. It should not be combined with
51  * servlet-specific multipart resolution.
52  *
53  * @author Juergen Hoeller
54  * @since 08.10.2003
55  * @see #setMultipartResolverBeanName
56  * @see #lookupMultipartResolver
57  * @see org.springframework.web.multipart.MultipartResolver
58  * @see org.springframework.web.servlet.DispatcherServlet
59  */
60 public class MultipartFilter extends OncePerRequestFilter {
61
62     public static final String JavaDoc DEFAULT_MULTIPART_RESOLVER_BEAN_NAME = "filterMultipartResolver";
63
64     private String JavaDoc multipartResolverBeanName = DEFAULT_MULTIPART_RESOLVER_BEAN_NAME;
65
66
67     /**
68      * Set the bean name of the MultipartResolver to fetch from Spring's
69      * root application context. Default is "filterMultipartResolver".
70      */
71     public void setMultipartResolverBeanName(String JavaDoc multipartResolverBeanName) {
72         this.multipartResolverBeanName = multipartResolverBeanName;
73     }
74
75     /**
76      * Return the bean name of the MultipartResolver to fetch from Spring's
77      * root application context.
78      */
79     protected String JavaDoc getMultipartResolverBeanName() {
80         return multipartResolverBeanName;
81     }
82
83
84     /**
85      * Check for a multipart request via this filter's MultipartResolver,
86      * and wrap the original request with a MultipartHttpServletRequest if appropriate.
87      * <p>All later elements in the filter chain, most importantly servlets, benefit
88      * from proper parameter extraction in the multipart case, and are able to cast to
89      * MultipartHttpServletRequest if they need to.
90      */
91     protected void doFilterInternal(
92             HttpServletRequest JavaDoc request, HttpServletResponse JavaDoc response, FilterChain JavaDoc filterChain)
93             throws ServletException JavaDoc, IOException JavaDoc {
94
95         MultipartResolver multipartResolver = lookupMultipartResolver(request);
96
97         HttpServletRequest JavaDoc processedRequest = request;
98         if (multipartResolver.isMultipart(processedRequest)) {
99             if (logger.isDebugEnabled()) {
100                 logger.debug("Resolving multipart request [" + processedRequest.getRequestURI() +
101                         "] with MultipartFilter");
102             }
103             processedRequest = multipartResolver.resolveMultipart(processedRequest);
104         }
105         else {
106             if (logger.isDebugEnabled()) {
107                 logger.debug("Request [" + processedRequest.getRequestURI() + "] is not a multipart request");
108             }
109         }
110         
111         try {
112             filterChain.doFilter(processedRequest, response);
113         }
114         finally {
115             if (processedRequest instanceof MultipartHttpServletRequest) {
116                 multipartResolver.cleanupMultipart((MultipartHttpServletRequest) processedRequest);
117             }
118         }
119     }
120
121     /**
122      * Look up the MultipartResolver that this filter should use,
123      * taking the current HTTP request as argument.
124      * <p>Default implementation delegates to the <code>lookupMultipartResolver</code>
125      * without arguments.
126      * @return the MultipartResolver to use
127      * @see #lookupMultipartResolver()
128      */
129     protected MultipartResolver lookupMultipartResolver(HttpServletRequest JavaDoc request) {
130         return lookupMultipartResolver();
131     }
132
133     /**
134      * Look for a MultipartResolver bean in the root web application context.
135      * Supports a "multipartResolverBeanName" filter init param; the default
136      * bean name is "filterMultipartResolver".
137      * <p>This can be overridden to use a custom MultipartResolver instance,
138      * for example if not using a Spring web application context.
139      * @return the MultipartResolver instance, or <code>null</code> if none found
140      */
141     protected MultipartResolver lookupMultipartResolver() {
142         if (logger.isDebugEnabled()) {
143             logger.debug("Using MultipartResolver '" + getMultipartResolverBeanName() + "' for MultipartFilter");
144         }
145         WebApplicationContext wac =
146                 WebApplicationContextUtils.getRequiredWebApplicationContext(getServletContext());
147         return (MultipartResolver) wac.getBean(getMultipartResolverBeanName(), MultipartResolver.class);
148     }
149
150 }
151
Popular Tags