分分钟搞定redis

随着科技不断的发展，使用到的技术也是更新换代，大家都知道当一个程序用户量上来之后，必然是要做数据缓存的，那么如何去实现的呢，在之前我们一直使用memcache去做数据缓存，现在众所周知主流的缓存技术已经换成redis了，说实话，没有对比就没有伤害，用过redis的人肯定不再希望去用memcache了，举个最简单的例子，对hash的存储以及提供的各种函数，真的是让memcache望尘莫及啊，好了，废话不多说，直接上干货。

一、安装redis

windows版安装：

1.下载redis：https://github.com/ServiceStack/redis-windows/raw/master/downloads/redis-latest.zip

2.解压后随便找个盘符放进去，例如：解压到C盘了，C:\redis

3.打开命令行，直接敲命令：

cd c:\redis
redis-server.exe redis.windows.conf

如果你弹出下面的页面，那么恭喜你已经成功了。

注意：如果你只是想本机玩玩 那么现在就可以了，如果想通过外网来去访问，则需要去修改配置文件redis.windows.conf,具体修改什么我会在linux版本配置当中贴出来。

linux版安装：

1.下载redis：https://redis.io/download 找个稳定的版本下载下来

2.直接执行下面的命令

$ wget http://download.redis.io/releases/redis-3.2.8.tar.gz
$ tar xzf redis-3.2.8.tar.gz
$ cd redis-3.2.8
$ make

注意：$不是命令

3.启动服务

进入src的目录下

[root@localhost src]# ./redis-server ../redis.conf 

4.关闭服务

[root@localhost src]# ps -ef|grep redis
root      9492     1  0 09:39 ?        00:00:00 ./redis-server *:6379
root      9605  8310  0 09:48 pts/1    00:00:00 grep --color=auto redis
[root@localhost src]# kill -9 9492

5.设置外网访问

修改redis.conf文件

将bind 127.0.0.1 注释掉  改成# bind 127.0.0.1

将daemonize no  改成daemonize yes    　　　　　　ps:将redis-service设置为后台服务

将protected-mode  yes 改成 protected-mode no     ps:将redis的保护模式去掉，否则在这种模式下连接只接受从环回接口，也就是只能单机玩，windows版安装也一样

6.配置防火墙，开放6379端口

iptables -I IN_public_allow 4 -p tcp -m state --state NEW -m tcp --dport 6379 -j ACCEPT

注意：IN_public_allow为自己服务器的中的组，一般为input。

二、客户端调用代码

package cfs.wsdl.cache;

import java.util.Map;
import java.util.UUID;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisSentinelPool;
import cfs.core.util.Util;

public class RedisCacheUtil {
    private static final String TOKENS="tokens";
    private static String ip=Util.getString("redis", "redis.ip");
    private static String port=Util.getString("redis", "redis.port");
    private static String maxActive=Util.getString("redis", "jedis.pool.maxActive");
    private static String maxIdle=Util.getString("redis", "jedis.pool.maxIdle");
    private static String maxWaitMillis=Util.getString("redis", "jedis.pool.maxWait");
    private static String testOnBorrow=Util.getString("redis", "jedis.pool.testOnBorrow");
    private static String testOnReturn=Util.getString("redis", "jedis.pool.testOnReturn");
    
    //声明连接池对象
    private static JedisPoolConfig config;
    //声明连接管道对象
    private static JedisPool pool;
    //声明主从切换管道对象
    private static JedisSentinelPool sentinelpool;
    //声明redis操作对象
    private static Jedis jedis;
    
    //获取连接池对象
    private static JedisPoolConfig getPoolConfig(){
       if(config == null){
          config = new JedisPoolConfig();
          //最大连接数
          config.setMaxTotal(Integer.valueOf(maxActive));
          //最大空闲连接数
          config.setMaxIdle(Integer.valueOf(maxIdle));
          //获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,  默认-1
          config.setMaxWaitMillis(Long.valueOf(maxWaitMillis));
          //在获取连接的时候检查有效性, 默认false
          config.setTestOnBorrow(Boolean.valueOf(testOnBorrow));
          //在获取返回结果的时候检查有效性, 默认false
          config.setTestOnReturn(Boolean.valueOf(testOnReturn));

       }
       return config;
    }
    
    
    

    /**
     * 得到普通连接池的连接管道.
     *
     * @Title: getPool
     * @author lmoran@163.com
     * @return
     */
    private static synchronized  JedisPool getPool(){
       if(pool == null){
          //初始化连接池
          pool = new JedisPool(getPoolConfig(), ip,Integer.valueOf(port));
       }
       return pool;
    } 
    
    
    /**
     * 获取一个redis操作对象.
     *
     * @Title: getJedis
     * @author lmoran@163.com
     * @return
     */
    private static synchronized Jedis getJedis(){
        if(jedis==null){
            jedis =RedisCacheUtil.getPool().getResource();
        }
        return jedis;
    }
    
    
    /**
     * 获取token.
     *
     * @Title: getToken
     * @author lmoran@163.com
     * @param user_id 用户id
     * @return token
     */
    public static String getToken(String user_id){
        String token="";
        Jedis jedis =getJedis();
        boolean bool=jedis.hexists(TOKENS, user_id);
        if(bool){
            token=jedis.hget(TOKENS, user_id);
        }else{
            token=UUID.randomUUID().toString().replaceAll("-", "");
            jedis.hset(TOKENS, user_id, token);
        }
        return token;
    }
    
    
    
    
    public static void main(String[] args) {
        Jedis jedis =RedisCacheUtil.getPool().getResource();
        jedis.hdel("tokens", "aaa");
        System.out.println(getToken("aaa"));
        
        
        
    }
}

/**
     * 获取指定资源*.properites里的数据..
     *
     * @Title: getString
     * @author lmoran@163.com
     * @param res
     *            资源名称例如 jdbc.properites,传参时就传jdbc
     * @param key
     *            要获取的key
     * @return 返回对应的value
     */
    public static String getString(String res, String key) {
        String propertyFileName = res;
        ResourceBundle resourceBundle = ResourceBundle
                .getBundle(propertyFileName);
        if (key == null || key.equals("") || key.equals("null")) {
            return "";
        }
        String result = "";
        try {
            result = resourceBundle.getString(key);
        } catch (MissingResourceException e) {
            e.printStackTrace();
        }
        return result;
    }

#redis服务器ip #   
redis.ip= 192.168.1.66
#redis服务器端口号# 
redis.port=6379
###jedis##pool##config### 
#jedis的最大分配对象# 
jedis.pool.maxActive=10
#jedis最大保存idel状态对象数 # 
jedis.pool.maxIdle=200
#jedis池没有对象返回时，最大等待时间 # 
jedis.pool.maxWait=1000
#jedis调用borrowObject方法时，是否进行有效检查# 
jedis.pool.testOnBorrow=false
#jedis调用returnObject方法时，是否进行有效检查 # 
jedis.pool.testOnReturn=true