spring+memcache实践实例

配置文件：

<bean id="memcachedPool" class="com.danga.MemCached.SockIOPool"
		factory-method="getInstance" init-method="initialize" destroy-method="shutDown">
		<constructor-arg>
			<value>neeaMemcachedPool</value>
		</constructor-arg>
		<property name="servers">
			<list>
				<value>127.0.0.1:11211</value>
			</list>
		</property>
		<property name="initConn">
			<value>20</value>
		</property>
		<property name="minConn">
			<value>10</value>
		</property>
		<property name="maxConn">
			<value>50</value>
		</property>
		<property name="maintSleep">
			<value>30</value>
		</property>
		<property name="nagle">
			<value>false</value>
		</property>
		<property name="socketTO">
			<value>3000</value>
		</property>
	</bean>

	<bean id="memcachedClient" class="com.danga.MemCached.MemCachedClient">
		<constructor-arg>
			<value>neeaMemcachedPool</value>
		</constructor-arg>
		<property name="primitiveAsString">
			<value>true</value>
		</property>
		<property name="defaultEncoding">
			<value>utf-8</value>
		</property>
		<property name="compressEnable">
			<value>true</value>
		</property>
		<property name="compressThreshold">
			<value>4096</value>
		</property>
	</bean>

服务接口：

public interface MemcachedService {
    
    public MemCachedClient getMemCachedClient();
    
    public void setMemCachedClient(MemCachedClient memCachedClient);
    
    public boolean removeCached(String key);
    
    public void addCached(String key, Object value);
    
    public void addCached(String key, Object value, Date exTime);
    
    /**
     * 放入缓存
     * 
     * @param key
     * @param value
     */
    public void setCached(String key, Object value);
    
    /**
     * 放入缓存并且指定缓存时间
     * 
     * @param key
     * @param value
     * @param time
     */
    // public void setCached(String key, Object value, int time) {
    // memCachedClient.set(key, value, time);
    // }
    
    public void setCached(String key, Object value, Date time);
    
    /**
     * 取缓存
     * 
     * @param key
     * @return
     */
    public Object getCached(String key);
    
    /**
     * 清空缓存 慎用
     */
    public void clearCached();
    
    @SuppressWarnings("rawtypes")
    public Set filterCachedKey(String keyStart);
}

接口实现：

@Service("memcachedService")
public class MemcachedServiceImpl implements MemcachedService, Serializable {
    
    private static final long serialVersionUID = 3637897902641513553L;
    
    @Resource
    MemCachedClient memCachedClient;
    
    private static final Log log = LogFactory.getLog(MemcachedServiceImpl.class);
    
    @Override
    public MemCachedClient getMemCachedClient() {
        return memCachedClient;
    }
    
    public void setMemCachedClient(MemCachedClient memCachedClient) {
        
        this.memCachedClient = memCachedClient;
        
        // 序列化
        if (this.memCachedClient != null) {
            this.memCachedClient.setPrimitiveAsString(true);
        }
        
        log.debug(memCachedClient);
    }
    
    public boolean removeCached(String key) {
        log.debug("移出 key:" + key + " 的缓存");
        return memCachedClient.delete(key);
    }
    
    public void addCached(String key, Object value) {
        log.debug("存入key:" + key + "的缓存 ");
        memCachedClient.add(key, value, Integer.MAX_VALUE);
    }
    
    public void addCached(String key, Object value, Date exTime) {
        try {
            log.debug("存入key:" + key + "的缓存，过期时间为" + DateUtil.getFormatDate(exTime, "yyyy-MM-dd HH:mm:ss"));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        memCachedClient.add(key, value, exTime);
    }
    
    /**
     * 放入缓存
     * 
     * @param key
     * @param value
     */
    public void setCached(String key, Object value) {
        log.debug("存入key:" + key + "的缓存 ");
        memCachedClient.set(key, value, Integer.MAX_VALUE);
    }
    
    /**
     * 放入缓存并且指定缓存时间
     * 
     * @param key
     * @param value
     * @param time
     */
    public void setCached(String key, Object value, int time) {
        memCachedClient.set(key, value, time);
    }
    
    // /**
    // * 放入缓存并且指定缓存时间
    // *
    // * @param key
    // * @param value
    // * @param time 有效期，单位为 毫秒
    // */
    // public void setCached(String key, Object value, int time) {
    // memCachedClient.set(key, value, new Date(time));
    // }
    
    public void setCached(String key, Object value, Date time) {
        try {
            log.debug("存入key:" + key + "的缓存，过期时间为" + DateUtil.getFormatDate(time, "yyyy-MM-dd HH:mm:ss"));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        memCachedClient.set(key, value, time);
    }
    
    /**
     * 取缓存
     * 
     * @param key
     * @return
     */
    public Object getCached(String key) {
        log.debug(">>>>>>>>>>> [ from cached ]  取出key:" + key + "的缓存 ");
        return memCachedClient.get(key);
    }
    
    /**
     * 清空缓存 慎用
     */
    public void clearCached() {
        memCachedClient.flushAll();
    }
    
    /**
     * 
     * 从memcached 中检索以指定key为开头的一组key值
     */
    @SuppressWarnings("rawtypes")
    public Set filterCachedKey(String keyStart) {
        Set<String> keys = new HashSet<String>();
        try {
            int limit = 0;
            
            Map<String, Integer> dumps = new HashMap<String, Integer>();
            
            Map slabs = memCachedClient.statsItems();
            if (slabs != null && slabs.keySet() != null) {
                Iterator itemsItr = slabs.keySet().iterator();
                while (itemsItr.hasNext()) {
                    String server = itemsItr.next().toString();
                    Map itemNames = (Map)slabs.get(server);
                    Iterator itemNameItr = itemNames.keySet().iterator();
                    while (itemNameItr.hasNext()) {
                        String itemName = itemNameItr.next().toString();
                        // itemAtt[0]=itemname
                        // itemAtt[1]=number
                        // itemAtt[2]=field
                        String[] itemAtt = itemName.split(":");
                        
                        if (itemAtt[2].startsWith("number"))
                            dumps.put(itemAtt[1], Integer.parseInt(itemAtt[1]));
                        
                    }
                }
                if (!dumps.values().isEmpty()) {
                    Iterator<Integer> dumpIter = dumps.values().iterator();
                    while (dumpIter.hasNext()) {
                        int dump = dumpIter.next();
                        
                        Map cacheDump = memCachedClient.statsCacheDump(dump, limit);
                        Iterator entryIter = cacheDump.values().iterator();
                        while (entryIter.hasNext()) {
                            Map items = (Map)entryIter.next();
                            Iterator ks = items.keySet().iterator();
                            while (ks.hasNext()) {
                                String k = (String)ks.next();
                                if (k.startsWith(keyStart) && this.memCachedClient.keyExists(k)) {
                                    keys.add(k);
                                }
                            }
                        }
                    }
                }
                
            }
        } catch (Exception ex) {
            log.debug(ex.toString());
        }
        return keys;
        
    }
}