Coverage Report

Coverage Report - org.kuali.student.common.test.spring.IdToObjectEhcacheAdvice

Classes in this File

Line Coverage

Branch Coverage

Complexity

IdToObjectEhcacheAdvice

54%

28/51

37%

9/24

3.667

 /**
  * Copyright 2010 The Kuali Foundation Licensed under the
  * Educational Community License, Version 2.0 (the "License"); you may
  * not use this file except in compliance with the License. You may
  * obtain a copy of the License at
  *
  * http://www.osedu.org/licenses/ECL-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an "AS IS"
  * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  * or implied. See the License for the specific language governing
  * permissions and limitations under the License.
  */
 
 package org.kuali.student.common.test.spring;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import net.sf.ehcache.CacheManager;
 import net.sf.ehcache.Element;
 import net.sf.ehcache.ObjectExistsException;
 
 import org.aopalliance.aop.Advice;
 import org.apache.log4j.Logger;
 import org.aspectj.lang.ProceedingJoinPoint;
 
 public class IdToObjectEhcacheAdvice implements Advice {
         final Logger LOG = Logger.getLogger(IdToObjectEhcacheAdvice.class);
         
         private CacheManager cacheManager;
         private String cacheName;
 
         /**
          * 
          */
         public IdToObjectEhcacheAdvice() {
                 super();
         }
 
         /**
          * @param cacheName
          */
         public IdToObjectEhcacheAdvice(String cacheName) {
                 super();
                 this.cacheName = cacheName;
         }
 
         public Object invalidateCache(ProceedingJoinPoint pjp) throws Throwable {
                 if (cacheManager == null) {
                         cacheManager = CacheManager.getInstance();
                         try {
                                 cacheManager.addCache(cacheName);
                         } catch (ObjectExistsException e) {
 
                         }
                 }
                 LOG.info("Invalidating Cache");
                 cacheManager.getCache(cacheName).remove(pjp.getArgs()[0]);
                 return pjp.proceed();
         }
 
         @SuppressWarnings("unchecked")
         public Object getFromCache(ProceedingJoinPoint pjp) throws Throwable {
                 if (cacheManager == null) {
                         cacheManager = CacheManager.getInstance();
                         try {
                                 cacheManager.addCache(cacheName);
                         } catch (ObjectExistsException e) {
 
                         }
                 }
                 // Have two caches for the one object? one by id, the other by method
                 // call?
                 if (pjp.getArgs().length == 1 && pjp.getArgs()[0] instanceof List) {
                         List<Object> results = new ArrayList<Object>();
                         List<String> uncachedIdList = new ArrayList<String>();
                         for (String id : (List<String>) pjp.getArgs()[0]) {
                                 // Look in the cache
                                 LOG.info("Looking in Cache");
                                 Element cachedResult = cacheManager.getCache(cacheName).get(id);
                                 if (cachedResult == null) {
                                         uncachedIdList.add(id);
                                 } else {
                                         results.add(cachedResult.getValue());
                                 }
                         }
                         if (uncachedIdList.size() > 0) {
                                 List<Idable> uncachedResults = (List<Idable>) pjp.proceed();
                                 if (uncachedResults != null) {
                                         for (Idable uncachedResult : uncachedResults) {
                                                 // Add to the cache and add to results
                                                 LOG.info("Storing to Cache");
                                                 results.add(uncachedResult);
                                                 cacheManager.getCache(cacheName).put(
                                                                 new Element(uncachedResult.getId(),
                                                                                 uncachedResult));
                                         }
                                 }
                         }
                         return results;
                 }
                 if (pjp.getArgs().length == 1 && pjp.getArgs()[0] instanceof String) {
                         String id = (String) pjp.getArgs()[0];
                         LOG.info("Looking in Cache");
                         Element resultElement = cacheManager.getCache(cacheName).get(id);
                         Object result;
                         if (resultElement == null) {
                                 result = pjp.proceed();
                                 LOG.info("Storing to Cache");
                                 cacheManager.getCache(cacheName).put(new Element(id, result));
                         } else {
                                 result = resultElement.getValue();
                         }
                         return result;
                 }
 
                 return pjp.proceed();
         }
 
         /**
          * @return the cacheName
          */
         public String getCacheName() {
                 return cacheName;
         }
 
         /**
          * @param cacheName
          *            the cacheName to set
          */
         public void setCacheName(String cacheName) {
                 this.cacheName = cacheName;
         }
 
 }

1		/**
2		* Copyright 2010 The Kuali Foundation Licensed under the
3		* Educational Community License, Version 2.0 (the "License"); you may
4		* not use this file except in compliance with the License. You may
5		* obtain a copy of the License at
6		*
7		* http://www.osedu.org/licenses/ECL-2.0
8		*
9		* Unless required by applicable law or agreed to in writing,
10		* software distributed under the License is distributed on an "AS IS"
11		* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
12		* or implied. See the License for the specific language governing
13		* permissions and limitations under the License.
14		*/
15
16		package org.kuali.student.common.test.spring;
17
18		import java.util.ArrayList;
19		import java.util.List;
20
21		import net.sf.ehcache.CacheManager;
22		import net.sf.ehcache.Element;
23		import net.sf.ehcache.ObjectExistsException;
24
25		import org.aopalliance.aop.Advice;
26		import org.apache.log4j.Logger;
27		import org.aspectj.lang.ProceedingJoinPoint;
28
29		public class IdToObjectEhcacheAdvice implements Advice {
30	4	final Logger LOG = Logger.getLogger(IdToObjectEhcacheAdvice.class);
31
32		private CacheManager cacheManager;
33		private String cacheName;
34
35		/**
36		*
37		*/
38		public IdToObjectEhcacheAdvice() {
39	3	super();
40	3	}
41
42		/**
43		* @param cacheName
44		*/
45		public IdToObjectEhcacheAdvice(String cacheName) {
46	1	super();
47	1	this.cacheName = cacheName;
48	1	}
49
50		public Object invalidateCache(ProceedingJoinPoint pjp) throws Throwable {
51	2	if (cacheManager == null) {
52	0	cacheManager = CacheManager.getInstance();
53		try {
54	0	cacheManager.addCache(cacheName);
55	0	} catch (ObjectExistsException e) {
56
57	0	}
58		}
59	2	LOG.info("Invalidating Cache");
60	2	cacheManager.getCache(cacheName).remove(pjp.getArgs()[0]);
61	2	return pjp.proceed();
62		}
63
64		@SuppressWarnings("unchecked")
65		public Object getFromCache(ProceedingJoinPoint pjp) throws Throwable {
66	7	if (cacheManager == null) {
67	3	cacheManager = CacheManager.getInstance();
68		try {
69	3	cacheManager.addCache(cacheName);
70	1	} catch (ObjectExistsException e) {
71
72	2	}
73		}
74		// Have two caches for the one object? one by id, the other by method
75		// call?
76	7	if (pjp.getArgs().length == 1 && pjp.getArgs()[0] instanceof List) {
77	0	List<Object> results = new ArrayList<Object>();
78	0	List<String> uncachedIdList = new ArrayList<String>();
79	0	for (String id : (List<String>) pjp.getArgs()[0]) {
80		// Look in the cache
81	0	LOG.info("Looking in Cache");
82	0	Element cachedResult = cacheManager.getCache(cacheName).get(id);
83	0	if (cachedResult == null) {
84	0	uncachedIdList.add(id);
85		} else {
86	0	results.add(cachedResult.getValue());
87		}
88	0	}
89	0	if (uncachedIdList.size() > 0) {
90	0	List<Idable> uncachedResults = (List<Idable>) pjp.proceed();
91	0	if (uncachedResults != null) {
92	0	for (Idable uncachedResult : uncachedResults) {
93		// Add to the cache and add to results
94	0	LOG.info("Storing to Cache");
95	0	results.add(uncachedResult);
96	0	cacheManager.getCache(cacheName).put(
97		new Element(uncachedResult.getId(),
98		uncachedResult));
99		}
100		}
101		}
102	0	return results;
103		}
104	7	if (pjp.getArgs().length == 1 && pjp.getArgs()[0] instanceof String) {
105	7	String id = (String) pjp.getArgs()[0];
106	7	LOG.info("Looking in Cache");
107	7	Element resultElement = cacheManager.getCache(cacheName).get(id);
108		Object result;
109	7	if (resultElement == null) {
110	6	result = pjp.proceed();
111	6	LOG.info("Storing to Cache");
112	6	cacheManager.getCache(cacheName).put(new Element(id, result));
113		} else {
114	1	result = resultElement.getValue();
115		}
116	7	return result;
117		}
118
119	0	return pjp.proceed();
120		}
121
122		/**
123		* @return the cacheName
124		*/
125		public String getCacheName() {
126	0	return cacheName;
127		}
128
129		/**
130		* @param cacheName
131		* the cacheName to set
132		*/
133		public void setCacheName(String cacheName) {
134	3	this.cacheName = cacheName;
135	3	}
136
137		}