SpringBoot集成redis【Jedis】

布满荆棘的人生 2023-05-30 06:09 55阅读 0赞

1、pom.xml的引用

  1. <dependency>
  2.    <groupId>org.projectlombok</groupId>
  3.    <artifactId>lombok</artifactId>
  4.    <version>1.18.10</version>
  5.     <scope>provided</scope>
  6. </dependency>
  7. <dependency>
  8.     <groupId>redis.clients</groupId>
  9.     <artifactId>jedis</artifactId>
  10.     <version>2.9.0</version>
  11.  </dependency>
  12.  <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
  13. <dependenc>
  14.     <groupId>com.fasterxml.jackson.core</groupId>
  15.     <artifactId>jackson-databind</artifactId>
  16.     <version>2.10.0</version>
  17. </dependency>

这里的lombok是为了简化实体类的get/set

2、application.properties

  1. spring.redis.host=127.0.0.0
  2. spring.redis.port=6379
  3. spring.redis.password=
  4. #连接超时时间
  5. spring.redis.timeout=0
  6. #连接的库
  7. spring.redis.database=15
  8. #连接池配置
  9. spring.redis.pool.max-total=100
  10. spring.redis.pool.max-wait=-1
  11. spring.redis.pool.max-idle=8
  12. spring.redis.pool.min-idle=0

3、redis自动注入配置相关的信息

  1. package com.cat.code.config;
  3. import org.springframework.beans.factory.annotation.Value;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import redis.clients.jedis.JedisPool;
  7. import redis.clients.jedis.JedisPoolConfig;
  9. @Configuration
  10. public class JedisConf {
  11.     @Value("${spring.redis.host}")
  12.     private String redisHost;
  13.     @Value("${spring.redis.port}")
  14.     private int redisPort;    
  15.     @Value("${spring.redis.password}")
  16.     private String redisPasswd;
  17.     @Value("${spring.redis.database}")
  18.     private int redisDb;
  19.     @Value("${spring.redis.timeout}")
  20.     private int redisTimeout;    
  21.     @Value("${spring.redis.pool.max-total}")
  22.     private int redisMaxTotal; 
  23.     @Value("${spring.redis.pool.max-wait}")
  24.     private int redisMaxWait;    
  25.     @Value("${spring.redis.pool.max-idle}")
  26.     private int redisMaxIdle;
  27.     @Value("${spring.redis.pool.min-idle}")
  28.     private int redisMinIdle;
  30.     @Bean
  31.     public JedisPool redisPoolFactory()  throws Exception{
  32.         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
  33.         jedisPoolConfig.setMaxTotal(redisMaxTotal);
  34.         jedisPoolConfig.setMaxIdle(redisMaxIdle);
  35.         jedisPoolConfig.setMinIdle(redisMinIdle);
  36.         jedisPoolConfig.setMaxWaitMillis(redisMaxWait);
  37.         jedisPoolConfig.setTestOnBorrow(true);
  38.         jedisPoolConfig.setTestOnReturn(true);
  39.         // 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true
  40. //        jedisPoolConfig.setBlockWhenExhausted(blockWhenExhausted);
  41.         // 是否启用pool的jmx管理功能, 默认true
  42.         jedisPoolConfig.setJmxEnabled(true);
  43.         if (redisPasswd != null && redisPasswd.trim().length() == 0) {
  44.             redisPasswd = null;
  45.         }
  46.         JedisPool jedisPool = new JedisPool(jedisPoolConfig, redisHost, redisPort, redisTimeout, redisPasswd, redisDb);
  47.         return jedisPool;
  48.     }
  50. }

4、对jedis调用进行简单封装，每次重新获取连接池资源和归还连接池资源

  1. package com.cat.code.config;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.stereotype.Component;
  5. import redis.clients.jedis.Jedis;
  6. import redis.clients.jedis.JedisPool;
  8. import java.io.Serializable;
  9. import java.util.Set;
  11. /**
  12.  * @Description: 配置redis连接池
  13.  */
  14. @Component
  15. public class RedisTemplate {
  17.     @Autowired
  18.     private JedisPool jedisPool;
  20.     /**
  21.      * key-value存储
  22.      * @param key
  23.      * @param value
  24.      * @return
  25.      */
  26.     public boolean set(String key, String value) {
  27.         Jedis jedis = null;
  28.         try {
  29.             jedis = jedisPool.getResource();
  30.             String res = jedis.set(key, value);
  31.             return (res == null || !res.equalsIgnoreCase("OK") ? false : true);
  32.         } catch (Exception e) {
  33.             e.printStackTrace();
  34.         } finally {
  35.             if (jedis != null) {
  36.                 jedis.close();
  37.             }
  38.         }
  39.         return false;
  40.     }
  42.     /**
  43.      * key-value存储设置过期时间
  44.      * @param key
  45.      * @param value
  46.      * @param expire_time
  47.      * @return
  48.      */
  49.     public boolean set(String key, String value, int expire_time) {
  50.         Jedis jedis = null;
  51.         try {
  52.             jedis = jedisPool.getResource();
  53.             String res = jedis.set(key, value, "NX", "EX", expire_time);
  54.             return (res == null || !res.equalsIgnoreCase("OK") ? false : true);
  55.         } catch (Exception e) {
  56.             e.printStackTrace();
  57.         } finally {
  58.             if (jedis != null) {
  59.                 jedis.close();
  60.             }
  61.         }
  62.         return false;
  63.     }
  65.     /**
  66.      * key-value存储设置过期时间，当存在替换为新的值
  67.      * @param key
  68.      * @param value
  69.      * @param expire_time
  70.      * @return
  71.      */
  72.     public boolean setex(String key, String value, int expire_time) {
  73.         Jedis jedis = null;
  74.         try {
  75.             jedis = jedisPool.getResource();
  76.             String res = jedis.setex(key, expire_time, value);
  77.             return (res == null || !res.equalsIgnoreCase("OK") ? false : true);
  78.         } catch (Exception e) {
  79.             e.printStackTrace();
  80.         } finally {
  81.             if (jedis != null) {
  82.                 jedis.close();
  83.             }
  84.         }
  85.         return false;
  86.     }
  88.     /**
  89.      * 获取key-value 值
  90.      * @param key
  91.      * @return
  92.      */
  93.     public String get(String key) {
  94.         Jedis jedis = null;
  95.         try {
  96.             jedis = jedisPool.getResource();
  97.             String res = jedis.get(key);
  98.             return res;
  99.         } catch (Exception e) {
  100.             e.printStackTrace();
  101.         } finally {
  102.             if (jedis != null) {
  103.                 jedis.close();
  104.             }
  105.         }
  106.         return null;
  107.     }
  109.     /**
  110.      * key是否存在
  111.      * @param key
  112.      * @return
  113.      */
  114.     public boolean exist(String key) {
  115.         Jedis jedis = null;
  116.         try {
  117.             jedis = jedisPool.getResource();
  118.             Boolean res = jedis.exists(key);
  119.             return res;
  120.         } catch (Exception e) {
  121.             e.printStackTrace();
  122.         } finally {
  123.             if (jedis != null) {
  124.                 jedis.close();
  125.             }
  126.         }
  127.         return false;
  128.     }
  130.     /**
  131.      * list左进队列
  132.      * @param key
  133.      * @param values
  134.      * @return
  135.      */
  136.     public Long lpush(String key, String... values) {
  137.         Jedis jedis = null;
  138.         try {
  139.             jedis = jedisPool.getResource();
  140.             Long ret = jedis.lpush(key, values);
  141.             return ret;
  142.         } catch (Exception e) {
  143.             e.printStackTrace();
  144.         } finally {
  145.             if (jedis != null) {
  146.                 jedis.close();
  147.             }
  148.         }
  149.         return null;
  150.     }
  152.     /**
  153.      * list 右进队列
  154.      * @param key
  155.      * @return
  156.      */
  157.     public String rpop(String key) {
  158.         Jedis jedis = null;
  159.         try {
  160.             jedis = jedisPool.getResource();
  161.             String value = jedis.rpop(key);
  162.             return value;
  163.         } catch (Exception e) {
  164.             e.printStackTrace();
  165.         } finally {
  166.             if (jedis != null) {
  167.                 jedis.close();
  168.             }
  169.         }
  170.         return null;
  171.     }
  173.     /**
  174.      * set key-values存储
  175.      * @param key
  176.      * @param values
  177.      * @return
  178.      */
  179.     public Long sadd(String key,String... values){
  180.         Jedis jedis = null;
  181.         try {
  182.             jedis = jedisPool.getResource();
  183.             return jedis.sadd(key,values);
  184.         } catch (Exception e) {
  185.             System.err.println(e.getMessage());
  186.             return null;
  187.         } finally {
  188.             if (jedis != null) {
  189.                 jedis.close();
  190.             }
  191.         }
  192.     }
  194.     /**
  195.      * set key-value获取
  196.      * @param key
  197.      * @return
  198.      */
  199.     public String spop(String key){
  200.         Jedis jedis = null;
  201.         try {
  202.             jedis = jedisPool.getResource();
  203.             return jedis.spop(key);
  204.         } catch (Exception e) {
  205.             System.err.println(e.getMessage());
  206.             return null;
  207.         } finally {
  208.             if (jedis != null) {
  209.                 jedis.close();
  210.             }
  211.         }
  212.     }
  214.     /**
  215.      *命令将 key 中储存的数字值增一
  216.      * @param key
  217.      * @return
  218.      */
  219.         public Long incr(String key){
  220.         Jedis jedis = null;
  221.         try {
  222.             jedis = jedisPool.getResource();
  223.             return jedis.incr(key);
  224.         } catch (Exception e) {
  225.             System.err.println(e.getMessage());
  226.             return null;
  227.         } finally {
  228.             if (jedis != null) {
  229.                 jedis.close();
  230.             }
  231.         }
  232.     }
  233. }

5、User实体类，继承Serializable序列化是非必要

  1. package com.cat.code.po;
  3. import lombok.Data;
  5. import java.io.Serializable;
  7. /**
  8.  * @Author: lvgang
  9.  * @Time: 2019/10/29 16:43
  10.  * @Email: lvgang@golaxy.cn
  11.  * @Description: todo
  12.  */
  13. @Data
  14. public class User implements Serializable {
  16.     private static final long serialVersionUID = 1L;
  18.     private Long id;
  19.     private String name;
  20.     private Integer age;
  22.     public User(){}
  24.     public User(Long id,String name,Integer age){
  25.         this.id = id;
  26.         this.name = name;
  27.         this.age = age;
  28.     }
  30. }

6、调用redis存取，在大部分情况下是OK的，保证资源存取不会出现问题

  1. package com.cat.code;
  3. import com.cat.code.config.RedisTemplate;
  4. import com.cat.code.po.User;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import org.junit.Test;
  7. import org.junit.runner.RunWith;
  8. import org.slf4j.Logger;
  9. import org.slf4j.LoggerFactory;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.boot.test.context.SpringBootTest;
  12. import org.springframework.test.context.junit4.SpringRunner;
  14. import java.util.concurrent.ExecutorService;
  15. import java.util.concurrent.Executors;
  16. import java.util.stream.IntStream;
  18. /**
  19.  * @Author: lvgang
  20.  * @Time: 2019/10/29 17:05
  21.  * @Email: lvgang@golaxy.cn
  22.  * @Description: todo
  23.  */
  24. @RunWith(SpringRunner.class)
  25. @SpringBootTest(classes = ServiceSpringDataRedisApplication.class)
  26. public class RedisTest {
  27.     private Logger logger = LoggerFactory.getLogger(RedisTest.class);
  29.     @Autowired
  30.     private RedisTemplate redisTemplate;
  31.     @Autowired
  32.     private ObjectMapper objectMapper = new ObjectMapper();
  34.     @Test
  35.     public void test1() throws Exception{
  36.         String key = "user1";
  37.         String json = objectMapper.writeValueAsString(new User(1L,"admin",21));
  38.         redisTemplate.set(key,json);
  39.         String value = redisTemplate.get(key);
  40.         User user = objectMapper.readValue(value,User.class);
  41.         logger.info("user:{}",user.toString());
  42.     }
  44.     @Test
  45.     public void test2(){
  46.         ExecutorService executorService = Executors.newFixedThreadPool(1000);
  47.         IntStream.range(0, 1000).forEach(i->{
  48.             executorService.execute(()->{
  49.                 logger.info("i:{}",i);
  50.                 redisTemplate.incr("count");//累加
  51.                 if(i%2==1){
  52.                     redisTemplate.sadd("set",""+i);//添加
  53.                 }else {
  54.                     String value = redisTemplate.spop("set");//取出
  55.                     logger.info("第i次:{}获取{}",i,value);
  56.                 }
  57.             });
  58.         });
  59.     }
  60. }

7、写在最后，当我们对redis连接要求不是那么高时，我建议直接使用spring-boot-data-redis

  1. pom.xml依赖
  2. <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-data-redis</artifactId>
  5.             <version>2.1.8.RELEASE</version>
  6.         </dependency>
  8. 服务直接自动注入使用
  9. @Autowired
  10.  private StringRedisTemplate stringRedisTemplate;

发表评论

表情：
评论列表 （有 0 条评论，55人围观）

还没有评论，来说两句吧...

相关阅读