redis应用—缓存

项目的缓存设计主要是这样的，监听数据库中表的改变，如果会发生变动，则对缓存做一些处理，具体实现如下：

 （1）缓存支持类（实体、辅助类等）的设计

实体缓存注释类 NeedCache

[java] view plain copy print ?

1. <SPAN style="FONT-SIZE: 14px">/** 
2.  * 缓存的注释类，如果需要缓存某个类，请在类上添加此注释类，并给出cache的处理类 
3.  *  
4.  * @author liuyang 
5.  *  
6.  */  
7. @Documented  
8. @Target(value = ElementType.TYPE)  
9. @Retention(RetentionPolicy.RUNTIME)  
10. public @interface NeedCache {  
11.   
12.     Class<?> cacheDealClass();  
13.   
14. }</SPAN>  

/**
 * 缓存的注释类，如果需要缓存某个类，请在类上添加此注释类，并给出cache的处理类
 * 
 * @author liuyang
 * 
 */
@Documented
@Target(value = ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface NeedCache {

	Class<?> cacheDealClass();

}

缓存类 Cache

[java] view plain copy print ?

1. <SPAN style="FONT-SIZE: 14px">/** 
2.  * 对象缓存类 
3.  *  
4.  * @author liuyang 
5.  *  
6.  */  
7. public class Cache {  
8.   
9.     private String key;  
10.   
11.     private Map<String,String> fieldHashMap;  
12.   
13.     private int expiredSeconds;  
14.   
15.     private long expiredTime;  
16.   
17.     /** 
18.      * 键 
19.      *  
20.      * @return 
21.      */  
22.     public String getKey() {  
23.         return key;  
24.     }  
25.   
26.     public void setKey(String key) {  
27.         this.key = key;  
28.     }  
29.   
30.     /** 
31.      * 缓存的对象map 
32.      * @return 
33.      */  
34.     public Map<String, String> getFieldHashMap() {  
35.         return fieldHashMap;  
36.     }  
37.   
38.     public void setFieldHashMap(Map<String, String> fieldHashMap) {  
39.         this.fieldHashMap = fieldHashMap;  
40.     }  
41.   
42.     /** 
43.      * 过期秒数 
44.      *  
45.      * @return 
46.      */  
47.     public int getExpiredSeconds() {  
48.         return expiredSeconds;  
49.     }  
50.   
51.     public void setExpiredSeconds(int expiredSeconds) {  
52.         this.expiredSeconds = expiredSeconds;  
53.     }  
54.   
55.     /** 
56.      * 过期时间 
57.      *  
58.      * @return 
59.      */  
60.     public long getExpiredTime() {  
61.         return expiredTime;  
62.     }  
63.   
64.     public void setExpiredTime(long expiredTime) {  
65.         this.expiredTime = expiredTime;  
66.     }  
67.   
68. }</SPAN>  

/**
 * 对象缓存类
 * 
 * @author liuyang
 * 
 */
public class Cache {

	private String key;

	private Map<String,String> fieldHashMap;

	private int expiredSeconds;

	private long expiredTime;

	/**
	 * 键
	 * 
	 * @return
	 */
	public String getKey() {
		return key;
	}

	public void setKey(String key) {
		this.key = key;
	}

	/**
	 * 缓存的对象map
	 * @return
	 */
	public Map<String, String> getFieldHashMap() {
		return fieldHashMap;
	}

	public void setFieldHashMap(Map<String, String> fieldHashMap) {
		this.fieldHashMap = fieldHashMap;
	}

	/**
	 * 过期秒数
	 * 
	 * @return
	 */
	public int getExpiredSeconds() {
		return expiredSeconds;
	}

	public void setExpiredSeconds(int expiredSeconds) {
		this.expiredSeconds = expiredSeconds;
	}

	/**
	 * 过期时间
	 * 
	 * @return
	 */
	public long getExpiredTime() {
		return expiredTime;
	}

	public void setExpiredTime(long expiredTime) {
		this.expiredTime = expiredTime;
	}

}

缓存处理接口类 CacheDeal

[java] view plain copy print ?

1. <SPAN style="FONT-SIZE: 14px">/** 
2.  * 缓存处理接口 
3.  *  
4.  * @author liuyang 
5.  *  
6.  */  
7. public interface CacheDeal {  
8.   
9.     /** 
10.      * 添加缓存 
11.      *  
12.      * @param cachedEntity 
13.      */  
14.     void addCache(Object cachedEntity);  
15.   
16.     /** 
17.      * 移除缓存 
18.      *  
19.      * @param cachedEntity 
20.      */  
21.     void removeCache(Object cachedEntity);  
22.   
23.     /** 
24.      * 更新缓存 
25.      *  
26.      * @param cachedEntity 
27.      */  
28.     void updateCache(Object cachedEntity);  
29.   
30.     /** 
31.      * 获取缓存 
32.      *  
33.      * @param key 
34.      * @return 
35.      */  
36.     Cache getCache(String key);  
37.   
38. }</SPAN>  

/**
 * 缓存处理接口
 * 
 * @author liuyang
 * 
 */
public interface CacheDeal {

	/**
	 * 添加缓存
	 * 
	 * @param cachedEntity
	 */
	void addCache(Object cachedEntity);

	/**
	 * 移除缓存
	 * 
	 * @param cachedEntity
	 */
	void removeCache(Object cachedEntity);

	/**
	 * 更新缓存
	 * 
	 * @param cachedEntity
	 */
	void updateCache(Object cachedEntity);

	/**
	 * 获取缓存
	 * 
	 * @param key
	 * @return
	 */
	Cache getCache(String key);

}

（2）缓存监听、管理类设计

          这里用了hibernate的监听类，创建3个监听类，插入、修改、删除分别继承Ejb3PostInsertEventListener，Ejb3PostUpdateEventListener，Ejb3DeleteInsertEventListener，srping配置文件如下配置：

[html] view plain copy print ?

1. <SPAN style="FONT-SIZE: 14px"><!-- Jpa Entity Manager 配置 -->  
2.     <bean id="entityManagerFactory"  
3.         class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">  
4.         <property name="dataSource" ref="dataSource" />  
5.         <property name="persistenceUnitName" value="defaultPU" />  
6.         <property name="persistenceUnitManager" ref="persistenceUnitManager"/>  
7.         <property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter" />  
8.         <property name="jpaProperties">  
9.             <props>  
10.                 <prop key="hibernate.dialect">${hibernate.dialect}</prop>  
11.                 <prop key="hibernate.show_sql">false</prop>  
12.                 <prop key="hibernate.format_sql">false</prop>  
13.                 <prop key="hibernate.hbm2ddl.auto">update</prop>  
14.                 <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>  
15.                 <prop key="hibernate.search.default.directory_provider">org.hibernate.search.store.impl.FSDirectoryProvider</prop>  
16.                 <prop key="hibernate.search.default.indexBase">./build/indexes</prop>  
17.                 <prop key="hibernate.search.lucene_version">LUCENE_35</prop>  
18.                   
19.                 <!-- for hibernate ejb event -->  
20.                 <prop key="hibernate.ejb.event.post-insert">  
21.                     com.liuyang.infrastructure.cache.listener.ejb.PostInsertEventListener  
22.                 </prop>  
23.                 <prop key="hibernate.ejb.event.post-update">  
24.                     com.liuyang.infrastructure.cache.listener.ejb.PostUpdateEventListener  
25.                 </prop>  
26.                 <prop key="hibernate.ejb.event.post-delete">  
27.                     com.liuyang.infrastructure.cache.listener.ejb.PostDeleteEventListener  
28.                 </prop>  
29.                   
30.             </props>  
31.         </property>  
32.     </bean></SPAN>  

<!-- Jpa Entity Manager 配置 -->
	<bean id="entityManagerFactory"
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="persistenceUnitName" value="defaultPU" />
		<property name="persistenceUnitManager" ref="persistenceUnitManager"/>
		<property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter" />
		<property name="jpaProperties">
			<props>
				<prop key="hibernate.dialect">${hibernate.dialect}</prop>
				<prop key="hibernate.show_sql">false</prop>
				<prop key="hibernate.format_sql">false</prop>
				<prop key="hibernate.hbm2ddl.auto">update</prop>
				<prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
				<prop key="hibernate.search.default.directory_provider">org.hibernate.search.store.impl.FSDirectoryProvider</prop>
				<prop key="hibernate.search.default.indexBase">./build/indexes</prop>
				<prop key="hibernate.search.lucene_version">LUCENE_35</prop>
				
				<!-- for hibernate ejb event -->
				<prop key="hibernate.ejb.event.post-insert">
					com.liuyang.infrastructure.cache.listener.ejb.PostInsertEventListener
				</prop>
				<prop key="hibernate.ejb.event.post-update">
					com.liuyang.infrastructure.cache.listener.ejb.PostUpdateEventListener
				</prop>
				<prop key="hibernate.ejb.event.post-delete">
					com.liuyang.infrastructure.cache.listener.ejb.PostDeleteEventListener
				</prop>
				
			</props>
		</property>
	</bean>

缓存管理类

[java] view plain copy print ?

1. public class CacheManager {  
2.   
3.     private static CacheManager instance = null;  
4.   
5.     private static CacheDeal cacheDeal = null;  
6.   
7.     private static Object cachedEntity = null;  
8.   
9.     private CacheManager() {  
10.     }  
11.   
12.     public static CacheManager getNewInstance(Object cachedEntity) {  
13.         CacheManager.cacheDeal = getCacheDealObject(cachedEntity.getClass());  
14.         CacheManager.cachedEntity = cachedEntity;  
15.         if (instance == null)  
16.             synchronized (CacheManager.class) {  
17.                 if (instance == null) {  
18.                     instance = new CacheManager();  
19.                 }  
20.             }  
21.         return instance;  
22.     }  
23.   
24.     public void addCache() {  
25.         if (isNull())  
26.             return;  
27.         cacheDeal.addCache(cachedEntity);  
28.     }  
29.   
30.     public void removeCache() {  
31.         if (isNull())  
32.             return;  
33.         cacheDeal.removeCache(cachedEntity);  
34.     }  
35.   
36.     public void updateCache() {  
37.         if (isNull())  
38.             return;  
39.         cacheDeal.updateCache(cachedEntity);  
40.     }  
41.   
42.     public Cache getCache(String key) {  
43.         if (isNull())  
44.             return null;  
45.         return cacheDeal.getCache(key);  
46.     }  
47.   
48.     private boolean isNull() {  
49.         return cacheDeal == null || cachedEntity == null;  
50.     }  
51.   
52.     private static CacheDeal getCacheDealObject(Class<?> cachedClazz) {  
53.         CacheDeal cacheDealObject = null;  
54.         try {  
55.             boolean hasNeedCacheAnnotation = cachedClazz  
56.                     .isAnnotationPresent(NeedCache.class);  
57.             if (hasNeedCacheAnnotation) {  
58.                 NeedCache needCache = cachedClazz  
59.                         .getAnnotation(NeedCache.class);  
60.                 cacheDealObject = (CacheDeal) SpringContextHolder  
61.                         .getBean(needCache.cacheDealClass());  
62.             }  
63.         } catch (Exception e) {  
64.             LoggerUtil.error(CacheManager.class, cachedClazz + "获取缓存处理类失败", e);  
65.         }  
66.         return cacheDealObject;  
67.     }  
68.   
69. }  

public class CacheManager {

	private static CacheManager instance = null;

	private static CacheDeal cacheDeal = null;

	private static Object cachedEntity = null;

	private CacheManager() {
	}

	public static CacheManager getNewInstance(Object cachedEntity) {
		CacheManager.cacheDeal = getCacheDealObject(cachedEntity.getClass());
		CacheManager.cachedEntity = cachedEntity;
		if (instance == null)
			synchronized (CacheManager.class) {
				if (instance == null) {
					instance = new CacheManager();
				}
			}
		return instance;
	}

	public void addCache() {
		if (isNull())
			return;
		cacheDeal.addCache(cachedEntity);
	}

	public void removeCache() {
		if (isNull())
			return;
		cacheDeal.removeCache(cachedEntity);
	}

	public void updateCache() {
		if (isNull())
			return;
		cacheDeal.updateCache(cachedEntity);
	}

	public Cache getCache(String key) {
		if (isNull())
			return null;
		return cacheDeal.getCache(key);
	}

	private boolean isNull() {
		return cacheDeal == null || cachedEntity == null;
	}

	private static CacheDeal getCacheDealObject(Class<?> cachedClazz) {
		CacheDeal cacheDealObject = null;
		try {
			boolean hasNeedCacheAnnotation = cachedClazz
					.isAnnotationPresent(NeedCache.class);
			if (hasNeedCacheAnnotation) {
				NeedCache needCache = cachedClazz
						.getAnnotation(NeedCache.class);
				cacheDealObject = (CacheDeal) SpringContextHolder
						.getBean(needCache.cacheDealClass());
			}
		} catch (Exception e) {
			LoggerUtil.error(CacheManager.class, cachedClazz + "获取缓存处理类失败", e);
		}
		return cacheDealObject;
	}

}

PostInsertEventListener类为例

[java] view plain copy print ?

1. <SPAN style="FONT-SIZE: 14px">public class PostInsertEventListener extends EJB3PostInsertEventListener{  
2.   
3.     private static final long serialVersionUID = 7401854577429048855L;  
4.   
5.     @Override  
6.     public void onPostInsert(PostInsertEvent event) {  
7.         super.onPostInsert(event);  
8.         CacheManager cacheManager = CacheManager.getNewInstance(event.getEntity());  
9.         cacheManager.addCache();  
10.     }  
11.   
12. }  
13. </SPAN>  

public class PostInsertEventListener extends EJB3PostInsertEventListener{

	private static final long serialVersionUID = 7401854577429048855L;

	@Override
	public void onPostInsert(PostInsertEvent event) {
		super.onPostInsert(event);
		CacheManager cacheManager = CacheManager.getNewInstance(event.getEntity());
		cacheManager.addCache();
	}

}

以上是缓存设计的核心代码，如果要实现用户的缓存管理需要创建用户缓存管理类，并实现CacheDeal接口：

需要缓存的用户实体类 UserInfo

[java] view plain copy print ?

1. /** 
2.  * 用户类 
3.  *  
4.  * @author liuyang 
5.  *  
6.  */  
7. @Entity  
8. @Indexed  
9. @Table(name = "user_info")  
10. @NeedCache(cacheDealClass = UserCacheManager.class)//用户缓存管理类   
11. public class UserInfo extends IdEntity implements Serializable {  
12.   
13.     private static final long serialVersionUID = 8046430120913324930L;  
14.   
15.     private String loginName;  
16.   
17.     private String password;  
18.   
19.     private String name;  
20.   
21.     private String email;  

/**
 * 用户类
 * 
 * @author liuyang
 * 
 */
@Entity
@Indexed
@Table(name = "user_info")
@NeedCache(cacheDealClass = UserCacheManager.class)//用户缓存管理类
public class UserInfo extends IdEntity implements Serializable {

	private static final long serialVersionUID = 8046430120913324930L;

	private String loginName;

	private String password;

	private String name;

	private String email;

[java] view plain copy print ?

1. <SPAN style="WHITE-SPACE: pre"> </SPAN>//getter setter省略  

	//getter setter省略

[java] view plain copy print ?

1. }  

}

用户缓存管理类

[java] view plain copy print ?

1. /** 
2.  * 用户缓存管理类 
3.  *  
4.  * @author liuyang 
5.  *  
6.  */  
7. @Component  
8. public class UserCacheManager implements CacheDeal {  
9.   
10.     @Autowired  
11.     private UserRepository userRepository;//数据库user dao   
12.   
13.     @Autowired  
14.     private JedisManagerCache jedisManagerCache;//jedis管理类   
15.   
16.     @Override  
17.     public void addCache(Object cachedEntity) {  
18.         UserInfo user = (UserInfo) cachedEntity;  
19.         addUserCache(user);  
20.     }  
21.   
22.     @Override  
23.     public void removeCache(Object cachedEntity) {  
24.         UserInfo user = (UserInfo) cachedEntity;  
25.         removeUserCache(user);  
26.     }  
27.   
28.     @Override  
29.     public void updateCache(Object cachedEntity) {  
30.         UserInfo user = (UserInfo) cachedEntity;  
31.         String userKey = KeyConstants.USER_ + user.getId();  
32.         Map<String, String> userHash = buildUserHash(user);  
33.         jedisManagerCache.saveHash(userKey, userHash);  
34.     }  
35.   
36.     @Override  
37.     public Cache getCache(String key) {  
38.         Cache cache = new Cache();  
39.         cache.setKey(key);  
40.         cache.setFieldHashMap(jedisManagerCache.getHashMapByKey(key));  
41.         return cache;  
42.     }  
43.   
44.     @Override  
45.     public void init() {  
46.         List<UserInfo> allUserList = getAllUsers();  
47.         for (UserInfo user : allUserList) {  
48.             addUserCache(user);  
49.         }  
50.     }  
51.   
52.     /** 
53.      * 新增用户时，添加用户缓存 
54.      *  
55.      * @param user 
56.      */  
57.     private void addUserCache(UserInfo user) {  
58.         Jedis jedis = null;  
59.         Transaction tran = null;  
60.         try {  
61.             jedis = jedisManagerCache.getJedis();  
62.             tran = jedis.multi();  
63.             String userKey = KeyConstants.USER_ + user.getId();  
64.             String userLesseeKey = KeyConstants.USER_LESSEE_  
65.                     + user.getLessee().getId();  
66.             Map<String, String> userHash = buildUserHash(user);  
67.             tran.hmset(userKey, userHash);  
68.             tran.sadd(userLesseeKey, user.getId().toString());  
69.             tran.set("user:" + user.getEmail() + ":id", user.getId().toString());  
70.             tran.exec();  
71.         } catch (Exception e) {  
72.             tran.discard();  
73.             LoggerUtil.error(UserCacheManager.class, "添加" + user.getEmail()  
74.                     + "缓存失败", e);  
75.         } finally {  
76.             jedisManagerCache.returnResource(jedis);  
77.         }  
78.     }  
79.   
80.     /** 
81.      * 移除用户缓存 
82.      *  
83.      * @param user 
84.      */  
85.     private void removeUserCache(UserInfo user) {  
86.         Jedis jedis = null;  
87.         Transaction tran = null;  
88.         try {  
89.             jedis = jedisManagerCache.getJedis();  
90.             tran = jedis.multi();  
91.             String userKey = KeyConstants.USER_ + user.getId();  
92.             String userLesseeKey = KeyConstants.USER_LESSEE_  
93.                     + user.getLessee().getId();  
94.             tran.del(userKey);  
95.             tran.srem(userLesseeKey, user.getId().toString());  
96.             tran.del("user:" + user.getEmail() + ":id");  
97.             tran.exec();  
98.         } catch (Exception e) {  
99.             tran.discard();  
100.             LoggerUtil.error(UserCacheManager.class, "删除" + user.getEmail()  
101.                     + "缓存失败", e);  
102.         } finally {  
103.             jedisManagerCache.returnResource(jedis);  
104.         }  
105.     }  
106.   
107.     /** 
108.      * 构建用户hashmap 
109.      *  
110.      * @param user 
111.      * @return 
112.      */  
113.     private Map<String, String> buildUserHash(UserInfo user) {  
114.         Map<String, String> userHash = new HashMap<String, String>();  
115.         userHash.put("login_name", user.getLoginName());  
116.         userHash.put("name", user.getName());  
117.         userHash.put("email", user.getEmail());  
118.         if (null != user.getUserGroup())  
119.             userHash.put("user_group_name", user.getUserGroup().getName());  
120.         return userHash;  
121.     }  
122.   
123. }  

/**
 * 用户缓存管理类
 * 
 * @author liuyang
 * 
 */
@Component
public class UserCacheManager implements CacheDeal {

	@Autowired
	private UserRepository userRepository;//数据库user dao

	@Autowired
	private JedisManagerCache jedisManagerCache;//jedis管理类

	@Override
	public void addCache(Object cachedEntity) {
		UserInfo user = (UserInfo) cachedEntity;
		addUserCache(user);
	}

	@Override
	public void removeCache(Object cachedEntity) {
		UserInfo user = (UserInfo) cachedEntity;
		removeUserCache(user);
	}

	@Override
	public void updateCache(Object cachedEntity) {
		UserInfo user = (UserInfo) cachedEntity;
		String userKey = KeyConstants.USER_ + user.getId();
		Map<String, String> userHash = buildUserHash(user);
		jedisManagerCache.saveHash(userKey, userHash);
	}

	@Override
	public Cache getCache(String key) {
		Cache cache = new Cache();
		cache.setKey(key);
		cache.setFieldHashMap(jedisManagerCache.getHashMapByKey(key));
		return cache;
	}

	@Override
	public void init() {
		List<UserInfo> allUserList = getAllUsers();
		for (UserInfo user : allUserList) {
			addUserCache(user);
		}
	}

	/**
	 * 新增用户时，添加用户缓存
	 * 
	 * @param user
	 */
	private void addUserCache(UserInfo user) {
		Jedis jedis = null;
		Transaction tran = null;
		try {
			jedis = jedisManagerCache.getJedis();
			tran = jedis.multi();
			String userKey = KeyConstants.USER_ + user.getId();
			String userLesseeKey = KeyConstants.USER_LESSEE_
					+ user.getLessee().getId();
			Map<String, String> userHash = buildUserHash(user);
			tran.hmset(userKey, userHash);
			tran.sadd(userLesseeKey, user.getId().toString());
			tran.set("user:" + user.getEmail() + ":id", user.getId().toString());
			tran.exec();
		} catch (Exception e) {
			tran.discard();
			LoggerUtil.error(UserCacheManager.class, "添加" + user.getEmail()
					+ "缓存失败", e);
		} finally {
			jedisManagerCache.returnResource(jedis);
		}
	}

	/**
	 * 移除用户缓存
	 * 
	 * @param user
	 */
	private void removeUserCache(UserInfo user) {
		Jedis jedis = null;
		Transaction tran = null;
		try {
			jedis = jedisManagerCache.getJedis();
			tran = jedis.multi();
			String userKey = KeyConstants.USER_ + user.getId();
			String userLesseeKey = KeyConstants.USER_LESSEE_
					+ user.getLessee().getId();
			tran.del(userKey);
			tran.srem(userLesseeKey, user.getId().toString());
			tran.del("user:" + user.getEmail() + ":id");
			tran.exec();
		} catch (Exception e) {
			tran.discard();
			LoggerUtil.error(UserCacheManager.class, "删除" + user.getEmail()
					+ "缓存失败", e);
		} finally {
			jedisManagerCache.returnResource(jedis);
		}
	}

	/**
	 * 构建用户hashmap
	 * 
	 * @param user
	 * @return
	 */
	private Map<String, String> buildUserHash(UserInfo user) {
		Map<String, String> userHash = new HashMap<String, String>();
		userHash.put("login_name", user.getLoginName());
		userHash.put("name", user.getName());
		userHash.put("email", user.getEmail());
		if (null != user.getUserGroup())
			userHash.put("user_group_name", user.getUserGroup().getName());
		return userHash;
	}

}

这样，就可以监听数据库改变并跟心缓存了，其中jedisCacheManager就是我自己封装的常用的jedis操作方法，这个大家可以自己实现，用到什么去做封装。

（3）添加服务器启动时，写入缓存功能

我们肯定会遇到，在服务器启动时，去写入很多缓存，这样，在服务器运行中，就可以直接调用缓存了，下面就是这个功能的设计：

让上面的UserCacheManager在多实现一个接口InitializeCache

[java] view plain copy print ?

1. /** 
2.  * 缓存数据初始化接口，如果某个实体的缓存数据需要在服务器启动时初始化请实现此接口 
3.  *  
4.  * @author liuyang 
5.  *  
6.  */  
7. public interface InitializeCache {  
8.   
9.     void init();  
10.   
11. }  

/**
 * 缓存数据初始化接口，如果某个实体的缓存数据需要在服务器启动时初始化请实现此接口
 * 
 * @author liuyang
 * 
 */
public interface InitializeCache {

	void init();

}

[java] view plain copy print ?

1. @Component  
2. public class UserCacheManager implements CacheDeal, InitializeCache {  
3.     //前面的省略   
4.     @Override  
5.     public void init() {  
6.         List<UserInfo> allUserList = getAllUsers();  
7.         for (UserInfo user : allUserList) {  
8.             addUserCache(user);  
9.         }  
10.     }  
11. }  

@Component
public class UserCacheManager implements CacheDeal, InitializeCache {
	//前面的省略
	@Override
	public void init() {
		List<UserInfo> allUserList = getAllUsers();
		for (UserInfo user : allUserList) {
			addUserCache(user);
		}
	}
}

初始化缓存管理类，这类需要在spring中注入

[java] view plain copy print ?

1. public class InitializeCahceManager {  
2.   
3.     private List<String> cachedEntityClazzNameList = new ArrayList<String>();  
4.   
5.     public void setCachedEntityClazzNameList(  
6.             List<String> cachedEntityClazzNameList) {  
7.         this.cachedEntityClazzNameList = cachedEntityClazzNameList;  
8.     }  
9.   
10.     public void init() {  
11.         try {  
12.             for (String clazzName : cachedEntityClazzNameList) {  
13.                 Class<?> clazz = Class.forName(clazzName);  
14.                 boolean hasNeedCacheAnnotation = clazz  
15.                         .isAnnotationPresent(NeedCache.class);  
16.                 if (hasNeedCacheAnnotation) {  
17.                     NeedCache needCache = clazz.getAnnotation(NeedCache.class);  
18.                     InitializeCache initObject = (InitializeCache) SpringContextHolder  
19.                             .getBean(needCache.cacheDealClass());  
20.                     initObject.init();  
21.                 }  
22.             }  
23.         } catch (Exception e) {  
24.             LoggerUtil.error(InitializeCahceManager.class, "初始化缓存失败", e);  
25.         }  
26.     }  
27.   
28. }  

public class InitializeCahceManager {

	private List<String> cachedEntityClazzNameList = new ArrayList<String>();

	public void setCachedEntityClazzNameList(
			List<String> cachedEntityClazzNameList) {
		this.cachedEntityClazzNameList = cachedEntityClazzNameList;
	}

	public void init() {
		try {
			for (String clazzName : cachedEntityClazzNameList) {
				Class<?> clazz = Class.forName(clazzName);
				boolean hasNeedCacheAnnotation = clazz
						.isAnnotationPresent(NeedCache.class);
				if (hasNeedCacheAnnotation) {
					NeedCache needCache = clazz.getAnnotation(NeedCache.class);
					InitializeCache initObject = (InitializeCache) SpringContextHolder
							.getBean(needCache.cacheDealClass());
					initObject.init();
				}
			}
		} catch (Exception e) {
			LoggerUtil.error(InitializeCahceManager.class, "初始化缓存失败", e);
		}
	}

}

[html] view plain copy print ?

1. <!-- 初始化缓存管理类  
2.         如果需要缓存实体，添加实现类，实现cacheDeal、InitializeCache接口，然后在实体上加needclass的注释，  
3.         并把需要缓存的实体加入到下面的集合  
4.      -->  
5.     <bean id="initializeCacheManager" class="com.liuyang.infrastructure.cache.InitializeCahceManager">  
6.         <property name="cachedEntityClazzNameList">  
7.             <list>  
8.                 <value>com.liuyang.security.model.UserInfo</value>  
9.             </list>  
10.         </property>  
11.     </bean>  

<!-- 初始化缓存管理类
    	如果需要缓存实体，添加实现类，实现cacheDeal、InitializeCache接口，然后在实体上加needclass的注释，
    	并把需要缓存的实体加入到下面的集合
     -->
    <bean id="initializeCacheManager" class="com.liuyang.infrastructure.cache.InitializeCahceManager">
		<property name="cachedEntityClazzNameList">
			<list>
				<value>com.liuyang.security.model.UserInfo</value>
			</list>
		</property>
	</bean>

list是需要初始化数据的实体类，下面的serlvet需要加入到web.xml中服务器启动时运行，就大功告成了，启动试试看

[java] view plain copy print ?

1. @SuppressWarnings("serial")  
2. public class InitializeCacheServlet extends HttpServlet {  
3.   
4.     @Override  
5.     public void init() throws ServletException {  
6.         super.init();  
7.         InitializeCahceManager manager = SpringContextHolder  
8.                 .getBean(InitializeCahceManager.class);  
9.         manager.init();  
10.     }  
11.   
12. }