Spring boot中Redis的使用

散列表（是说散列表里面存储的数少）使用的内存非常小，所以你应该尽可能的将你的数据模型抽象到一个散列表里面。

POM.XML依赖：

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>最新版本号</version>
</dependency>

散列表代码实现：

import redis.clients.jedis.Jedis;
 
public class RedisHashExample {
    public static void main(String[] args) {
        // 连接到Redis服务器
        Jedis jedis = new Jedis("localhost", 6379);
 
        // 使用散列结构的名称 "hashExample"
        String hashName = "hashExample";
 
        // 添加键值对
        jedis.hset(hashName, "key1", "value1");
        jedis.hset(hashName, "key2", "value2");
 
        // 获取键的值
        String value1 = jedis.hget(hashName, "key1");
        System.out.println("key1: " + value1);
 
        // 获取散列中所有的键值对
        java.util.Map<String, String> allEntries = jedis.hgetAll(hashName);
        for (String key : allEntries.keySet()) {
            System.out.println(key + ": " + allEntries.get(key));
        }
 
        // 删除键
        jedis.hdel(hashName, "key1");
 
        // 检查键是否存在
        if (jedis.hexists(hashName, "key1")) {
            System.out.println("key1 exists");
        } else {
            System.out.println("key1 does not exist");
        }
 
        // 关闭连接
        jedis.close();
    }
}

 

 

普通插入和获取：

public String getRedisInfos(String dataParame) throws Exception {
        try {
            Jedis jedis = new Jedis(redisIP, redisPort);
            if (!StringUtils.isBlank(redisPwd)) {
                jedis.auth(redisPwd);
            }
            jedis.select(redisIndex);
            String reData = jedis.get(dataParame);
            jedis.close();
            return reData;
        } catch (Exception err) {
            throw err;
        }
    }

    public Boolean setRedisInfos(String dataKey, String dataVal,int timeOut) throws Exception {
        Jedis jedis = new Jedis(redisIP, redisPort);
        if (!StringUtils.isBlank(redisPwd)) {
            jedis.auth(redisPwd);
        }
        jedis.select(redisIndex);
        jedis.set(dataKey, dataVal);
        if(timeOut>=0){
            jedis.expire(dataKey,timeOut);
        }
        jedis.close();
        return true;
    }

 

redis队列

            RedisHelper tempRedisHelper = new RedisHelper("127.0.0.1", 6379, "123456", 0);
            for(int i=0;i<100;i++){
                tempRedisHelper.setRedisQueue("myQueue","测试队列内容"+i);
            }
            String tempMyQueue="";
            do{
                tempMyQueue=tempRedisHelper.getRedisQueue("myQueue");
                if(StringUtils.isNotBlank(tempMyQueue)){
                    System.out.println(tempMyQueue);
                }
            }while (StringUtils.isNotBlank(tempMyQueue));

 

 

redis线程池

// redis线程池
    public JedisPool jpHandel;
    public JedisPool getjpHandel(){
        if(jpHandel!=null){
            return jpHandel;
        }
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        /**
         * 核心类：
         * maxTotal：最大连接数；
         * maxIdle：最大空闲连接数；
         * minIdle：最小空闲连接数；
         * blockWhenExhausted：表示当pool中的jedis实例都被分配完时，是否要进行阻塞；
         * maxWaitMillis：当blockWhenExhausted为true时，最大的阻塞时长。
         * 空闲连接资源检测相关：
         * testOnCreate：在创建Jedis实例时，测试连接可用性，默认关闭，如果打开，则保证创建的都是连接可用的Jedis实例；
         * testOnBorrow：在资源池借出Jedis实例时，测试连接可用性，默认关闭，如果打开，则保证借出的都是可用的；
         * testOnReturn：在Jedis归还Jedis资源池时，测试连接可用性，默认关闭；
         * testWhileIdle：表示有一个idle object evitor线程对空闲的Jedis实例进行扫描，如果验证失败，此Jedis实例会被从资源池中删除掉；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义。
         * 空闲连接资源驱逐相关：
         * timeBetweenEvictionRunsMillis：清理线程运行的时间间隔（毫秒），用于逐出空闲连接。
         * numTestsPerEvictionRun：表示idle object evitor每次扫描的最多的对象数；
         * minEvictableIdleTimeMillis：连接在池中最小空闲时间（毫秒），达到此时间后连接将被逐出；
         * softMinEvictableIdleTimeMillis：软空闲驱逐时间，在minEvictableIdleTimeMillis基础上，还需要检测至少minIdle个对象已经在资源池里，才会进行驱逐；
         * lifo：当借出的资源时，是使用LIFO（last in first out）策略，借出最新使用的资源；还是使用FIFO策略，借出最久没有使用的资源。默认为true，即LIFO；
         * evictionPolicy：驱逐策略，接口，默认实现逻辑：资源的空闲毫秒数，如果大于空闲驱逐时间minEvictableIdleTimeMillis，或大于softMinEvictableIdleTimeMillis且当前的空闲资源数量大于配置的最小空闲资源数量，则进行驱逐
         * */
        poolConfig.setMaxTotal(100); // 最大连接数
        poolConfig.setMaxIdle(20); // 最大空闲连接数
        poolConfig.setMinIdle(10); // 最小空闲连接数
        poolConfig.setMaxWaitMillis(5000); // 获取连接时的最大等待毫秒数
        poolConfig.setTestOnBorrow(true); // 在获取连接时是否进行验证
        poolConfig.setTestOnReturn(true); // 在返回连接时是否进行验证
        /**
         * poolConfig:线程池配置。
         * host:Redis服务器的主机名或IP地址。
         * port:Redis服务器的端口号。
         * timeout:连接超时时间（毫秒），即在等待从池中获取连接时最大的等待时间。
         * password:Redis服务器的密码（如果有进行了密码认证）。
         * database:Redis服务器的数据库索引（默认为0）。
         * **/
        jpHandel=new JedisPool(poolConfig,redisIP, redisPort,2000,redisPwd,redisIndex);
        return jpHandel;
    }

    public String getRedisPoolInfos(String dataParame) throws Exception {
        try(Jedis tempJedis=getjpHandel().getResource()){
            String backInfo=tempJedis.get(dataParame);
            tempJedis.close();
            return backInfo;
        }
    }

    public void setRedisPoolInfos(String dataKey, String dataVal,int timeOut) throws Exception {
        try(Jedis tempJedis=getjpHandel().getResource()){
            tempJedis.set(dataKey,dataVal);
            if(timeOut>=0){
                tempJedis.expire(dataKey,timeOut);
            }
            tempJedis.close();
        }
    }

    public String hGetRedisPoolInfos(String hName,String dataParame) throws Exception {
        try(Jedis tempJedis=getjpHandel().getResource()){
            String backInfo=tempJedis.hget(hName,dataParame);
            tempJedis.close();
            return backInfo;
        }
    }

    public void hSetRedisPoolInfos(String hName,String dataKey, String dataVal,int timeOut) throws Exception {
        try(Jedis tempJedis=getjpHandel().getResource()){
            tempJedis.hset(hName,dataKey,dataVal);
            if(timeOut>=0){
                // 设置散列表过期时间无效
                tempJedis.expire(dataKey,timeOut);
            }
            tempJedis.close();
        }
    }

    public void closeJedisPool(){
        if(jpHandel!=null){
            // 这一步，内部其实调用的是同一个类的destroy，不过是遍历调取destroy
            jpHandel.clear();
        }
        if(jpHandel!=null){
            // 这一步，内部调用的是父级的close
            jpHandel.destroy();
        }
        if(jpHandel!=null){
            // 这一步，内部其实调用的是同一个类的destroy
            jpHandel.close();
        }
    }