Redis缓存数据库搭建与使用（window64安装版下载安装配置）

App接口校验需要验证token，为了减轻数据库压力，将（userid，token）保存在缓存里，方便读取。

1. 下载安装

下面是下载链接，包含Redis window64位安装版以及相关jar包
Redis下载链接

解压后双击 Redis-x64-3.2.100.msi 进入安装面板
可自行修改安装目录，所有勾选的地方都打上对号。

端口号默认 6379

如果安装后出现如下问题，说明.NET Framework 版本太低

打开命令窗口 输入dir %WINDIR%\Microsoft.NET\Framework\v* /O:-N /B
查看.NET Framework版本信息

解决方法，安装高版本的.NET Framework，安装程序在下载的压缩包里
NDP46-KB3045557-x86-x64-AllOS-ENU.exe

安装完成后重新安装Redis即可安装完成。

2. 运行Redis

Redis安装目录D:\Redis\redisbin64

打开cmd进入redis的目录下

D:
cd Redis/redisbin64
redis-server.exe redis.windows.conf（开启redis的命令）

若出现（连接错误） 如上图
creating server tcp listening socket 127.0.0.1:6379: bind No error
解决方案如下按顺序输入如下命令就可以连接成功

1. Redis-cli.exe
2. shutdown
3. exit
4. redis-server.exe redis.windows.conf

Redis开启成功的界面

3. 测试Redis

不要关闭当前命令窗口
重新打开个命令窗口 进入到redis下

D:
cd Redis/redisbin64
redis-server.exe redis.windows.conf
redis-cli.exe -h 127.0.0.1 -p 6379

测试
set name songhui
get name
del name

---

到此Redis已经可以使用了

下面是java代码redis工具类，需要的jar都在下载的压缩包里面。

package com.sh.tools;

import net.sf.json.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * Redis存储工具
 * ClassName: RedisTool 
 * @Description: TODO
 * @author micoMo
 * @date 2017-4-28
 */
public class RedisTool {

    private static int maxActive = 100;
    private static int maxIdle = 20;
    private static int maxWait = 3000;
    private static String ip = "127.0.0.1";
    private static int port = 6379;
    private static JedisPool jedisPool;
    private static Jedis jedis;

    static {
        JedisPoolConfig config = new JedisPoolConfig();  
        //设置最大连接数
        config.setMaxActive(maxActive);
        //设置最大空闲数
        config.setMaxIdle(maxIdle);
        //设置超时时间
        config.setMaxWait(maxWait);

        //初始化连接池
        jedisPool = new JedisPool(config, ip, port);
        jedis = jedisPool.getResource();
//      jedis.auth("password");
    }

    /**
     * 向缓存中设置字符串内容
     * @param key key
     * @param value value
     * @return
     * @throws Exception
     */
    public static boolean  set(String key,String value) throws Exception{
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }finally{
            jedisPool.returnResource(jedis);
        }
    }

    /**
     * 向缓存中设置字符串内容
     * @param key key
     * @param value value
     * @return
     * @throws Exception
     */
    public static String get(String key){
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            String value = jedis.get(key);
            return value;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }finally{
            jedisPool.returnResource(jedis);
        }
    }

    /**
     * 向缓存中设置对象
     * @param key 
     * @param value
     * @return
     */
    public static boolean setObject(String key,Object value){
        Jedis jedis = null;
        try {
            JSONObject objectJson = JSONObject.fromObject(value);
            jedis = jedisPool.getResource();
            jedis.set(key, objectJson.toString());
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }finally{
            jedisPool.returnResource(jedis);
        }
    }

    /**
     * 删除缓存中得对象，根据key
     * @param key
     * @return
     */
    public static boolean del(String key){
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.del(key);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }finally{
            jedisPool.returnResource(jedis);
        }
    }

    /**
     * 根据key 获取内容
     * @param key
     * @return
     */
    public static Object getObject(String key){
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            Object value = jedis.get(key);
            return value;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }finally{
            jedisPool.returnResource(jedis);
        }
    }


    /**
     * 根据key 获取对象
     * @param key
     * @return
     */
    public static <T> T get(String key,Class<T> clazz){
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            String value = jedis.get(key);
            JSONObject jsonobject = JSONObject.fromObject(value);
            return (T) JSONObject.toBean(jsonobject, clazz);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }finally{
            jedisPool.returnResource(jedis);
        }
    }


    public static void saveToken(String account,String token) {
        jedis.set(account, token);
        System.out.println(jedis.get(account));

    }

}

在用户登录时，初始化token，并保存到Redis。

    public String login() throws Exception{


        String account = request.getParameter("account");
        String password = request.getParameter("password");
        String deviceid = request.getParameter("deviceid");
        String channelId = request.getParameter("channelId");
        String os = request.getParameter("os");

        String[] param = {account,password,deviceid,channelId,os};
        String[] name = {"account","password","deviceid","channelId","os"};
        if(!"".equals(StringTool.isEmpty(param, name))){
            errorMessage += StringTool.isEmpty(param, name);
            resultCode = "0";
        }

        if ("" == errorMessage) {
            User u = userService.login(account, password);
            if(u == null){
                errorMessage += "账号未生效或用户名密码错误！";
                resultCode = "0";
            } else {
                u.setDeviceid(deviceid);
                u.setChannelId(channelId);
                u.setOs(os);
                userService.updateUser(u);
                //生成token
                String token = NumberTool.getRandomString(16);
                //保存token到Redis
                RedisTool.set(String.valueOf(u.getId()), token);
                System.out.println(RedisTool.get(String.valueOf(u.getId())));
                json.put("user", JSONObject.fromObject(u)); 
                json.put("token", token);
            }
        }

        json.put("errorMessage", errorMessage);
        json.put("resultCode", resultCode);
        ResponseTool.write(ServletActionContext.getResponse(), json);
        return null;
    }

验证token的过滤器

package com.sh.tools;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.List;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import net.sf.json.JSONObject;

/**
 * 接口token验证过滤器
 * ClassName: SecurityFilter 
 * @Description: TODO
 * @author micoMo
 * @date 2017-5-3
 */
public class SecurityFilter implements Filter {

    public void destroy() {
        // TODO Auto-generated method stub
    }

    public void doFilter(ServletRequest servletrequest,
            ServletResponse servletresponse, FilterChain filterchain)
            throws IOException, ServletException {

        HttpServletRequest httpRequest = (HttpServletRequest) servletrequest;
        JSONObject json = new JSONObject();
        String myuserid = servletrequest.getParameter("myuserid");
        String sign = servletrequest.getParameter("sign");

        // 数组转换成list
        List<String> list = Arrays.asList(Constants.FILTERKEY);
        String path = httpRequest.getServletPath();

            if (list.contains(path)) {

                if(StringTool.isEmpty(myuserid)||StringTool.isEmpty(sign)){
                    json.put("errorMessage", "sign或myuserid为空");
                    json.put("resultCode", "0");
                } else {
                    //从Redis获取token
                    String token = RedisTool.get(myuserid);
                    sign = MD5Util.MD5Encode(sign, "UTF-8");
                    System.out.println("加密后的token："+sign);
                    if(!sign.equals(MD5Util.MD5Encode(token, "UTF-8"))){    
                        json.put("errorMessage", "token验证失败");
                        json.put("resultCode", "0");
                    } else {
                        filterchain.doFilter(servletrequest, servletresponse);
                    }
                }
                servletresponse.setCharacterEncoding("GBK");
                PrintWriter out = servletresponse.getWriter();
                out.append(json.toString());
                out.close();

            } else {

                filterchain.doFilter(servletrequest, servletresponse);
            }
    }

    public void init(FilterConfig filterConfig) throws ServletException {
        // TODO Auto-generated method stub
    }

}

以上只是实现简单的存储数据。