1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.eclipse.jetty.servlet;
20
21 import java.io.IOException;
22 import java.util.ArrayList;
23 import java.util.Arrays;
24 import java.util.Collection;
25 import java.util.EnumSet;
26 import java.util.List;
27
28 import javax.servlet.DispatcherType;
29 import javax.servlet.Filter;
30 import javax.servlet.FilterConfig;
31 import javax.servlet.FilterRegistration;
32 import javax.servlet.ServletContext;
33 import javax.servlet.ServletException;
34
35 import org.eclipse.jetty.util.TypeUtil;
36 import org.eclipse.jetty.util.component.Dumpable;
37 import org.eclipse.jetty.util.log.Log;
38 import org.eclipse.jetty.util.log.Logger;
39
40
41
42
43
44 public class FilterHolder extends Holder<Filter>
45 {
46 private static final Logger LOG = Log.getLogger(FilterHolder.class);
47
48
49 private transient Filter _filter;
50 private transient Config _config;
51 private transient FilterRegistration.Dynamic _registration;
52
53
54
55
56 public FilterHolder()
57 {
58 this(Source.EMBEDDED);
59 }
60
61
62
63
64
65 public FilterHolder(Holder.Source source)
66 {
67 super(source);
68 }
69
70
71
72
73 public FilterHolder(Class<? extends Filter> filter)
74 {
75 this(Source.EMBEDDED);
76 setHeldClass(filter);
77 }
78
79
80
81
82 public FilterHolder(Filter filter)
83 {
84 this(Source.EMBEDDED);
85 setFilter(filter);
86 }
87
88
89 @Override
90 public void doStart()
91 throws Exception
92 {
93 super.doStart();
94
95 if (!javax.servlet.Filter.class
96 .isAssignableFrom(_class))
97 {
98 String msg = _class+" is not a javax.servlet.Filter";
99 super.stop();
100 throw new IllegalStateException(msg);
101 }
102 }
103
104
105
106
107
108
109
110 @Override
111 public void initialize() throws Exception
112 {
113 super.initialize();
114
115 if (_filter==null)
116 {
117 try
118 {
119 ServletContext context=_servletHandler.getServletContext();
120 _filter=(context instanceof ServletContextHandler.Context)
121 ?((ServletContextHandler.Context)context).createFilter(getHeldClass())
122 :getHeldClass().newInstance();
123 }
124 catch (ServletException se)
125 {
126 Throwable cause = se.getRootCause();
127 if (cause instanceof InstantiationException)
128 throw (InstantiationException)cause;
129 if (cause instanceof IllegalAccessException)
130 throw (IllegalAccessException)cause;
131 throw se;
132 }
133 }
134
135 _config=new Config();
136 if (LOG.isDebugEnabled())
137 LOG.debug("Filter.init {}",_filter);
138 _filter.init(_config);
139 }
140
141
142
143 @Override
144 public void doStop()
145 throws Exception
146 {
147 if (_filter!=null)
148 {
149 try
150 {
151 destroyInstance(_filter);
152 }
153 catch (Exception e)
154 {
155 LOG.warn(e);
156 }
157 }
158 if (!_extInstance)
159 _filter=null;
160
161 _config=null;
162 super.doStop();
163 }
164
165
166 @Override
167 public void destroyInstance (Object o)
168 throws Exception
169 {
170 if (o==null)
171 return;
172 Filter f = (Filter)o;
173 f.destroy();
174 getServletHandler().destroyFilter(f);
175 }
176
177
178 public synchronized void setFilter(Filter filter)
179 {
180 _filter=filter;
181 _extInstance=true;
182 setHeldClass(filter.getClass());
183 if (getName()==null)
184 setName(filter.getClass().getName());
185 }
186
187
188 public Filter getFilter()
189 {
190 return _filter;
191 }
192
193
194 @Override
195 public String toString()
196 {
197 return getName();
198 }
199
200
201 @Override
202 public void dump(Appendable out, String indent) throws IOException
203 {
204 super.dump(out, indent);
205 if(_filter instanceof Dumpable) {
206 ((Dumpable) _filter).dump(out, indent);
207 }
208 }
209
210
211 public FilterRegistration.Dynamic getRegistration()
212 {
213 if (_registration == null)
214 _registration = new Registration();
215 return _registration;
216 }
217
218
219
220
221 protected class Registration extends HolderRegistration implements FilterRegistration.Dynamic
222 {
223 public void addMappingForServletNames(EnumSet<DispatcherType> dispatcherTypes, boolean isMatchAfter, String... servletNames)
224 {
225 illegalStateIfContextStarted();
226 FilterMapping mapping = new FilterMapping();
227 mapping.setFilterHolder(FilterHolder.this);
228 mapping.setServletNames(servletNames);
229 mapping.setDispatcherTypes(dispatcherTypes);
230 if (isMatchAfter)
231 _servletHandler.addFilterMapping(mapping);
232 else
233 _servletHandler.prependFilterMapping(mapping);
234 }
235
236 public void addMappingForUrlPatterns(EnumSet<DispatcherType> dispatcherTypes, boolean isMatchAfter, String... urlPatterns)
237 {
238 illegalStateIfContextStarted();
239 FilterMapping mapping = new FilterMapping();
240 mapping.setFilterHolder(FilterHolder.this);
241 mapping.setPathSpecs(urlPatterns);
242 mapping.setDispatcherTypes(dispatcherTypes);
243 if (isMatchAfter)
244 _servletHandler.addFilterMapping(mapping);
245 else
246 _servletHandler.prependFilterMapping(mapping);
247 }
248
249 public Collection<String> getServletNameMappings()
250 {
251 FilterMapping[] mappings =_servletHandler.getFilterMappings();
252 List<String> names=new ArrayList<String>();
253 for (FilterMapping mapping : mappings)
254 {
255 if (mapping.getFilterHolder()!=FilterHolder.this)
256 continue;
257 String[] servlets=mapping.getServletNames();
258 if (servlets!=null && servlets.length>0)
259 names.addAll(Arrays.asList(servlets));
260 }
261 return names;
262 }
263
264 public Collection<String> getUrlPatternMappings()
265 {
266 FilterMapping[] mappings =_servletHandler.getFilterMappings();
267 List<String> patterns=new ArrayList<String>();
268 for (FilterMapping mapping : mappings)
269 {
270 if (mapping.getFilterHolder()!=FilterHolder.this)
271 continue;
272 String[] specs=mapping.getPathSpecs();
273 patterns.addAll(TypeUtil.asList(specs));
274 }
275 return patterns;
276 }
277 }
278
279
280
281
282 class Config extends HolderConfig implements FilterConfig
283 {
284
285 public String getFilterName()
286 {
287 return _name;
288 }
289 }
290 }