非spring项目整合redis

最近由于接触到非spring的java项目需要用到redis缓存中间件，所以专门整理了一下分享给大家！我想到的方式是使用jedis的方式操作redis，jedis是通过redis.clients.jedis.JedisPool来管理，即通过池来管理，通过池对象获取jedis实例，然后通过jedis实例直接操作redis服务的
方法如下：

1、添加maven依赖

    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>2.9.0</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>

2、添加redis.properties配置文件

#最大活动对象数
redis.pool.maxTotal=1000
#最大能够保持idel状态的对象数
redis.pool.maxIdle=50
#资源池确保最少空闲的连接数；默认值：0
redis.pool.minIdle=5
#当资源池连接用尽后，调用者的最大等待时间(单位为毫秒) -1：表示永不超时；使用建议：不建议使用默认值
redis.pool.maxWaitMillis=20000
#当池内没有返回对象时，最大等待时间
redis.pool.maxWait=300
#当调用borrow Object方法时，是否进行有效性检查
redis.pool.testOnBorrow=false
redis.host = 127.0.0.1
redis.port = 6379
redis.timeout=30000
redis.password =123456
redis.database = 0

3、添加工具类JedisUtil

这里的工具类只是实现了基本的方法，具体方法大家可以自行拓展

package com.redic.sale.config;
 
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
 
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
 
/**
 * redis工具类
 * @author xdy
 */
public class JedisUtil {
    private static JedisPool jedisPool = null;
 
    private JedisUtil() {
 
    }
    
    //写成静态代码块形式，只加载一次，节省资源
    static {
        Properties properties = PropertyUtil.loadProperties("properties/redis.properties");
        String host = properties.getProperty("redis.host");
        String port = properties.getProperty("redis.port");
        String password = properties.getProperty("redis.password");
        String timeout = properties.getProperty("redis.timeout");
        String maxIdle = properties.getProperty("redis.pool.maxIdle");
        String maxTotal = properties.getProperty("redis.pool.maxTotal");
        String maxWaitMillis = properties.getProperty("redis.pool.maxWaitMillis");
        String testOnBorrow = properties.getProperty("redis.pool.testOnBorrow");
 
        JedisPoolConfig config = new JedisPoolConfig();
        //控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；
        //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
        config.setMaxTotal(Integer.parseInt(maxTotal));
        //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。
        config.setMaxIdle(Integer.parseInt(maxIdle));
        //表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；
        config.setMaxWaitMillis(Long.parseLong(maxWaitMillis));
        //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
        config.setTestOnBorrow(Boolean.valueOf(testOnBorrow));
 
        jedisPool = new JedisPool(config, host, Integer.parseInt(port), Integer.parseInt(timeout), null);
    }
 
    /**
     * 从jedis连接池中获取获取jedis对象
     *
     * @return
     */
    private Jedis getJedis() {
        return jedisPool.getResource();
    }
 
    private static final JedisUtil jedisUtil = new JedisUtil();
 
    /**
     * 获取JedisUtil实例
     *
     * @return
     */
    public static JedisUtil getInstance() {
        return jedisUtil;
    }
 
    /**
     * 回收jedis(放到finally中)
     *
     * @param jedis
     */
    private void returnJedis(Jedis jedis) {
        if (null != jedis && null != jedisPool) {
            jedisPool.returnResource(jedis);
        }
    }
 
    /**
     * 销毁连接(放到catch中)
     *
     * @param jedis
     */
    private static void returnBrokenResource(Jedis jedis) {
        if (null != jedis && null != jedisPool) {
            jedisPool.returnResource(jedis);
        }
    }

    /**
     * 添加一个键值对，如果键存在不在添加，如果不存在，添加完成以后设置键的有效期
     * @param key
     * @param value
     * @param timeOut 秒
     */
    public void set(String key,String value,int timeOut){
        Jedis jedis = getJedis();
        if(0!=jedis.setnx(key, value)){
            jedis.expire(key, timeOut);
        }
        returnJedis(jedis);
    }

    /**
     * 设置永不过期的键值对
     * @param key
     * @param value
     */
    public void set(String key,String value){
        Jedis jedis = getJedis();
        jedis.set(key,value);
        returnJedis(jedis);
    }


    /**
     * 获取一个键值对
     * @param key
     * @return
     */
    public String get(String key){
        Jedis jedis = getJedis();
        returnJedis(jedis);
        return jedis.get(key);
    }
 
    /**
     * 添加sorted set
     *
     * @param key
     * @param value
     * @param score
     */
    public void zadd(String key, String value, double score) {
        Jedis jedis = getJedis();
        jedis.zadd(key, score, value);
        returnJedis(jedis);
    }
 
    /**
     * 返回指定位置的集合元素,0为第一个元素，-1为最后一个元素
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<String> zrange(String key, int start, int end) {
        Jedis jedis = getJedis();
        Set<String> set = jedis.zrange(key, start, end);
        returnJedis(jedis);
        return set;
    }
 
    /**
     * 获取给定区间的元素，原始按照权重由高到低排序
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<String> zrevrange(String key, int start, int end) {
        Jedis jedis = getJedis();
        Set<String> set = jedis.zrevrange(key, start, end);
        returnJedis(jedis);
        return set;
    }
 
    /**
     * 添加对应关系，如果对应关系已存在，则覆盖
     *
     * @param key
     * @param map 对应关系
     * @return 状态，成功返回OK
     */
    public String hmset(String key, Map<String, String> map) {
        Jedis jedis = getJedis();
        String s = jedis.hmset(key, map);
        returnJedis(jedis);
        return s;
    }
 
    /**
     * 向List头部追加记录
     *
     * @param key
     * @param value
     * @return 记录总数
     */
    public long rpush(String key, String value) {
        Jedis jedis = getJedis();
        long count = jedis.rpush(key, value);
        returnJedis(jedis);
        return count;
    }
 
    /**
     * 向List头部追加记录
     *
     * @param key
     * @param value
     * @return 记录总数
     */
    private long rpush(byte[] key, byte[] value) {
        Jedis jedis = getJedis();
        long count = jedis.rpush(key, value);
        returnJedis(jedis);
        return count;
    }
 
    /**
     * 删除
     *
     * @param key
     * @return
     */
    public long del(String key) {
        Jedis jedis = getJedis();
        long s = jedis.del(key);
        returnJedis(jedis);
        return s;
    }
 
    /**
     * 从集合中删除成员
     * @param key
     * @param value
     * @return 返回1成功
     * */
    public long zrem(String key, String... value) {
        Jedis jedis = getJedis();
        long s = jedis.zrem(key, value);
        returnJedis(jedis);
        return s;
    }
    
    public void saveValueByKey(int dbIndex, byte[] key, byte[] value, int expireTime)
            throws Exception {
        Jedis jedis = null;
        boolean isBroken = false;
        try {
            jedis = getJedis();
            jedis.select(dbIndex);
            jedis.set(key, value);
            if (expireTime > 0) {
                jedis.expire(key, expireTime);
            }
        } catch (Exception e) {
            isBroken = true;
            throw e;
        } finally {
            returnResource(jedis, isBroken);
        }
    }
    
    public byte[] getValueByKey(int dbIndex, byte[] key) throws Exception {
        Jedis jedis = null;
        byte[] result = null;
        boolean isBroken = false;
        try {
            jedis = getJedis();
            jedis.select(dbIndex);
            result = jedis.get(key);
        } catch (Exception e) {
            isBroken = true;
            throw e;
        } finally {
            returnResource(jedis, isBroken);
        }
        return result;
    }
    
    public void deleteByKey(int dbIndex, byte[] key) throws Exception {
        Jedis jedis = null;
        boolean isBroken = false;
        try {
            jedis = getJedis();
            jedis.select(dbIndex);
            jedis.del(key);
        } catch (Exception e) {
            isBroken = true;
            throw e;
        } finally {
            returnResource(jedis, isBroken);
        }
    }
    
    public void returnResource(Jedis jedis, boolean isBroken) {
        if (jedis == null) {
            return;
        }
        if (isBroken) {
            jedisPool.returnBrokenResource(jedis);
        } else {
            jedisPool.returnResource(jedis);
        }
    }
    
    /**
     * 获取总数量
     * @param key
     * @return
     */
    public long zcard(String key) {
        Jedis jedis = getJedis();
        long count = jedis.zcard(key);
        returnJedis(jedis);
        return count;
    }
 
    /**
     * 是否存在KEY
     * @param key
     * @return
     */
    public boolean exists(String key) {
        Jedis jedis = getJedis();
        boolean exists = jedis.exists(key);
        returnJedis(jedis);
        return exists;
    }
 
    /**
     * 重命名KEY
     * @param oldKey
     * @param newKey
     * @return
     */
    public String rename(String oldKey, String newKey) {
        Jedis jedis = getJedis();
        String result = jedis.rename(oldKey, newKey);
        returnJedis(jedis);
        return result;
    }
 
    /**
     * 设置失效时间
     * @param key
     * @param seconds
     */
    public void expire(String key, int seconds) {
        Jedis jedis = getJedis();
        jedis.expire(key, seconds);
        returnJedis(jedis);
    }
 
    /**
     * 删除失效时间
     * @param key
     */
    public void persist(String key) {
        Jedis jedis = getJedis();
        jedis.persist(key);
        returnJedis(jedis);
    }
    
    /**
     * 返回指定key序列值 
     * @param key
     * @return
     */
    public long incr(String key){
    	Jedis jedis = getJedis();
    	long l = jedis.incr(key);
        returnJedis(jedis);
        return l;
    }

    public static void main(String[] args) {
        System.out.println(JedisUtil.getInstance().currentTimeSecond());
    }
    
    /**
     * 获取当前时间 
     * @return 秒
     */
    public long currentTimeSecond(){
    	Long l = 0L;
    	Jedis jedis = getJedis();
    	Object obj = jedis.eval("return redis.call('TIME')",0);
    	if(obj != null){
    		List<String> list = (List)obj;
    		l = Long.valueOf(list.get(0));
    	}
        returnJedis(jedis);
        return l;
    }
}

这里是加在配置文件的工具类：

package com.redic.sale.config;
 
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
 
/**
 * 属性文件加载工具类
 * @author xdy
 */
public class PropertyUtil {
   
    //加载property文件到io流里面
    public static Properties loadProperties(String propertyFile) {
    	Properties properties = new Properties();
        try {
            InputStream is = PropertyUtil.class.getClassLoader().getResourceAsStream(propertyFile);
            if(is == null){
            	is = PropertyUtil.class.getClassLoader().getResourceAsStream("properties/" + propertyFile);
            }
            properties.load(is);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return properties;
    }
}

4、牛刀小试

    public static void main(String[] args) {
        JedisUtil instance = JedisUtil.getInstance();
        instance.set("key","测试一下",30);
        System.out.println(instance.get("key"));
    }

5、配置参数相关介绍

maxTotal：资源池中最大连接数；默认值：8
maxIdle：资源池允许最大空闲的连接数；默认值：8
minIdle：资源池确保最少空闲的连接数；默认值：0
blockWhenExhausted：当资源池用尽后，调用者是否要等待。只有当为true时，下面的maxWaitMillis才会生效；默认值：true；使用建议：建议使用默认值
maxWaitMillis：当资源池连接用尽后，调用者的最大等待时间(单位为毫秒) -1：表示永不超时；使用建议：不建议使用默认值
testOnBorrow：向资源池借用连接时是否做连接有效性检测(ping)，无效连接会被移除；默认值：false；使用建议：业务量很大时候建议设置为false(多一次ping的开销)。
testOnReturn：向资源池归还连接时是否做连接有效性检测(ping)，无效连接会被移除；默认值：false；使用建议：业务量很大时候建议设置为false(多一次ping的开销)。
jmxEnabled：是否开启jmx监控，可用于监控；默认值：true；使用建议：建议开启，但应用本身也要开启