接口
package com.enation.framework.cache; /** * 缓存接口 * */ public interface ICache<T> { /** * 初始化缓存对象 * @param cacheName 缓存对象名称 */ public void initCache(String cacheName); /** * Get an item from the cache, nontransactionally * @param key * @return the cached object or <tt>null</tt> * @throws CacheException */ public T get(Object key); /** * Add an item to the cache, nontransactionally, with * failfast semantics * @param key * @param value * @throws CacheException */ public void put(Object key, T value); /** * 往缓存中写入内容 * @param key * @param value * @param exp 超时时间，单位为秒 */ public void put(Object key, T value, int exp); /** * Remove an item from the cache */ public void remove(Object key); /** * Clear the cache */ public void clear(); }1、Ehcache的实现
package com.enation.framework.cache; import java.io.Serializable; import org.springframework.stereotype.Component; import org.springframework.stereotype.Service; import net.sf.ehcache.CacheException; import net.sf.ehcache.CacheManager; import net.sf.ehcache.Element; /** * Ehcache缓存实现 */ @Component public class EhCacheImpl implements ICache { private net.sf.ehcache.Cache cache; /** * */ public EhCacheImpl() { } /** * 初始化缓存对象 * * @param name */ @Override public void initCache(String name) { try { CacheManager manager = CacheManager.getInstance(); cache = manager.getCache(name); if (cache == null) { manager.addCache(name); cache = manager.getCache(name); } } catch (net.sf.ehcache.CacheException e) { e.printStackTrace(); } } /** * Gets a value of an element which matches the given key. * * @param key * the key of the element to return. * @return The value placed into the cache with an earlier put, or null if * not found or expired * @throws CacheException */ public Object get(Object key) { Object obj = null; try { if (key != null) { Element element = cache.get((Serializable) key); if (element != null) { obj = element.getValue(); } } } catch (net.sf.ehcache.CacheException e) { e.printStackTrace(); } return obj; } /** * Puts an object into the cache. * * @param key * a {@link Serializable} key * @param value * a {@link Serializable} value * @throws CacheException * if the parameters are not {@link Serializable}, the * {@link CacheManager} is shutdown or another {@link Exception} * occurs. */ public void put(Object key, Object value) { try { Element element = new Element((Serializable) key, (Serializable) value); cache.put(element); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (IllegalStateException e) { e.printStackTrace(); } } /** * Puts an object into the cache. * @param key * @param value * @param exp */ public void put(Object key, Object value, int exp) { try { Element element = new Element((Serializable) key, (Serializable) value); element.setTimeToLive(exp); cache.put(element); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (IllegalStateException e) { e.printStackTrace(); } } /** * Removes the element which matches the key. * <p> * If no element matches, nothing is removed and no Exception is thrown. * * @param key * the key of the element to remove * @throws CacheException */ public void remove(Object key) { try { cache.remove((Serializable) key); } catch (ClassCastException e) { e.printStackTrace(); } catch (IllegalStateException e) { e.printStackTrace(); } } public static void main(String[] args) { EhCacheImpl cache = new EhCacheImpl(); cache.initCache("queryCache"); cache.put("test","fjdkafjsdkajd"); } @Override public void clear() { try { //cache.remove(arg0) cache.removeAll(); } catch (IllegalStateException e) { e.printStackTrace(); } } } 2、Memcached的实现 package com.enation.app.shop.cluster.cache.memcached; import java.io.IOException; import java.util.concurrent.TimeoutException; import org.apache.commons.lang3.StringUtils; import org.apache.log4j.Logger; import org.springframework.stereotype.Component; import com.enation.framework.cache.ICache; import com.enation.framework.util.PropertiesUtil; import net.rubyeye.xmemcached.XMemcachedClient; import net.rubyeye.xmemcached.XMemcachedClientBuilder; import net.rubyeye.xmemcached.exception.MemcachedException; import net.rubyeye.xmemcached.utils.AddrUtil; /** * Memcached的缓存实现 */ @Component public class MemcachedImpl implements ICache { protected final Logger logger = Logger.getLogger(getClass()); private static XMemcachedClient memcachedClient; @Override public void initCache(String cacheName) { if (memcachedClient != null) return; try { PropertiesUtil properties = new PropertiesUtil("cluster.properties"); String memcachedServer = properties.getProperties("memcached_server"); if(StringUtils.isEmpty(memcachedServer)){ logger.error("can't get memcached server address"); return; } String[] memcachedServers = StringUtils.split(memcachedServer, ","); XMemcachedClientBuilder builder = new XMemcachedClientBuilder( AddrUtil.getAddresses(memcachedServers[0])); memcachedClient = (XMemcachedClient) builder.build(); if(memcachedServers.length > 1){ for(int i = 1; i < memcachedServers.length; i++){ try{ memcachedClient.addServer(memcachedServers[i].trim()); }catch(Exception ex){ logger.error("can't connect " + memcachedServers[i].trim(), ex); } } } } catch (IOException ex) { logger.error("can't conect memcached server", ex); } } @Override public Object get(Object key) { try { return memcachedClient.get(key.toString()); } catch (TimeoutException | InterruptedException | MemcachedException e) { logger.error("get cache from memcached error", e); } return null; } @Override public void put(Object key, Object value) { try { memcachedClient.set(key.toString(), 0, value); } catch (TimeoutException | InterruptedException | MemcachedException e) { logger.error("put value to memcached error", e); } } @Override public void put(Object key, Object value, int exp) { try { memcachedClient.set(key.toString(), exp, value); } catch (TimeoutException | InterruptedException | MemcachedException e) { logger.error("put value to memcached error", e); } } @Override public void remove(Object key) { try { memcachedClient.delete(key.toString()); } catch (TimeoutException | InterruptedException | MemcachedException e) { logger.error("remove cache from memcached error", e); } } @Override public void clear() { // TODO Auto-generated method stub } } 3、Redis的实现 package com.enation.app.shop.cluster.cache.redis; import java.util.ArrayList; import java.util.List; import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.math.NumberUtils; import org.apache.log4j.Logger; import org.springframework.stereotype.Component; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoolConfig; import redis.clients.jedis.JedisShardInfo; import redis.clients.jedis.ShardedJedis; import redis.clients.jedis.ShardedJedisPool; import com.enation.app.base.core.model.Member; import com.enation.framework.cache.ICache; import com.enation.framework.util.PropertiesUtil; import com.enation.framework.util.SerializeUtil; /** * Redis的缓存实现类 * */ @Component public class RedisImpl implements ICache { protected final Logger logger = Logger.getLogger(getClass()); private static ShardedJedisPool pool; @Override public void initCache(String cacheName) { if (pool != null) return; PropertiesUtil properties = new PropertiesUtil("cluster.properties"); String redisServer = properties.getProperties("redis_server"); if(StringUtils.isEmpty(redisServer)){ logger.error("can't get redis server address"); return; } String[] redisServers = StringUtils.split(redisServer, ","); List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(); for(int i = 0; i < redisServers.length; i++){ String[] hostPort = StringUtils.split(redisServers[i].trim(), ":"); String host = hostPort[0]; int port = 6379; if(hostPort.length == 2){ port = NumberUtils.toInt(hostPort[1], 6379); } try{ shards.add(new JedisShardInfo(host, port, "redis_" + i)); }catch(Exception ex){ logger.error("can't connect " + redisServers[i].trim(), ex); } } // 构造池 pool = new ShardedJedisPool(new JedisPoolConfig(), shards); } @Override public Object get(Object key) { ShardedJedis shardedJedis = null; try { shardedJedis = pool.getResource(); byte[] bytes = shardedJedis.get(key.toString().getBytes()); if (bytes == null || bytes.length == 0) return null; return SerializeUtil.unserialize(bytes); } catch (Exception ex) { logger.error("get cache from redis error", ex); } finally { if (shardedJedis != null) { pool.returnResource(shardedJedis); } } return null; } @Override public void put(Object key, Object value) { ShardedJedis shardedJedis = null; try { shardedJedis = pool.getResource(); shardedJedis.set(key.toString().getBytes(), SerializeUtil.serialize(value)); } catch (Exception ex) { logger.error("put cache to redis error", ex); } finally { if (shardedJedis != null) { pool.returnResource(shardedJedis); } } } @Override public void put(Object key, Object value, int exp) { ShardedJedis shardedJedis = null; try { shardedJedis = pool.getResource(); shardedJedis.setex(key.toString().getBytes(), exp, SerializeUtil.serialize(value)); } catch (Exception ex) { logger.error("put cache to redis error", ex); } finally { if (shardedJedis != null) { pool.returnResource(shardedJedis); } } } @Override public void remove(Object key) { ShardedJedis shardedJedis = null; try { shardedJedis = pool.getResource(); shardedJedis.del(key.toString().getBytes()); } catch (Exception ex) { logger.error("remove cache from redis error", ex); } finally { if (shardedJedis != null) { pool.returnResource(shardedJedis); } } } public static void main(String[] args) { JedisPool pool2 = new JedisPool(new JedisPoolConfig(), "localhost"); Jedis jedis = null; try { jedis = pool2.getResource(); Member m = new Member(); m.setUname("dawei"); jedis.set("user".getBytes(), SerializeUtil.serialize(m)); // String name = jedis.get("user"); // System.out.println(name); Member m1 = (Member) SerializeUtil.unserialize(jedis.get("user".getBytes())); System.out.println(m1.getUname()); } catch (Exception ex) { ex.printStackTrace(); } finally { if (jedis != null) { jedis.close(); } } } @Override public void clear() { // TODO Auto-generated method stub } }