• 今天完成的事情：Memcached完整应用
  明天计划的事情：Redis的运用
  遇到的问题：

• 1.Error:(3,27) java: 程序包com.danga.MemCached不存在。又是找不到。按照以前的方法不行，最后找到如下解决方案。

• 先导入依赖，我这导入了还是报错

  <dependency>
    <groupId>com.danga</groupId>
    <artifactId>java-memcached</artifactId>
    <version>2.6.6</version>
  </dependency>

  然后手动导入jar包到maven的仓库中

• 在maven中执行以下命令，红色是自己jar包的存放地址

• mvn install:install-file -Dfile=E:/download/java_memcached-release_2.6.6.jar -DgroupId=com.danga       -DartifactId=java-memcached             -Dversion=2.6.6 -Dpackaging=jar

• 2. 用了缓存后，自己的项目路径访问不到。还在解决中

• 收获：

• java中使用Memcached（下）完整版

• 1. 导入jar包。

• java_memcached-release_2.6.6.jar
  commons-pool-1.5.6.jar
  slf4j-api-1.6.1.jar
  slf4j-simple-1.6.1.jar

java_memcached-release_2.6.6.jar这个包在maven依赖引入不管用，我是自己想办法解决的。就是上面遇到问题。

2.创建一个MemcachedUtil工具类。

用来获取MemcachedClient以及自定义方法。设置连接池的属性，后面我改了是放在用Spring整合了配置。

public class MemcachedUtil {
    private static MemCachedClient mcc =new MemCachedClient();
    private MemcachedUtil(){

    }

   static{
       String[] servers = {"120.25.222.150:11211"};
       Integer[] weights = {1};

       SockIOPool pool = SockIOPool.getInstance();
       pool.setServers(servers);
       pool.setWeights(weights);
       pool.setInitConn(5);//设置开始时每个cache服务器的可用连接数
       pool.setMinConn(5);//设置每个服务器最少可用连接数
       pool.setMaxConn(250);//设置每个服务器最大可用连接数
       pool.setMaxIdle(1000*60*60*6);//设置可用连接池的最长等待时间
       //设置连接池维护线程的睡眠时间 ,设置为0,维护线程不启动。维护线程主要通过log输出
       pool.setMaintSleep(30);
       //设置是否使用Nagle算法,因为通讯数据量通常都比较大(相对TCP控制数据)而且要求响应及时,
       // 因此该值需要设置为false(默认是true)
       pool.setNagle(false);
       pool.setSocketConnectTO(0);//设置socket的读取等待超时值
       pool.setSocketTO(3000);
       pool.setHashingAlg(3);
       // 设置hash算法
        //  alg=0 使用String.hashCode()获得hash code,该方法依赖JDK,可能和其他客户端不兼容,建议不使用
        //  alg=1 使用original 兼容hash算法,兼容其他客户端
        //  alg=2 使用CRC32兼容hash算法,兼容其他客户端,性能优于original算法
        //  alg=3 使用MD5 hash算法
        //  采用前三种hash算法的时候,查找cache服务器使用余数方法。采用最后一种hash算法查找cache
//       pool.initialize();// 设置完pool参数后最后调用该方法,启动pool。
   }
   public static MemCachedClient getMemCachedClient(){
        return mcc;
   }

    /**
     * set缓存数据
     * @param key 取值的键
     * @param value 缓存的字符串类型
     */
   public static void set(String key,String value){
    mcc.set(key,value);
   }
    /**
     * set缓存数据
     * @param key
     * @param obj  缓存对象类型
     */
   public static void set(String key,Object obj){
       mcc.set(key,obj);
   }

    /**
     * replace替换存在key的值，key不存在则替换失败
     * @param key
     * @param obj
     */
    public static void replace(String key,Object obj){
        mcc.replace(key, obj);
    }

    /**
     * append在已有的key后追加数据
     * @param key
     * @param obj
     */
    public static void append(String key,Object obj){
        mcc.append(key,obj);
    }

    /**
     * get 获取单个数据
     * @param key
     * @return
     */
    public static Object get(String key){
        return mcc.get(key);
    }

    /**
     * get获取多个值
     * @param keys
     * @return 返回map集合
     */
    public static Map<String,Object> get(Collection<String> keys){
        Map<String,Object> map = new HashMap<>();
        for(String s:keys){

            map.put(s,mcc.get(s));
        }
            return map;
    }
}

3.修改自己Service的方法。

从数据库查询的学生数据放入缓存。

public class StudentServiceImpl implements StudentService {
    @Resource
    private StudentMapper studentMapper;
       //定义一个常量key
    private static String STUKEY = "studentList";
       private static Logger logger = LoggerFactory.getLogger(StudentServiceImpl.class);
      @Override
    public List<Student> selectAll() {
         MemCachedClient mcc = MemcachedUtil.getMemCachedClient();
         String key = STUKEY;
         List<Student> stuList = null;
       ObjectMapper mapper = new ObjectMapper();
               //如果缓存没有key，则查询数据库，把值放到缓存中，最后返回数据
    //否则key存在，直接从缓存中取数据
    if(!mcc.keyExists(key)){
              stuList = studentMapper.selectAll();
               MemcachedUtil.set(key,stuList);
        }else{
               stuList = castList(mcc.get(key),Student.class);
        }
        return stuList;
    }

    /**
     * 使用Class.cast做类型转换，将Object转换成List
     * @param obj
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> List<T> castList(Object obj, Class<T> clazz)
    {
        List<T> result = new ArrayList<T>();
        if(obj instanceof List<?>)
        {
            for (Object o : (List<?>) obj)
            {
                result.add(clazz.cast(o));
            }
            return result;
        }
        return null;
    }
}

测试

@Test
public void memcachedTest(){
    List list = studentService.selectAll();
    System.out.println(list);
}

Spring整合Memcached的配置

<!--Spring整合Memcached配置-->
<bean id="propertyConfigurer"
      class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
        <list>
            <value>classpath:memcached.properties</value>
        </list>
    </property>
</bean>
<!--memcached 客户端 SocketPool-->
<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>${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>

<bean id="memcachedClient" class="com.danga.MemCached.MemCachedClient">
    <constructor-arg>
        <value>neeaMemcachedPool</value>
    </constructor-arg>
</bean>