一、今日完成

1.学习在Spring MVC中配置Memcache

(1)在pom文件引入依赖

!-- memcache -->
<dependency>
  <groupId>com.whalin</groupId>
  <artifactId>Memcached-Java-Client</artifactId>
  <version>3.0.0</version>
</dependency>

（2）在src/main/resources目录下新建Memcache相关属性配置文件memcached.properties

#######################设置Memcached服务器参数#######################
#设置服务器地址
memcached.server=目标服务器ip:11211  #该端口号默认为11211
#容错
memcached.failOver=true
#设置初始连接数
memcached.initConn=20
#设置最小连接数
memcached.minConn=10
#设置最大连接数
memcached.maxConn=250
#设置连接池维护线程的睡眠时间
memcached.maintSleep=3000
#设置是否使用Nagle算法（Socket的参数），如果是true在写数据时不缓冲，立即发送出去
memcached.nagle=false
#设置socket的读取等待超时时间
memcached.socketTO=3000
#设置连接心跳监测开关
memcached.aliveCheck=true

（3）加载Memcache属性（applicationContext-memcached.xml）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:cache="http://www.springframework.org/schema/cache"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-3.0.xsd
                        http://www.springframework.org/schema/tx
                        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
                        http://www.springframework.org/schema/aop
                        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
                        http://www.springframework.org/schema/mvc
                        http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
                        http://www.springframework.org/schema/cache
                        http://www.springframework.org/schema/cache/spring-cache-3.2.xsd">

      <!-- 扫描项目包的根路径 -->
    <context:component-scan base-package="com.task06" />

    <!-- ===================================  配置Memcached =============================== -->
     <!-- 开启缓存 -->
   <cache:annotation-driven cache-manager="cacheManager" proxy-target-class="true" />
    <!-- 导入外部properties -->
    <context:property-placeholder location="classpath:memcached.properties"/>

     <bean id="memcachedPool" class="com.task06..utils.SockIOPool"
        factory-method="getInstance" init-method="initialize" destroy-method="shutDown">
       <constructor-arg>
            <value>neeaMemcachedPool</value>
        </constructor-arg>
        <property name="servers">
            <list>
                <value>${memcache.server}</value>
            </list>
        </property>
        <property name="initConn">
            <value>${memcache.initConn}</value>
        </property>
        <property name="minConn">
            <value>${memcache.minConn}</value>
        </property>
        <property name="maxConn">
            <value>${memcache.maxConn}</value>
        </property>
        <property name="maintSleep">
            <value>${memcache.maintSleep}</value>
        </property>
        <property name="nagle">
            <value>${memcache.nagle}</value>
        </property>
        <property name="socketTO">
            <value>${memcache.socketTO}</value>
        </property>
    </bean>

    <!-- 配置MemcachedClient -->
    <bean id="memcachedClient" class="com.com.task06..utils.MemCachedClient">
        <constructor-arg>
            <value>neeaMemcachedPool</value>
        </constructor-arg>
    </bean>

    <!-- 配置缓存管理 -->
    <bean id="cacheManager" class="com.cdsmartlink.framework.cache.memcached.MemcachedCacheManager">
        <property name="memcachedClient" ref="memcachedClient"/>
        <!-- 配置缓存时间 -->
        <property name="configMap">
             <map>
                 <!-- key缓存对象名称   value缓存过期时间 -->
                 <entry key="systemCache" value="3600"/>
             </map>
        </property>
    </bean>

    <!-- 导入调度任务 -->
    <!-- <import resource="spring-quartz.xml" /> -->
</beans>

（4）引入到web.xml中

<!-- 加载配置文件路径 -->
<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath*:applicationContext*.xml</param-value>
</context-param>

(5)创建MemcachedCacheManager、MemcachedCache和MemCache工具类

public class MemcachedCacheManager  extends AbstractTransactionSupportingCacheManager{
    private ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap<String, Cache>();
    private Map<String, Integer> expireMap = new HashMap<String, Integer>();   //缓存的时间  
    private MemCachedClient memcachedClient;   //memcached的客户端  

    public MemcachedCacheManager() {
    }

    @Override
    protected Collection<? extends Cache> loadCaches() {
        Collection<Cache> values = cacheMap.values();
        return values;
    }

    @Override
    public Cache getCache(String name) {
        Cache cache = cacheMap.get(name);
        if (cache == null) {
            Integer expire = expireMap.get(name);
            if (expire == null) {
                expire = 0;
                expireMap.put(name, expire);
            }
            cache = new MemcachedCache(name, expire.intValue(), memcachedClient);
            cacheMap.put(name, cache);
        }
        return cache;
    }

    public void setMemcachedClient(MemCachedClient memcachedClient) {
        this.memcachedClient = memcachedClient;
    }

    public void setConfigMap(Map<String, Integer> configMap) {
        this.expireMap = configMap;
    }

}

public class MemcachedCache  implements Cache {
     private final String name;  
    private final MemCache memCache;  
  
    public MemcachedCache(String name, int expire, MemCachedClient memcachedClient) {  
        this.name = name;  
        this.memCache = new MemCache(name, expire, memcachedClient);  
    }  
  
    @Override  
    public void clear() {  
        memCache.clear();  
    }  
  
    @Override  
    public void evict(Object key) {  
        memCache.delete(key.toString());  
    }  
  
    @Override  
    public ValueWrapper get(Object key) {  
        ValueWrapper wrapper = null;  
        Object value = memCache.get(key.toString());  
        if (value != null) {  
            wrapper = new SimpleValueWrapper(value);  
        }  
        return wrapper;  
    }  
  
    @Override  
    public String getName() {  
        return this.name;  
    }  
  
    @Override  
    public MemCache getNativeCache() {  
        return this.memCache;  
    }  
  
    @Override  
    public void put(Object key, Object value) {  
        memCache.put(key.toString(), value);  
    }  
  
    @Override  
    @SuppressWarnings("unchecked")  
    public <T> T get(Object key, Class<T> type) {  
        Object cacheValue = this.memCache.get(key.toString());  
        Object value = (cacheValue != null ? cacheValue : null);  
        if (type != null && !type.isInstance(value)) {  
            throw new IllegalStateException("Cached value is not of required type [" + type.getName() + "]: " + value);  
        }  
        return (T) value;  
    }  
  

}

public class MemCache {
    private static Logger log = LoggerFactory.getLogger(MemCache.class);

    private Set<String> keySet = new HashSet<String>();
    private final String name;
    private final int expire;
    private final MemCachedClient memcachedClient;

    public MemCache(String name, int expire, MemCachedClient memcachedClient) {
        this.name = name;
        this.expire = expire;
        this.memcachedClient = memcachedClient;
    }

    public Object get(String key) {
        Object value = null;
        try {
            key = this.getKey(key);
            value = memcachedClient.get(key);
        } catch (Exception e) {
            log.warn("获取 Memcached 缓存超时", e);
        }
        return value;
    }

    public void put(String key, Object value) {
        if (value == null)
            return;
        try {
            key = this.getKey(key);
            memcachedClient.set(key, value, expire);
            keySet.add(key);
        }catch (Exception e) {
            log.warn("更新 Memcached 缓存错误", e);
        }
    }

    public void clear() {
        for (String key : keySet) {
            try {
                memcachedClient.delete(this.getKey(key));
            }catch (Exception e) {
                log.warn("删除 Memcached 缓存错误", e);
            }
        }
    }

    public void delete(String key) {
        try {
            key = this.getKey(key);
            memcachedClient.delete(key);
        } catch (Exception e) {
            log.warn("删除 Memcached 缓存被中断", e);
        }
    }

    private String getKey(String key) {
        return name + "_" + key;
    }
}

（6）对工具类的调用还在整理中。

二、明日计划

1.整理Memcache的原理和客户端应用相关知识点；

2.使用nginx做负载均衡

三、遇到问题

暂无。

四、收获

以上。