jedis连接redis

1 pom引用

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-aop</artifactId>
   <version>4.3.7.RELEASE</version>
</dependency>
<dependency>
   <groupId>redis.clients</groupId>
   <artifactId>jedis</artifactId>
   <version>2.9.0</version>
</dependency>
<dependency>
   <groupId>cglib</groupId>
   <artifactId>cglib</artifactId>
   <version>3.2.5</version>
</dependency>

<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjrt</artifactId>
   <version>1.8.10</version>
</dependency>
<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
   <version>1.8.10</version>
</dependency>

2 配置文件

#--------------------------------------------------------#
# 缓存配置
#--------------------------------------------------------#

#redis.address = 111.111.111.111
#redis.password = redis

#哨兵配置
redis.sentinel.address = 111.111.111.111:26379,111.111.111.112:26379,111.111.111.113:26378
redis.sentinel.password = redis
redis.master.name = master8025

3 jedis配置

这里用了很多spring的注解，jar的引入缺少不了spring。

这里配置的是哨兵机制的，如果只有一个节点的服务器的话，这里面的配置也有，但在init 、destroy等地方需要调整一下，setJedisSentinelPool改为setJedisPool

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisSentinelPool;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.util.HashSet;
import java.util.Set;

@Component
public class JedisUtil{
    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Value("${redis.master.name:}")
    private String masterName;

    @Value("${redis.sentinel.address:}")
    private String sentinelAddress;

    @Value("${redis.sentinel.password:}")
    private String sentinelPassword;

    //Redis服务器IP
    @Value("${redis.address:}")
    private String address;

    //Redis的端口号
    @Value("${redis.port:6379}")
    private int port;

    //访问密码
    @Value("${redis.password:}")
    private String password;

    //可用连接实例的最大数目，默认值为8；
    //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
    @Value("${redis.maxTotal:60}")
    private int maxTotal;

    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
    @Value("${redis.maxIdle:20}")
    private int maxIdle;

    //控制一个pool最少有多少个状态为idle(空闲的)的jedis实例，默认值也是0。
    @Value("${redis.minIdle:10}")
    private int minIdle;

    //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
    @Value("${redis.maxWaitMillis:3000}")
    private int maxWaitMillis;

    @Value("${redis.timeout:3000}")
    private int timeout;

    //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
    @Value("${redis.testOnBorrow:true}")
    private boolean testOnBorrow;

    private JedisPool jedisPool;
    private JedisSentinelPool jedisSentinelPool;

    private JedisPoolConfig config;

    public void initJedisPoolConfig(){
        config = new JedisPoolConfig();
        config.setMaxTotal(maxTotal);
        config.setMaxIdle(maxIdle);
        config.setMinIdle(minIdle);
        config.setMaxWaitMillis(maxWaitMillis);
        config.setTestOnBorrow(testOnBorrow);
    }

    public void setJedisPool(JedisPool jedisPool){
        this.jedisPool = jedisPool;
    }

    public void setJedisSentinelPool(JedisSentinelPool jedisSentinelPool){
        this.jedisSentinelPool = jedisSentinelPool;
    }

    public JedisPool getJedisPool(){
        try {
            initJedisPoolConfig();
            return new JedisPool(config, address, port, timeout, password);
        } catch (Exception e) {
            logger.error("redis未连接成功",e);
            return null;
        }
    }

    public JedisSentinelPool getJedisSentinelPool(){
        try {
            initJedisPoolConfig();
            Set<String> sentinelSet = new HashSet<String>();
            String[] sentinelString = sentinelAddress.split(",");
            for (String sentinelAddr : sentinelString){
                sentinelSet.add(sentinelAddr);
                System.out.println(sentinelAddr);
            }
            return new JedisSentinelPool(masterName,sentinelSet,config,timeout,sentinelPassword);
        } catch (Exception e) {
            logger.error("redis未连接成功",e);
            return null;
        }
    }

    public void reloadJedisPool(){
        this.setJedisPool(this.getJedisPool());
    }

    public void reloadJedisSentinelPool(){
        this.setJedisSentinelPool(this.getJedisSentinelPool());
    }

    /**
     * 初始化Redis连接池
     */
    @PostConstruct
    public void init(){
        if (StringUtils.isNotBlank(sentinelAddress)){
            jedisSentinelPool = this.getJedisSentinelPool();
        }else {
            logger.info("redis连接池未初始化：sentinelAddress = [{}]",sentinelAddress);
        }
    }

    /**
     * 销毁Redis连接池
     */
    @PreDestroy
    public void destroy(){
        if (jedisSentinelPool != null){
            jedisSentinelPool.close();
        }
    }

    /**
     * 获取Jedis实例
     * @return
     */
    public synchronized Jedis getJedis() {
        try {
            if (jedisSentinelPool != null) {
                Jedis resource = jedisSentinelPool.getResource();
                return resource;
            } else {
                logger.info("jedisPool为null");
                return null;
            }
        } catch (Exception e) {
            logger.error("redis服务器没有连接上,获取redis资源出现异常",e);
            return null;
        }
    }

    /**
     * 释放jedis资源
     * @param jedis
     */
    public void closeJedis(Jedis jedis) {
        if (jedis != null) {
            jedis.close();
        }
    }
    
    public static void main(String[] args) {
        Logger logger = LoggerFactory.getLogger(JedisUtil.class);
        Set<String> sentinelSet = new HashSet<String>();
        sentinelSet.add("111.111.80.26:26379");
        sentinelSet.add("111.111.80.25:26379");
        sentinelSet.add("111.111.80.26:26378");
        sentinelSet.add("111.111.80.25:26378");
        JedisSentinelPool pool =  new JedisSentinelPool("master8025",sentinelSet,"redis");
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            jedis.set("5","5");
            jedis.expire("5",300);

        }catch (Exception e){
            logger.error(e.getMessage(),e);
        }finally {
            System.out.println("finally");
            if (jedis != null){
                jedis.close();
            }
            pool.close();
        }
    }
}

4 提供对redis调用的接口

这里是一些对redis调用封装的接口，其中lifespan设置的是在redis中生命周期

import com.cache.service.IJedisService;
import com.cache.util.JedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import redis.clients.jedis.Jedis;

import java.io.*;
import java.util.List;
import java.util.Map;
import java.util.Set;

@Service
public class JedisServiceImpl implements IJedisService{

    @Autowired
    private JedisUtil jedisUtil;

    @Override
    public void add(String key, String value) {
        Jedis jedis = jedisUtil.getJedis();
        if (jedis != null) {
            jedis.set(key, value);
            jedisUtil.closeJedis(jedis);
        }
    }

    @Override
    public void add(String key, String value,int lifespan) {
        Jedis jedis = jedisUtil.getJedis();
        if (jedis != null) {
            jedis.setex(key, lifespan, value);
            jedisUtil.closeJedis(jedis);
        }
    }

    @Override
    public String get(String key) {
        Jedis jedis = jedisUtil.getJedis();
        if (jedis == null){
            return null;
        }
        String value = jedis.get(key);
        jedisUtil.closeJedis(jedis);
        return value;
    }

    @Override
    public void addList(String key, List<String> value) {
        if (!CollectionUtils.isEmpty(value)){
            Jedis jedis = jedisUtil.getJedis();
            if (jedis != null) {
                for (String s : value) {
                    jedis.lpush(key, s);
                }
                jedisUtil.closeJedis(jedis);
            }
        }

    }

    @Override
    public List<String> getList(String key) {
        Jedis jedis = jedisUtil.getJedis();
        if (jedis == null){
            return null;
        }
        List<String> value = jedis.lrange(key,0,-1);
        jedisUtil.closeJedis(jedis);
        return value;
    }

    @Override
    public List<String> getList(String key,long start, long end) {
        Jedis jedis = jedisUtil.getJedis();
        if (jedis == null){
            return null;
        }
        List<String> value = jedis.lrange(key,start,end);
        jedisUtil.closeJedis(jedis);
        return value;
    }

    @Override
    public void addMap(String key, Map<String, String> value) {
        if (!CollectionUtils.isEmpty(value)){
            Jedis jedis = jedisUtil.getJedis();
            if (jedis != null) {
                jedis.hmset(key, value);
                jedisUtil.closeJedis(jedis);
            }
        }
    }

    @Override
    public Map<String,String> getMap(String key) {
        Jedis jedis = jedisUtil.getJedis();
        if (jedis == null){
            return null;
        }
        Map<String,String> value = jedis.hgetAll(key);
        jedisUtil.closeJedis(jedis);
        return value;
    }

    @Override
    public void addSet(String key, Set<String> value) {
        if (!CollectionUtils.isEmpty(value)){
            Jedis jedis = jedisUtil.getJedis();
            if (jedis != null) {
                for (String s : value) {
                    jedis.sadd(key, s);
                }
                jedisUtil.closeJedis(jedis);
            }
        }
    }

    @Override
    public Set<String> getSet(String key) {
        Jedis jedis = jedisUtil.getJedis();
        if (jedis == null){
            return null;
        }
        Set<String> value = jedis.smembers(key);
        jedisUtil.closeJedis(jedis);
        return value;
    }

    @Override
    public void addObject(String key, Object value) throws IOException {
        Jedis jedis = jedisUtil.getJedis();
        if (jedis != null) {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(value);
            byte[] byteArray = bos.toByteArray();
            oos.close();
            bos.close();
            jedis.set(key.getBytes(), byteArray);
            jedisUtil.closeJedis(jedis);
        }
    }

    @Override
    public Object getObject(String key) throws IOException, ClassNotFoundException {
        Jedis jedis = jedisUtil.getJedis();
        if (jedis == null){
            return null;
        }
        byte [] bs = jedis.get( key.getBytes());
        if (bs == null){
            jedisUtil.closeJedis(jedis);
            return null;
        }
        ByteArrayInputStream bis =  new ByteArrayInputStream(bs);
        ObjectInputStream inputStream =  new ObjectInputStream(bis);
        Object value = inputStream.readObject();
        inputStream.close();
        bis.close();
        jedisUtil.closeJedis(jedis);
        return value;
    }

    @Override
    public void setLifespan(String key, int lifespan) {
        Jedis jedis = jedisUtil.getJedis();
        if (jedis != null) {
            jedis.expire(key, lifespan);
            jedisUtil.closeJedis(jedis);
        }
    }

    @Override
    public void setObjectLifespan(String key, int lifespan) {
        Jedis jedis = jedisUtil.getJedis();
        if (jedis != null) {
            jedis.expire(key.getBytes(), lifespan);
            jedisUtil.closeJedis(jedis);
        }
    }
}

最后总结一下，整合redis的方式有很多，这里采用的是jedis直接连接，看懂并修改代码，实践出结果。