今天完成的事情：

--

Redis的String字符串命令；

--

Redis的List列表命令；

--Redis的hashMap命令；

--set集合

--Sorted Set 有序集合

--

1.2、Redis优点：

（1）异常快速：Redis的速度非常快，每秒能执行约11万集合，每秒约81000+条记录。

（2）支持丰富的数据类型：Redis支持最大多数开发人员已经知道像列表，集合，有序集合，散列数据类型。这使得它非常容易解决各种各样的问题，因为我们知道哪些问题是可以处理通过它的数据类型更好。

（3）操作都是原子性：所有Redis操作是原子的，这保证了如果两个客户端同时访问的Redis服务器将获得更新后的值。

（4）多功能实用工具：Redis是一个多实用的工具，可以在多个用例如缓存，消息，队列使用(Redis原生支持发布/订阅)，任何短暂的数据，应用程序，如Web应用程序会话，网页命中计数等。

1.3、Redis缺点：

（1）单线程

（2）耗内存

--然后找到一篇非常不错的文章；

https://blog.csdn.net/Evankaka/article/details/50396325

--com/lihoo/ssm/util/interceptor/MethodCacheInterceptor.java

--主要是这个拦截器写的好；

package com.lihoo.ssm.util.interceptor;


import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import com.lihoo.ssm.util.cache.RedisUtil;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

/**
 * #Title: MethodCacheInterceptor
 * #ProjectName task6_index4
 * #Description: 切面MethodCacheInterceptor，.
 * 这是用来给不同的方法来加入判断如果缓存存在数据，从缓存取数据。
 * 否则第一次从数据库取，并将结果保存到缓存 中去。
 * #author lihoo
 * #date 2018/9/17-16:44
 */


public class MethodCacheInterceptor implements MethodInterceptor {
    private RedisUtil redisUtil;
    private List<String> targetNamesList; // 不加入缓存的service名称
    private List<String> methodNamesList; // 不加入缓存的方法名称
    private Long defaultCacheExpireTime; // 缓存默认的过期时间
    private Long xxxRecordManagerTime; //
    private Long xxxSetRecordManagerTime; //

    /**
     * 初始化读取不需要加入缓存的类名和方法名称
     */
    public MethodCacheInterceptor() {
        try {
            File f = new File("D:\\00_TASK\\task6\\task6_index4\\src\\main\\resources\\redis.properties");
            //配置文件位置直接被写死，有需要自己修改下
            InputStream in = new FileInputStream(f);
//       InputStream in = getClass().getClassLoader().getResourceAsStream(
//             "D:\\lunaJee-workspace\\msm\\msm_core\\src\\main\\java\\com\\mucfc\\msm\\common\\cacheConf.properties");
            Properties p = new Properties();
            p.load(in);
            // 分割字符串
            String[] targetNames = p.getProperty("targetNames").split(",");
            String[] methodNames = p.getProperty("methodNames").split(",");

            // 加载过期时间设置
            defaultCacheExpireTime = Long.valueOf(p.getProperty("defaultCacheExpireTime"));
            xxxRecordManagerTime = Long.valueOf(p.getProperty("com.service.impl.xxxRecordManager"));
            xxxSetRecordManagerTime = Long.valueOf(p.getProperty("com.service.impl.xxxSetRecordManager"));
            // 创建list
            targetNamesList = new ArrayList<String>(targetNames.length);
            methodNamesList = new ArrayList<String>(methodNames.length);
            Integer maxLen = targetNames.length > methodNames.length ? targetNames.length
                    : methodNames.length;
            // 将不需要缓存的类名和方法名添加到list中
            for (int i = 0; i < maxLen; i++) {
                if (i < targetNames.length) {
                    targetNamesList.add(targetNames[i]);
                }
                if (i < methodNames.length) {
                    methodNamesList.add(methodNames[i]);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Object value = null;

        String targetName = invocation.getThis().getClass().getName();
        String methodName = invocation.getMethod().getName();
        // 不需要缓存的内容
        //if (!isAddCache(StringUtil.subStrForLastDot(targetName), methodName)) {
        if (!isAddCache(targetName, methodName)) {
            // 执行方法返回结果
            return invocation.proceed();
        }
        Object[] arguments = invocation.getArguments();
        String key = getCacheKey(targetName, methodName, arguments);
        System.out.println(key);

        try {
            // 判断是否有缓存
            if (redisUtil.exists(key)) {
                return redisUtil.get(key);
            }
            // 写入缓存
            value = invocation.proceed();
            if (value != null) {
                final String tkey = key;
                final Object tvalue = value;
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        if (tkey.startsWith("com.service.impl.xxxRecordManager")) {
                            redisUtil.set(tkey, tvalue, xxxRecordManagerTime);
                        } else if (tkey.startsWith("com.service.impl.xxxSetRecordManager")) {
                            redisUtil.set(tkey, tvalue, xxxSetRecordManagerTime);
                        } else {
                            redisUtil.set(tkey, tvalue, defaultCacheExpireTime);
                        }
                    }
                }).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
            if (value == null) {
                return invocation.proceed();
            }
        }
        return value;
    }

    /**
     * 是否加入缓存
     *
     * @return
     */
    private boolean isAddCache(String targetName, String methodName) {
        boolean flag = true;
        if (targetNamesList.contains(targetName)
                || methodNamesList.contains(methodName)) {
            flag = false;
        }
        return flag;
    }

    /**
     * 创建缓存key
     *
     * @param targetName
     * @param methodName
     * @param arguments
     */
    private String getCacheKey(String targetName, String methodName,
                               Object[] arguments) {
        StringBuffer sbu = new StringBuffer();
        sbu.append(targetName).append("_").append(methodName);
        if ((arguments != null) && (arguments.length != 0)) {
            for (int i = 0; i < arguments.length; i++) {
                sbu.append("_").append(arguments[i]);
            }
        }
        return sbu.toString();
    }

    public void setRedisUtil(RedisUtil redisUtil) {
        this.redisUtil = redisUtil;
    }

}

--

    @Test
    public void getSettUnitBySettUnitIdTest() {
        Long systemId = 22L;
//        Long merchantId = 133L;

        StudentList studentList = studentListService.selectByPrimaryKey(systemId);
        StudentList studentList1 = studentListService.selectByPrimaryKey(systemId);
        boolean flag = (studentList == studentList1);
        System.out.println(studentList);
        System.out.println("相等吗：" + flag);
        Log2Util.logger.info("查找结果：" + studentList.getStudyType());
    }

--

打断点，看一下是否存入缓存；

--看看

--初始

--判断

--为null；

--数据库拿缓存，并写入缓存；

--判断

--有缓存，直接跳转缓存，不用去数据库拿数据了；

--存进去了；

--

--有意思；感觉比memcache友善多了；

--虽然最后还是没有用注解方式来写；

--但还是更深入的理解了Redis的一些原理和应用；

--明天继续学习Redis吧；

--

明天计划的事情：

--明天实现测试Redis，并实现负载均衡；

--

遇到的问题：

--害得我啊

--到这行去找；

--

--精辟

--

--坑王驾到；；

--加载不了properties；

--

--

--bingo

收获：

--

有意思--

--

--进度：任务六

--任务开始时间：2018.09.11

--预计demo时间：2018.09.19

--禅道地址：http://taskNaNteng.com/zentao/project-task-844.html

--demo延期两天