1 package org.apache.torque.manager;
2
3 /* ====================================================================
4 * The Apache Software License, Version 1.1
5 *
6 * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
7 * reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 *
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 *
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in
18 * the documentation and/or other materials provided with the
19 * distribution.
20 *
21 * 3. The end-user documentation included with the redistribution,
22 * if any, must include the following acknowledgment:
23 * "This product includes software developed by the
24 * Apache Software Foundation (http://www.apache.org/)."
25 * Alternately, this acknowledgment may appear in the software itself,
26 * if and wherever such third-party acknowledgments normally appear.
27 *
28 * 4. The names "Apache" and "Apache Software Foundation" and
29 * "Apache Turbine" must not be used to endorse or promote products
30 * derived from this software without prior written permission. For
31 * written permission, please contact apache@apache.org.
32 *
33 * 5. Products derived from this software may not be called "Apache",
34 * "Apache Turbine", nor may "Apache" appear in their name, without
35 * prior written permission of the Apache Software Foundation.
36 *
37 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
38 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
39 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
40 * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
41 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
42 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
43 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
44 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
45 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
46 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
47 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
48 * SUCH DAMAGE.
49 * ====================================================================
50 *
51 * This software consists of voluntary contributions made by many
52 * individuals on behalf of the Apache Software Foundation. For more
53 * information on the Apache Software Foundation, please see
54 * <http://www.apache.org/>.
55 */
56
57 import java.io.Serializable;
58 import java.util.HashMap;
59 import java.util.Map;
60
61 import org.apache.commons.pool.ObjectPool;
62 import org.apache.commons.pool.impl.StackObjectPool;
63
64 import org.apache.jcs.access.GroupCacheAccess;
65 import org.apache.jcs.access.exception.CacheException;
66
67 import org.apache.commons.logging.Log;
68 import org.apache.commons.logging.LogFactory;
69
70 import org.apache.torque.TorqueException;
71
72 /***
73 * This class provides a cache for convenient storage of method
74 * results.
75 *
76 * @author <a href="mailto:jmcnally@collab.net">John McNally</a>
77 * @version $Id: MethodResultCache.java,v 1.19 2003/08/25 16:33:22 henning Exp $
78 */
79 public class MethodResultCache
80 {
81 private ObjectPool pool;
82 private GroupCacheAccess jcsCache;
83 private Map groups;
84
85 /*** Logging */
86 private static Log log = LogFactory.getLog(MethodResultCache.class);
87
88 public MethodResultCache(GroupCacheAccess cache)
89 throws TorqueException
90 {
91 this.jcsCache = cache;
92 groups = new HashMap();
93 pool = new StackObjectPool(new MethodCacheKey.Factory(), 10000);
94 }
95
96 /***
97 * Allows subclasses to have ctors that do not require a cache.
98 * This is used by NullMethodResultCache which has no-op versions
99 * of all methods.
100 */
101 protected MethodResultCache()
102 {
103 }
104
105 public void clear()
106 {
107 if (jcsCache != null)
108 {
109 try
110 {
111 jcsCache.remove();
112 groups.clear();
113 }
114 catch (CacheException ce)
115 {
116 log.error(new TorqueException(
117 "Could not clear cache due to internal JCS error.", ce));
118 }
119 }
120 }
121
122 protected Object getImpl(MethodCacheKey key)
123 {
124 Object result = null;
125 if (jcsCache != null)
126 {
127 synchronized (this)
128 {
129 result = jcsCache.getFromGroup(key, key.getGroupKey());
130 }
131 }
132
133 if (result != null)
134 {
135 if (log.isDebugEnabled())
136 {
137 log.debug("MethodResultCache saved expensive operation: " + key);
138 }
139 }
140 return result;
141 }
142
143
144 protected Object putImpl(MethodCacheKey key, Object value)
145 throws TorqueException
146 {
147 //register the group, if this is the first occurrence
148 String group = key.getGroupKey();
149 if (!groups.containsKey(group))
150 {
151 groups.put(group, null);
152 }
153
154 Object old = null;
155 if (jcsCache != null)
156 {
157 try
158 {
159 synchronized (this)
160 {
161 old = jcsCache.getFromGroup(key, group);
162 jcsCache.putInGroup(key, group, value);
163 }
164 }
165 catch (CacheException ce)
166 {
167 throw new TorqueException
168 ("Could not cache due to internal JCS error", ce);
169 }
170 }
171 return old;
172 }
173
174 protected Object removeImpl(MethodCacheKey key)
175 throws TorqueException
176 {
177 Object old = null;
178 if (jcsCache != null)
179 {
180 synchronized (this)
181 {
182 old = jcsCache.getFromGroup(key, key.getGroupKey());
183 jcsCache.remove(key, key.getGroupKey());
184 }
185 }
186 return old;
187 }
188
189
190 public Object get(Serializable instanceOrClass, String method)
191 {
192 Object result = null;
193 if (jcsCache != null)
194 {
195 try
196 {
197 MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
198 key.init(instanceOrClass, method);
199 result = getImpl(key);
200 try
201 {
202 pool.returnObject(key);
203 }
204 catch (Exception e)
205 {
206 log.warn(
207 "Nonfatal error. Could not return key to pool", e);
208 }
209 }
210 catch (Exception e)
211 {
212 log.error("", e);
213 }
214 }
215 return result;
216 }
217
218 public Object get(Serializable instanceOrClass, String method,
219 Serializable arg1)
220 {
221 Object result = null;
222 if (jcsCache != null)
223 {
224 try
225 {
226 MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
227 key.init(instanceOrClass, method, arg1);
228 result = getImpl(key);
229 try
230 {
231 pool.returnObject(key);
232 }
233 catch (Exception e)
234 {
235 log.warn(
236 "Nonfatal error. Could not return key to pool", e);
237 }
238 }
239 catch (Exception e)
240 {
241 log.error("", e);
242 }
243 }
244 return result;
245 }
246
247 public Object get(Serializable instanceOrClass, String method,
248 Serializable arg1, Serializable arg2)
249 {
250 Object result = null;
251 if (jcsCache != null)
252 {
253 try
254 {
255 MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
256 key.init(instanceOrClass, method, arg1, arg2);
257 result = getImpl(key);
258 try
259 {
260 pool.returnObject(key);
261 }
262 catch (Exception e)
263 {
264 log.warn(
265 "Nonfatal error. Could not return key to pool", e);
266 }
267 }
268 catch (Exception e)
269 {
270 log.error("", e);
271 }
272 }
273 return result;
274 }
275
276 public Object get(Serializable instanceOrClass, String method,
277 Serializable arg1, Serializable arg2,
278 Serializable arg3)
279 {
280 Object result = null;
281 if (jcsCache != null)
282 {
283 try
284 {
285 MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
286 key.init(instanceOrClass, method, arg1, arg2, arg3);
287 result = getImpl(key);
288 try
289 {
290 pool.returnObject(key);
291 }
292 catch (Exception e)
293 {
294 log.warn(
295 "Nonfatal error. Could not return key to pool", e);
296 }
297 }
298 catch (Exception e)
299 {
300 log.error("", e);
301 }
302 }
303 return result;
304 }
305
306 public Object get(Serializable[] keys)
307 {
308 Object result = null;
309 if (jcsCache != null)
310 {
311 try
312 {
313 MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
314 key.init(keys);
315 result = getImpl(key);
316 try
317 {
318 pool.returnObject(key);
319 }
320 catch (Exception e)
321 {
322 log.warn(
323 "Nonfatal error. Could not return key to pool", e);
324 }
325 }
326 catch (Exception e)
327 {
328 log.error("", e);
329 }
330 }
331 return result;
332 }
333
334 public void put(Object value, Serializable instanceOrClass, String method)
335 {
336 try
337 {
338 MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
339 key.init(instanceOrClass, method);
340 putImpl(key, value);
341 }
342 catch (Exception e)
343 {
344 log.error("", e);
345 }
346 }
347
348 public void put(Object value, Serializable instanceOrClass,
349 String method, Serializable arg1)
350 {
351 try
352 {
353 MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
354 key.init(instanceOrClass, method, arg1);
355 putImpl(key, value);
356 }
357 catch (Exception e)
358 {
359 log.error("", e);
360 }
361 }
362
363 public void put(Object value, Serializable instanceOrClass, String method,
364 Serializable arg1, Serializable arg2)
365 {
366 try
367 {
368 MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
369 key.init(instanceOrClass, method, arg1, arg2);
370 putImpl(key, value);
371 }
372 catch (Exception e)
373 {
374 log.error("", e);
375 }
376 }
377
378 public void put(Object value, Serializable instanceOrClass, String method,
379 Serializable arg1, Serializable arg2, Serializable arg3)
380 {
381 try
382 {
383 MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
384 key.init(instanceOrClass, method, arg1, arg2, arg3);
385 putImpl(key, value);
386 }
387 catch (Exception e)
388 {
389 log.error("", e);
390 }
391 }
392
393 public void put(Object value, Serializable[] keys)
394 {
395 try
396 {
397 MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
398 key.init(keys);
399 putImpl(key, value);
400 }
401 catch (Exception e)
402 {
403 log.error("", e);
404 }
405 }
406
407
408 public void removeAll(Serializable instanceOrClass, String method)
409 {
410 if (jcsCache != null)
411 {
412 try
413 {
414 MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
415 key.init(instanceOrClass, method);
416 String groupName = key.getGroupKey();
417 jcsCache.invalidateGroup(groupName);
418 groups.remove(groupName);
419 try
420 {
421 pool.returnObject(key);
422 }
423 catch (Exception e)
424 {
425 log.warn(
426 "Nonfatal error. Could not return key to pool", e);
427 }
428 }
429 catch (Exception e)
430 {
431 log.error("", e);
432 }
433 }
434 }
435
436
437 public Object remove(Serializable instanceOrClass, String method)
438 {
439 Object result = null;
440 if (jcsCache != null)
441 {
442 try
443 {
444 MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
445 key.init(instanceOrClass, method);
446 result = removeImpl(key);
447 try
448 {
449 pool.returnObject(key);
450 }
451 catch (Exception e)
452 {
453 log.warn(
454 "Nonfatal error. Could not return key to pool", e);
455 }
456 }
457 catch (Exception e)
458 {
459 log.error("", e);
460 }
461 }
462 return result;
463 }
464
465 public Object remove(Serializable instanceOrClass, String method,
466 Serializable arg1)
467 {
468 Object result = null;
469 if (jcsCache != null)
470 {
471 try
472 {
473 MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
474 key.init(instanceOrClass, method, arg1);
475 result = removeImpl(key);
476 try
477 {
478 pool.returnObject(key);
479 }
480 catch (Exception e)
481 {
482 log.warn(
483 "Nonfatal error. Could not return key to pool", e);
484 }
485 }
486 catch (Exception e)
487 {
488 log.error("Error removing element", e);
489 }
490 }
491 return result;
492 }
493
494 public Object remove(Serializable instanceOrClass, String method,
495 Serializable arg1, Serializable arg2)
496 {
497 Object result = null;
498 if (jcsCache != null)
499 {
500 try
501 {
502 MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
503 key.init(instanceOrClass, method, arg1, arg2);
504 result = removeImpl(key);
505 try
506 {
507 pool.returnObject(key);
508 }
509 catch (Exception e)
510 {
511 log.warn(
512 "Nonfatal error: Could not return key to pool", e);
513 }
514 }
515 catch (Exception e)
516 {
517 log.error("Error removing element from cache", e);
518 }
519 }
520 return result;
521 }
522
523 public Object remove(Serializable instanceOrClass, String method,
524 Serializable arg1, Serializable arg2,
525 Serializable arg3)
526 {
527 Object result = null;
528 if (jcsCache != null)
529 {
530 try
531 {
532 MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
533 key.init(instanceOrClass, method, arg1, arg2, arg3);
534 result = removeImpl(key);
535 try
536 {
537 pool.returnObject(key);
538 }
539 catch (Exception e)
540 {
541 log.warn(
542 "Nonfatal error. Could not return key to pool", e);
543 }
544 }
545 catch (Exception e)
546 {
547 log.error("Error removing element from cache", e);
548 }
549 }
550 return result;
551 }
552
553 public Object remove(Serializable[] keys)
554 {
555 Object result = null;
556 if (jcsCache != null)
557 {
558 try
559 {
560 MethodCacheKey key = (MethodCacheKey) pool.borrowObject();
561 key.init(keys);
562 result = removeImpl(key);
563 try
564 {
565 pool.returnObject(key);
566 }
567 catch (Exception e)
568 {
569 log.warn(
570 "Nonfatal error: Could not return key to pool", e);
571 }
572 }
573 catch (Exception e)
574 {
575 log.error("Error removing element from cache", e);
576 }
577 }
578 return result;
579 }
580 }
This page was automatically generated by Maven