A Simple cache implement

2. package com.alex.commonutil.cache;
4. import java.util.Collection;
5. import java.util.HashMap;
6. import java.util.Iterator;
7. import java.util.Map;
9. /**
10.  * A simple implementation of {@link Cache}.
11.  * <p>
12.  * This cache implements most of the methods defined in {@link Cache}, using a
13.  * <tt>ConcurrentHashMap</tt> to store objects, which could provide better
14.  * performance in concurrent enviroment.
15.  * </p>
16.  */
17. public abstract class AbstractCache implements Cache {
18.     /**
19.      * This cache uses a concurrent hash map to store object.
20.      */
21.     Map storage = new HashMap();
24.     public boolean hasKey(Object key) {
25.         if (key == null) {
26.             return false;
27.         }
28.         return storage.containsKey(key);
29.     }
31.     /**
32.      * Identifier of this cache, unique and not null.
33.      */
34.     private final Object identifier;
36.     /**
37.      * Constructs a new cache with speicified identifier. The identifier should
38.      * be unique and not <tt>null</tt>.
39.      * 
40.      * @param identifier
41.      *            the identifier of the new cache, which is unique and not null
42.      * @throws IllegalArgumentException
43.      *             if the identifier is <tt>null</tt>
44.      */
45.     public AbstractCache(Object identifier) throws IllegalArgumentException {
46.         if (identifier == null) {
47.             throw new IllegalArgumentException(
48.                     "The identifier of cache should NOT be null.");
49.         }
50.         this.identifier = identifier;
51.     }
54.     public void clear() {
55.         storage.clear();
56.     }
58.     public boolean hasObject(Object object) {
59.         if (object == null) {
60.             return false;
61.         }
62.         return storage.containsValue(object);
63.     }
66.     public Object fetch(Object key) {
67.         return storage.get(key);
68.     }
71.     public Collection fetchAll() {
72.         return storage.values();
73.     }
76.     public Object getIdentifier() {
77.         return this.identifier;
78.     }
81.     public void remove(Object key) {
82.         storage.remove(key);
83.     }
86.     public void save(Object key, Object value) throws IllegalArgumentException {
87.         if (key == null || value == null) {
88.             throw new IllegalArgumentException(
89.                     "No null key or value allowed in cache.");
90.         }
91.         storage.put(key, value);
92.     }
94.     public void save(Object value) throws IllegalArgumentException {
95.         save(createKey(value), value);
96.     }
98.     public int size() {
99.         return storage.size();
100.     }
103.     public abstract Object createKey(Object object) throws IllegalArgumentException;
106.     public void saveAll(Collection values) {
107.         for (Iterator it = values.iterator(); it.hasNext();) {
108.             save(it.next());
109.         }
110.     }
113.     public void saveAll(Map values) {
114.         storage.putAll(values);
115.     }
118.     public Collection keys() {
119.         return storage.keySet();
120.     }
121. }

1. package com.alex.commonutil.cache;
3. import java.util.Collection;
4. import java.util.Map;
6. /**
7.  * A cache keeps objects that may be used frequently in memory, it is made up of
8.  * a pool of entries . Usually cache is used to improve performance, because
9.  * memory is always faster that DB or disk I/O.
10.  * <p>
11.  * Caches do not accept <tt>null</tt> keys or values. They may store kinds of
12.  * objects, however, it is better that each cache stores only one type of
13.  * objects, using a key mapping for association.
14.  * </p>
15.  * <p>
16.  * For performance, reading methods is not necessary to be synchronized.
17.  * However, adding, updating and removing should be synchronized when caches
18.  * might be accessed by many threads.
19.  * </p>
20.  */
21. public interface Cache {
23.     /**
24.      * Clears contents of this caches.
25.      */
26.     public void clear();
28.     /**
29.      * Creates a unique key for given object using some rules, if the object is
30.      * not in cache yet. If the object exists in cache, returns its key.
31.      * 
32.      * @param object
33.      *            an object in which the cache would save
34.      * @return the key of the object
35.      * @throws IllegalArgumentException
36.      *             if the object is <tt>null</tt>
37.      */
38.     public Object createKey(Object object) throws IllegalArgumentException;
40.     /**
41.      * Returns the value to which maps the specified key in cache. Returns
42.      * <tt>null</tt> if the cache contains no mapping for this key.
43.      * <p>
44.      * If this method is not synchronized, the performance might be higher, and
45.      * would not brings chaos when accessed by more than one thread.
46.      * </p>
47.      * 
48.      * @param key
49.      *            key whose associated value is to be returned
50.      * @return the value to which the cache maps the specified key, or null if
51.      *         the cacache contains no mapping for this key.
52.      */
53.     public Object fetch(Object key);
55.     /**
56.      * Returns all the objects stored in this cache.
57.      * <p>
58.      * This method is not needed to be synchronized.
59.      * </p>
60.      * 
61.      * @return a <code>Collection</code> of objects stored in the cache
62.      * @see #fetch(Object)
63.      */
64.     public Collection fetchAll();
66.     /**
67.      * Returns the identifier of this cache, which should be <tt>unique</tt>
68.      * and NOT <tt>null</tt>.
69.      * 
70.      * @return the unique identifier of this cache
71.      */
72.     public Object getIdentifier();
74.     /**
75.      * Returns <tt>true</tt> if this cache contains a mapping for the
76.      * specified key. (There can be at most one such mapping.)
77.      * <p>
78.      * If the key is <tt>null</tt>, this method always returns <tt>false</tt>.
79.      * Because cache does allow <tt>null</tt> keys or values.
80.      * </p>
81.      * 
82.      * @param key
83.      *            key whose presence in this cache is to be tested.
84.      * @return true if this map contains a mapping for the specified key
85.      */
86.     public boolean hasKey(Object key);
88.     /**
89.      * Returns <tt>true</tt> if the cache has one or more keys to the
90.      * specified object. More formally, returns <tt>true</tt> if and only if
91.      * the cache contains at least one mapping to an object.
92.      * <p>
93.      * Since cache does not allow null values, if the object is <tt>null</tt>,
94.      * always returns <tt>false</tt>.
95.      * </p>
96.      * 
97.      * @param object
98.      *            value whose presence in this map is to be tested.
99.      * @return <tt>true</tt> if this cache maps one or more keys to the
100.      *         specified value
101.      */
102.     public boolean hasObject(Object object);
104.     /**
105.      * Removes the mapping for this key from this cache if the key presents. If
106.      * the key is null, this method has no effect on cache.
107.      * 
108.      * @param key
109.      *            mapping key in the cache which is to be removed
110.      */
111.     public void remove(Object key);
113.     /**
114.      * Store the specified object with the specified key in this cache. If the
115.      * cache previously contained a mapping for this key, the old value is
116.      * replaced by the specified value.
117.      * <p>
118.      * Note that this method do not accept null key or null value. And this
119.      * method should be synchronized when possibly accessed by more than one
120.      * thread.
121.      * </p>
122.      * 
123.      * @param key
124.      *            key with which the specified object is to be associated.
125.      * @param value
126.      *            object to be stored in the cache, and associated with the
127.      *            specified key
128.      * @throws IllegalArgumentException
129.      *             if the key or value is null
130.      */
131.     public void save(Object key, Object value) throws IllegalArgumentException;
133.     /**
134.      * Save the object to the cache. The implementation must provide a key for
135.      * the association in the cache.
136.      * <p>
137.      * This method does not accepts null values. And it should be synchronized
138.      * in enviroment of multi-thread.
139.      * </p>
140.      * 
141.      * @param value
142.      *            the object to save
143.      * @throws IllegalArgumentException
144.      *             if the value is null
145.      * @see #save(Object, Object)
146.      * @see #createKey(Object)
147.      */
148.     public void save(Object value) throws IllegalArgumentException;
150.     /**
151.      * Adds all of the elements in the specified collection to this cache.
152.      * 
153.      * @param values
154.      *            objects to be saved into this cache
155.      * @throws IllegalArgumentException
156.      *             if one or more objects are null
157.      */
158.     public void saveAll(Collection values) throws IllegalArgumentException;
160.     /**
161.      * Copies all of the mappings from the specified map to this cache. The
162.      * effect of this call is equivalent to that of calling
163.      * {@link #save(Object,Object) save(key, value)} on this cache once for each
164.      * mapping from key to value in the specified map.
165.      * 
166.      * @param values
167.      *            mappings to be stored in this map
168.      * @throws IllegalArgumentException
169.      *             if one key or object is null
170.      */
171.     public void saveAll(Map values) throws IllegalArgumentException;
173.     /**
174.      * Returns the number of objects stored in this cache. If the cache contains
175.      * no data, returns zero.
176.      * 
177.      * @return the number of objects stored in a cache; returns zero if the
178.      *         cache contains no data
179.      */
180.     public int size();
182.     /**
183.      * Returns a collection of the keys contained in this cache.
184.      * 
185.      * @return keys in this cache
186.      */
187.     public Collection keys();
189. }

1. package com.alex.commonutil.cache;
3. /**
4.  */
5. public class CacheIncomingDataValidator {
6.     
7.     /**
8.      * Check whether an object is a valid instance of a specified Class.
9.      * 
10.      * @param obj     the object going to be validated
11.      * @param clazz   the specified Class
12.      * 
13.      * @return       true or false
14.      */
15.     public static boolean isValidObject(Class clazz, Object obj){
16.         if(null == obj || null == clazz){
17.             return false;
18.         }
19.         return clazz == obj.getClass();
20.     }
21. }

1. package com.alex.commonutil.cache;
3. /**
4.  * This class consists exclusively of static methods that operate on or return
5.  * caches.
6.  */
7. public class Caches {
9.     /**
10.      * If the key or value is null, throws an <tt>IllegalArgumentException</tt>.
11.      * 
12.      * @param object
13.      *            the key or value may store in a cache
14.      * @throws IllegalArgumentException
15.      *             if the key or value is null
16.      */
17.     public static void verifyKeyValue(Object object)
18.             throws IllegalArgumentException {
19.         if (object == null) {
20.             throw new IllegalArgumentException(
21.                     "Cache does not allow null key or values.");
22.         }
23.     }
25.     /**
26.      * If the identifier of a cache is null, this method will throw an
27.      * <tt>IllegalArgumentException</tt>.
28.      * 
29.      * @param identifier
30.      *            the identifier of a cache
31.      * @throws IllegalArgumentException
32.      *             if the identifier is null
33.      */
34.     public static void verifyIdentifier(Object identifier)
35.             throws IllegalArgumentException {
36.         if (identifier == null) {
37.             throw new IllegalArgumentException(
38.                     "The identifier of a cache should not be null");
39.         }
40.     }
41. }

1. package com.alex.commonutil.cache;
3. import java.util.Collection;
4. import java.util.Iterator;
5. import java.util.Map;
6. import java.util.Set;
8. /**
9.  * The cache service manages some caches, and providing a unified interface for
10.  * access them. Caches managed by the service can be located by the identifiers.
11.  * <p>
12.  * Since caches do not accept <tt>null</tt> keys or values, there are many
13.  * validations in those methods.
14.  * </p>
15.  */
16. public abstract class CacheService {
18.     /**
19.      * Add a cache into the service's management. The cache must provide an
20.      * available identifier.
21.      * 
22.      * @param cache
23.      *            a cache to be managed
24.      * @throws IllegalArgumentException
25.      *             if the cache does not provide an available identifier
26.      */
27.     public abstract void addCache(Cache cache) throws IllegalArgumentException;
29.     /**
30.      * Removes a cache of specified identifier out of the management. If the
31.      * cache is not under control, this method has no effect.
32.      * 
33.      * @param identifier
34.      *            the identifier of a cache
35.      */
36.     public abstract void removeCache(Object identifier);
38.     /**
39.      * Clear contents of one cache associated with speicified identifier. If the
40.      * cache does not exists or the identifier is <tt>null</tt>, this method
41.      * has no effect.
42.      * 
43.      * @param identifier
44.      *            the identifier of a cache
45.      */
46.     public void clear(Object identifier) {
47.         if (hasCache(identifier)) {
48.             getCache(identifier).clear();
49.         }
50.     }
52.     /**
53.      * Clears contents of all the caches.
54.      */
55.     public void clearAll() {
56.         for (Iterator it = getCaches().iterator(); it.hasNext();) {
57.             Cache cache = (Cache) it.next();
58.             cache.clear();
59.         }
60.     }
62.     /**
63.      * Determines in which cache the given object will be put. By the cache
64.      * identifier returned by this method, it would be easy to locate the cache.
65.      * 
66.      * @param object
67.      *            the object to be cached
68.      * @return the identifier of a cache in which the object will be put
69.      */
70.     public abstract Object getCacheIdentifier(Object object);
72.     /**
73.      * Get a collection of all the caches managed by this service.
74.      * 
75.      * @return an collection of caches managed by the service
76.      */
77.     public abstract Collection getCaches();
79.     /**
80.      * Returns true if the cache associated with specified identifier has a
81.      * mapping to the specified object.
82.      * <p>
83.      * If the given object is null, always returns false, because cache do not
84.      * allow <tt>null</tt> keys or values.
85.      * </p>
86.      * 
87.      * @param identifier
88.      *            the identifier of a cache
89.      * @param object
90.      *            key whose presence in the cache is to be tested
91.      * @param asKey
92.      *            whether take the object as key
93.      * @return true if the cache associated with specified identifier has one or
94.      *         more mapping to the specified key
95.      */
96.     public boolean contains(Object identifier, Object object, boolean asKey) {
97.         if (identifier == null || object == null) {
98.             return false;
99.         }
100.         if (!hasCache(identifier)) {
101.             return false;
102.         }
103.         Cache cache = getCache(identifier);
104.         return (asKey == true) ? cache.hasKey(object) : cache.hasObject(object);
105.     }
107.     /**
108.      * Returns true if the cache associated with specified identifier has a
109.      * mapping to the specified key.
110.      * <p>
111.      * If the key is <tt>null</tt>, always returns false, because cache do
112.      * not allow <tt>null</tt> keys or values.
113.      * </p>
114.      * 
115.      * @param identifier
116.      *            the identifier of a cache
117.      * @param object
118.      *            key whose presence in the cache is to be tested
119.      * @return true if the cache associated with specified identifier has a
120.      *         mapping to the specified key
121.      */
122.     public boolean contains(Object identifier, Object object) {
123.         return contains(identifier, object, false);
124.     }
126.     /**
127.      * Returns the number of caches managed by the service.
128.      * 
129.      * @return count of caches
130.      */
131.     public abstract int countOfCaches();
133.     /**
134.      * Returns the value to which maps the specified key in cache. Returns
135.      * <tt>null</tt> if the cache contains no mapping for this key.
136.      * <p>
137.      * If this method is not synchronized, the performance might be higher, and
138.      * would not brings chaos when accessed by more than one thread.
139.      * </p>
140.      * 
141.      * @param identifier
142.      *            the identifier of a cache
143.      * @param key
144.      *            the key whose associated value is to be returned
145.      * @return the value to which the cache maps the specified key, or
146.      *         <tt>null</tt> if the cacache contains no mapping for this key.
147.      */
148.     public Object fetch(Object identifier, Object key) {
149.         return getCache(identifier).fetch(key);
150.     }
152.     /**
153.      * Returns all the objects stored in a cache associated with specified
154.      * identifier.
155.      * <p>
156.      * This method is not needed to be synchronized.
157.      * </p>
158.      * 
159.      * @param identifier
160.      *            the identifier of a cache
161.      * @return a <code>Collection</code> of objects stored in the cache who is
162.      *         associated with specified identifier
163.      * @see #fetch(Object, Object)
164.      */
165.     public Collection fetchAll(Object identifier) {
166.         if (!hasCache(identifier)) {
167.             return null;
168.         }
169.         return getCache(identifier).fetchAll();
170.     }
172.     /**
173.      * Locates a cache by the its identifier. If the cache does not exist,
174.      * returns <tt>null</tt>.
175.      * 
176.      * @param identifier
177.      *            the identifier of the cache
178.      * @return a cache located by the identifier
179.      */
180.     public abstract Cache getCache(Object identifier);
182.     /**
183.      * Returns <tt>true</tt> if a cache is under management of the service,
184.      * and it can be located by the identifier. If the cache cannot be located
185.      * by the identifier, this method returns <tt>false</tt>. If the
186.      * identifier is <tt>null</tt>, this method always returns false.
187.      * 
188.      * @param identifier
189.      *            the identifier of the cache
190.      * @return <tt>true</tt> if the cache can be located by the identifier
191.      */
192.     public abstract boolean hasCache(Object identifier);
194.     /**
195.      * Removes the mapping for this key from a cache if it is present. If the
196.      * key is <tt>null</tt>, this method has no effect on cache.
197.      * 
198.      * @param identifier
199.      *            the identifier of a cache
200.      * @param key
201.      *            mapping key in the cache which is to be removed
202.      */
203.     public void remove(Object identifier, Object key) {
204.         if (!hasCache(identifier) || key == null) {
205.             return;
206.         }
207.         getCache(identifier).remove(key);
208.     }
210.     /**
211.      * Save an object to corresponding cache. The implementation must specify a
212.      * cache by {@link #getCacheIdentifier(Object)}, and provide an available
213.      * key for the association in the cache.
214.      * 
215.      * @param object
216.      *            the object to save
217.      * @throws IllegalArgumentException
218.      *             if the object is <tt>null</tt>
219.      * @see Cache#createKey(Object)
220.      * @see #getCacheIdentifier(Object)
221.      */
222.     public void save(Object object) throws IllegalArgumentException {
223.         Caches.verifyKeyValue(object);
225.         Object identifier = getCacheIdentifier(object);
226.         Object key = getCache(identifier).createKey(object);
227.         save(identifier, key, object);
228.     }
230.     /**
231.      * Save the object to the cache with an associated key. The implementation
232.      * must specify a cache.
233.      * <p>
234.      * This method does not accepts <tt>null</tt> values. And it should be
235.      * <tt>synchronized</tt> in enviroment of multi-thread.
236.      * </p>
237.      * 
238.      * @param key
239.      *            key with which the specified object is to be associated.
240.      * @param value
241.      *            object to be stored in the cache, and associated with the
242.      *            specified key
243.      * @throws IllegalArgumentException
244.      *             if the key or value is <tt>null</tt>
245.      * @see #save(Object, Object, Object)
246.      * @see Cache#createKey(Object)
247.      */
248.     public void save(Object key, Object value) throws IllegalArgumentException {
249.         Caches.verifyKeyValue(key);
250.         Caches.verifyKeyValue(value);
252.         Object identifier = getCacheIdentifier(value);
253.         save(identifier, key, value);
254.     }
256.     /**
257.      * Store the specified object with the specified key in a cache associated
258.      * with specified identifier. If the cache previously contained a mapping
259.      * for this key, the old value is replaced by the specified value.
260.      * <p>
261.      * This is a default implementation. If the cache cannot located by the
262.      * identifier, it would not be created. The sub classes may want to create a
263.      * new cache when necessary.
264.      * </p>
265.      * <p>
266.      * Note that this method do not accept <tt>null</tt> key or <tt>null</tt>
267.      * value. And this method should be synchronized when possibly accessed by
268.      * more than one thread.
269.      * </p>
270.      * 
271.      * @param identifier
272.      *            the identifier of a cache
273.      * @param key
274.      *            key with which the specified object is to be associated.
275.      * @param value
276.      *            object to be stored in the cache, and associated with the
277.      *            specified key
278.      * @throws IllegalArgumentException
279.      *             if the identifier, key or value is <tt>null</tt>
280.      */
281.     public void save(final Object identifier, final Object key,
282.             final Object value) throws IllegalArgumentException {
283.         /*
284.          * Make sure the identifier, key and value is not null
285.          */
286.         Caches.verifyIdentifier(identifier);
287.         Caches.verifyKeyValue(key);
288.         Caches.verifyKeyValue(value);
290.         getCache(identifier).save(key, value);
291.     }
293.     /**
294.      * Returns the number of objects stored in a cache. If the cache does not
295.      * exist or the given identifier is <tt>null</tt>, always return zero.
296.      * 
297.      * @param identifier
298.      *            the identifier of a cache
299.      * @return number of objects stored in a cache; or zero if the identifier is
300.      *         <tt>null</tt> or the cache does not exist
301.      */
302.     public int sizeOfCache(Object identifier) {
303.         if (!hasCache(identifier)) {
304.             return 0;
305.         }
306.         return getCache(identifier).size();
307.     }
309.     /**
310.      * Save all of the elements in the specified collection to a cache specified
311.      * by the identifier.
312.      * 
313.      * @param identifier
314.      *            the identifier of a cache
315.      * @param objects
316.      *            objects to be saved into a cache
317.      * @throws IllegalArgumentException
318.      *             if the identifier, one or more objects in collection are
319.      *             <tt>null</tt>
320.      */
321.     public void saveAll(Object identifier, Collection objects)
322.             throws IllegalArgumentException {
323.         Caches.verifyIdentifier(identifier);
324.         getCache(identifier).saveAll(objects);
325.     }
327.     /**
328.      * Copies all of the mappings from the specified map to a cache speicified
329.      * by the identifier.
330.      * 
331.      * @param identifier
332.      *            the identifier of a cache
333.      * @param objects
334.      *            objects to be saved into a cache
335.      * @throws IllegalArgumentException
336.      *             if the identifier, one key or object in mapping is
337.      *             <tt>null</tt>
338.      */
339.     public void saveAll(Object identifier, Map objects)
340.             throws IllegalArgumentException {
341.         Caches.verifyIdentifier(identifier);
342.         getCache(identifier).saveAll(objects);
343.     }
345.     /**
346.      * Save all of the elements in the specified collection to a cache. Before
347.      * saving these objects, please ensure that the corresponding cache has
348.      * provided available keys.
349.      * 
350.      * @param objects
351.      *            objects to be saved into a cache
352.      * @throws IllegalArgumentException
353.      *             if one object is <tt>null</tt>
354.      * @see #save(Object)
355.      * @see Cache#createKey(Object)
356.      */
357.     public void saveAll(Collection objects) throws IllegalArgumentException {
358.         for (Iterator it = objects.iterator(); it.hasNext();) {
359.             save(it.next());
360.         }
361.     }
363.     /**
364.      * Copies all of the mappings from the specified map to a cache. The effect
365.      * of this call is equivalent to that of calling
366.      * {@link #save(Object,Object) save(key, value)} on this cache once for each
367.      * mapping from key to value in the specified map.
368.      * 
369.      * @param objects
370.      *            mappings to be stored in this map
371.      * @see #save(Object, Object)
372.      * @throws IllegalArgumentException
373.      *             if one key or object is <tt>null</tt>
374.      */
375.     public void saveAll(Map objects) throws IllegalArgumentException {
376.         Set keys = objects.keySet();
377.         for (Iterator it = keys.iterator(); it.hasNext();) {
378.             Object k = (Object) it.next();
379.             save(k, objects.get(k));
380.         }
381.     }
382. }

1. package com.alex.commonutil.cache;
3. import java.util.Collection;
4. import java.util.HashMap;
6. public class ConcreteCacheService extends CacheService {
8.     /**
9.      * A lock used when creating cache. If a cache does not exist, this lock can
10.      * make sure that it will be created only once. And this
11.      * <tt>ReentrantLock</tt> can also provide better performance than the
12.      * <tt>synchronized</tt> key word.
13.      */
14.     private Object lock = new Object();
16.     /**
17.      * All the caches managed by the service.
18.      */
19.     private HashMap caches = new HashMap();
22.     public synchronized void addCache(Cache cache) throws IllegalArgumentException {
23.         if (cache == null) {
24.             throw new IllegalArgumentException("The cache is null.");
25.         }
27.         Object identifier = cache.getIdentifier();
28.         Caches.verifyIdentifier(identifier);
30.         caches.put(identifier, cache);
31.     }
34.     public synchronized int countOfCaches() {
35.         return caches.size();
36.     }
38.     /**
39.      * Locates a cache by the class of objects stored in it.
40.      * 
41.      * @param identifier
42.      *            the identifier of the cache
43.      * @return a cache located by the class
44.      */
45.     public synchronized  Cache getCache(Object identifier) {
46.         return (Cache)caches.get(identifier);
47.     }
50.     public  synchronized boolean hasCache(Object identifier) {
51.         if (!(identifier instanceof Class)) {
52.             return false;
53.         }
54.         return caches.containsKey(identifier);
55.     }
57.     /**
58.      * Store the specified object with the specified key in a cache associated
59.      * with specified identifier. If the cache cannot located by the identifier,
60.      * a new cache associated with the identifier will be created.
61.      * 
62.      * @param identifier
63.      *            the identifier of a cache
64.      * @param key
65.      *            key with which the specified object is to be associated.
66.      * @param value
67.      *            object to be stored in the cache, and associated with the
68.      *            specified key
69.      * @throws IllegalArgumentException
70.      *             if the identifier, key or value is <tt>null</tt>
71.      */
72.     public void save(final Object identifier, final Object key,
73.             final Object value) throws IllegalArgumentException {
74.         Caches.verifyIdentifier(identifier);
75.         Caches.verifyKeyValue(key);
76.         Caches.verifyKeyValue(value);
78.         /*
79.          * If a cache of certain class does not exist, a new cache of this class
80.          * will be created. The lock can make sure that the cache will be
81.          * created only once.
82.          */
83.         if (!hasCache(identifier)) {
84.             synchronized (lock) {
85.                 if (!hasCache(identifier)) {
86.                     Cache cache = new AbstractCache(identifier) {
87.                         public Object createKey(Object object) {
88.                             return key;
89.                         }
90.                     };
92.                     addCache(cache);
93.                     cache.save(key, value);
94.                 } else {
95.                     getCache(identifier).save(key, value);
96.                 }
97.             }
98.         } else {
99.             getCache(identifier).save(key, value);
100.         }
101.     }
104.     public  synchronized Collection getCaches() {
105.         return caches.values();
106.     }
109.     public  synchronized void removeCache(Object identifier) {
110.         caches.remove(identifier);
111.     }
114.     public Object getCacheIdentifier(Object object) {
115. //      if (object instanceof AbbrTradeLog) {
116. //          AbbrTradeLog a = (AbbrTradeLog) object;
117. //          return ((BBCacheServiceManager.TRADERID).equals(a.getCodeType())) ? BBCacheServiceManager.USERIDCACHE
118. //                  : AbbrTradeLog.class;
119. //      }
120.         return object.getClass();
121.     }
122. }

1. package com.alex.commonutil.cache;
3. import java.util.Collection;
5. /**
6.  * A persistable cache means it has a persisent storage as its backup, such as a
7.  * database, file system or some other devices.
8.  * <p>
9.  * A cache may need a persistent storage as its backup, because cache can not
10.  * hold data permanently. If power is off, the server crashes, or the cache
11.  * crashes, all the data in caches will be lost. It is much better that each new
12.  * added object can be persisted. When cache crashes, it can easily recover data
13.  * from persistent storage. And this makes data in a cache much safer than those
14.  * in caches without persistent storage.
15.  * </p>
16.  */
17. public interface PersistableCache extends Cache {
19.     /**
20.      * Persist contents in this cache to certain storage.
21.      * 
22.      * @throws Exception
23.      *             if an error occured
24.      */
25.     public void persist() throws Exception;
27.     /**
28.      * Persist one object to which maps the specified key in this cache to
29.      * certain storage.
30.      * 
31.      * @param key
32.      *            key with which the specified object is to be associated in
33.      *            this cache.
34.      * @throws Exception
35.      *             if an error occured
36.      */
37.     public void persist(Object key) throws Exception;
39.     /**
40.      * Synchronizes contents of the cache with its persistence.
41.      * 
42.      * @see #load()
43.      * @see #persist()
44.      * @throws Exception
45.      *             if an error occured
46.      */
47.     public void synchronize() throws Exception;
49.     /**
50.      * Synchronizes contents of the cache associated with speicified key with
51.      * its persistence.
52.      * 
53.      * @see #load(Object)
54.      * @see #persist(Object)
55.      * @throws Exception
56.      *             if an error occured
57.      */
58.     public void synchronize(Object key) throws Exception;
60.     /**
61.      * Load all the data from persistence to cache; returns all the loaded
62.      * objects.
63.      * 
64.      * @return all the loaded objects
65.      * @throws Exception
66.      *             if an error occured
67.      */
68.     public Collection load() throws Exception;
70.     /**
71.      * Load object associated with given key to the cache; and retusn the loaded
72.      * object.
73.      * 
74.      * @param key
75.      *            the key whose associated object is to be loaded
76.      * @return the object associated with the key
77.      * @throws Exception
78.      *             if an error occured
79.      */
80.     public Object load(Object key) throws Exception;
81. }

1. package com.alex.commonutil.cache;
3. import java.util.Collection;
4. import java.util.Iterator;
6. /**
7.  * This service manages persistable caches. A persistable cache means it has a
8.  * persisent storage as its backup, such as a database, file system or some
9.  * other devices.
10.  */
11. public abstract class PersistableCacheService extends CacheService {
13.     /**
14.      * Persist contents in a cache associated with specified identifier to
15.      * certain storage.
16.      * 
17.      * @param identifier
18.      *            the identifier of a cache
19.      * @throws Exception
20.      *             if an error occured
21.      */
22.     public void persist(Object identifier) throws Exception {
23.         if (hasCache(identifier)) {
24.             ((PersistableCache)getCache(identifier)).persist();
25.         }
26.     }
28.     /**
29.      * Persist one object to which maps the specified key in cache associated
30.      * with specified identifier to certain storage.
31.      * 
32.      * @param identifier
33.      *            the identifier of a cache
34.      * @param key
35.      *            key with which the specified object is to be associated in a
36.      *            cache.
37.      * @throws Exception
38.      *             if an error occured
39.      */
40.     public void persist(Object identifier, Object key) throws Exception {
41.         Caches.verifyKeyValue(key);
42.         if (hasCache(identifier)) {
43.             ((PersistableCache)getCache(identifier)).persist(key);
44.         }
45.     }
47.     /**
48.      * Persists all data in all caches to certain storage.
49.      * 
50.      * @throws Exception
51.      *             if an error occured
52.      */
53.     public void persistAll() throws Exception {
54.         for (Iterator it = getCaches().iterator(); it.hasNext();){
55.             PersistableCache cache = (PersistableCache) it;
56.             cache.persist();
57.         }
58.     }
60.     /**
61.      * Synchronizes contents of the cache with its persistent storage.
62.      * 
63.      * @param identifier
64.      *            the identifier of a cache
65.      * @throws Exception
66.      *             if an error occured
67.      */
68.     public void synchronize(Object identifier) throws Exception {
69.         if (hasCache(identifier)) {
70.             ((PersistableCache)getCache(identifier)).synchronize();
71.         }
72.     }
74.     /**
75.      * Synchronizes content of specified key in the cache with its persistent
76.      * storage.
77.      * 
78.      * @param identifier
79.      *            the identifier of a cache
80.      * @param key
81.      *            the key with which the specified object is to be associated in
82.      *            a cache. *
83.      * @throws Exception
84.      *             if an error occured
85.      */
86.     public void synchronize(Object identifier, Object key) throws Exception {
87.         Caches.verifyKeyValue(key);
88.         if (hasCache(identifier)) {
89.             ((PersistableCache)getCache(identifier)).synchronize(key);
90.         }
91.     }
93.     /**
94.      * Synchronizes contents of the all caches with their persistent storages.
95.      * 
96.      * @throws Exception
97.      *             if an error occured
98.      */
99.     public void synchronizeAll() throws Exception {
100. //      for (PersistableCache cache : getCaches()) {
101. //          cache.synchronize();
102. //      }
103.         
104.         for (Iterator it = getCaches().iterator(); it.hasNext();){
105.             PersistableCache cache = (PersistableCache) it;
106.             cache.synchronize();
107.         }
108.     }
110.     /**
111.      * Load all the data from persistence to all caches managed by the service;
112.      * returns all the loaded objects.
113.      * 
114.      * @return all the loaded objects
115.      * @throws Exception
116.      *             if an error occured
117.      */
118.     public void loadAll() throws Exception {
119. //      for (PersistableCache cache : getCaches()) {
120. //          cache.load();
121. //      }
122.         
123.         for (Iterator it = getCaches().iterator(); it.hasNext();){
124.             PersistableCache cache = (PersistableCache) it;
125.             cache.load();
126.         }
127.     }
129.     /**
130.      * Load objects in persistent storage for a cache which can be located by
131.      * the identifier; and retusn the loaded objects.
132.      * 
133.      * @param identifier
134.      *            the identifier of a cache
135.      * @return the objects for the cache in persist storage
136.      * @throws Exception
137.      *             if an error occured
138.      */
139.     public Collection load(Object identifier) throws Exception {
140.         return (hasCache(identifier)) ? ((PersistableCache)getCache(identifier)).load() : null;
141.     }
143.     /**
144.      * Load objects associated with given key to a cache which can be located by
145.      * the identifier; and retusn the loaded object.
146.      * 
147.      * @param identifier
148.      *            the identifier of a cache
149.      * @param key
150.      *            the key whose associated object is to be loaded
151.      * @return the object associated with the key
152.      * @throws Exception
153.      *             if an error occured
154.      */
155.     public Object load(Object identifier, Object key) throws Exception {
156.         Caches.verifyKeyValue(key);
157.         return (hasCache(identifier)) ? ((PersistableCache)getCache(identifier)).load(key) : null;
158.     }
161.     public abstract Cache getCache(Object identifier);
164.     public abstract Collection getCaches();
165. }

1. package com.alex.commonutil.cache.test;
3. import java.util.ArrayList;
4. import java.util.Iterator;
5. import java.util.List;
7. import com.alex.commonutil.cache.AbstractCache;
8. import com.alex.commonutil.cache.Cache;
9. import com.alex.commonutil.cache.CacheService;
10. import com.alex.commonutil.cache.ConcreteCacheService;
12. public class CacheTest {
13.     public static String CACHE_A = "CACHE_A";
14.     public static String CACHE_B = "CACHE_B";
16.     public static void main(String[] args) {
17.         CacheService cs = new ConcreteCacheService();
19.         Cache cacheA = new AbstractCache(CACHE_A) {
20.             public Object createKey(Object object)
21.                     throws IllegalArgumentException {
22.                 String str = (String) object;
23.                 return str;// tradeNumber as key
24.             }
25.         };
26.         cs.addCache(cacheA);
27.         
28.         List listTest = new ArrayList();
29.         listTest.add("AAA");
30.         listTest.add("BBB");
31.         cacheA.save("listTest", listTest);
32.         
34.         Cache cacheB = new AbstractCache(CACHE_B) {
35.             public Object createKey(Object object)
36.                     throws IllegalArgumentException {
37.                 String str = (String) object;
38.                 return str;// tradeNumber as key
39.             }
40.         };
41.         cs.addCache(cacheB);
43.         
44.         Cache cacheAA = cs.getCache(CACHE_A);
45.         List list=(List)cacheAA.fetch("listTest");
46.         Iterator itr = list.iterator();
47.         while (itr.hasNext()) {
48.             System.out.println(itr.next());
49.         }
50.     }
52. }

1. package com.alex.commonutil.cache.test;
3. import java.io.Serializable;
5. import org.apache.commons.lang.builder.EqualsBuilder;
6. import org.apache.commons.lang.builder.HashCodeBuilder;
7. import org.apache.commons.lang.builder.ToStringBuilder;
9. public class ValueObject implements Serializable {
10.     private static final long serialVersionUID = 2118933350226194725L;
12.     public java.lang.String getField1() {
13.         return field1;
14.     }
16.     public void setField1(java.lang.String field1) {
17.         this.field1 = field1;
18.     }
20.     public java.lang.String getField2() {
21.         return field2;
22.     }
24.     public void setField2(java.lang.String field2) {
25.         this.field2 = field2;
26.     }
28.     // fields
29.     private java.lang.String field1;
31.     private java.lang.String field2;
33.     
34.     public String toString() {
35.         return new ToStringBuilder(this).toString();
36.     }
37.     
38.     public int hashCode() {
39.         return new HashCodeBuilder().append(this.getField1()).append(
40.                 this.getField1()).toHashCode();
41.     }
43.     public boolean equals(Object obj) {
44.         if (obj == null)
45.             return false;
46.         if (!(obj instanceof ValueObject))
47.             return false;
48.         if (this == obj)
49.             return true;
50.         ValueObject other = (ValueObject) obj;
51.         return new EqualsBuilder()
52.                 .append(this.getField1(), other.getField1()).append(
53.                         this.getField2(), other.getField2()).isEquals();
54.     }
55. }