SpringBoot整合Redis-单机版

╰+哭是因爲堅強的太久メ 2024-03-24 12:17 145阅读 0赞

1、创建一个springboot工程

略

2、在pom.xml中导入Redis的相关依赖

  1. <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-data-redis</artifactId>
  4.         </dependency>
  5.         <!-- spring2.X集成redis所需common-pool2-->
  6.         <dependency>
  7.             <groupId>org.apache.commons</groupId>
  8.             <artifactId>commons-pool2</artifactId>
  9.             <version>2.6.0</version>
  10.         </dependency>

3、在application.properties中配置redis

  1. #springboot2.x之后，默认使用的client是lettuce，而不是jedis了
  2. # Redis数据库索引（默认为0）
  3. spring.redis.database=0
  4. # Redis服务器地址
  5. spring.redis.host=127.0.0.1
  6. # Redis服务器连接端口
  7. spring.redis.port=6379
  8. # Redis服务器连接密码（默认为空）
  9. #spring.redis.password=123456
  10. #连接超时时间（毫秒）
  11. spring.redis.timeout=1800000
  12. #连接池最大连接数（使用负值表示没有限制）
  13. spring.redis.lettuce.pool.max-active=20
  14. #最大阻塞等待时间(负数表示没限制)
  15. spring.redis.lettuce.pool.max-wait=-1
  16. #连接池中的最大空闲连接
  17. spring.redis.lettuce.pool.max-idle=5
  18. #连接池中的最小空闲连接
  19. spring.redis.lettuce.pool.min-idle=0

4、添加Redis的配置类

  1. package com.andrew.config;
  3. import org.springframework.cache.annotation.CachingConfigurerSupport;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.data.redis.connection.RedisConnectionFactory;
  7. import org.springframework.data.redis.core.RedisTemplate;
  8. import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
  9. import org.springframework.data.redis.serializer.StringRedisSerializer;
  11. @Configuration
  12. public class RedisConfig extends CachingConfigurerSupport {
  15.     @Bean
  16.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
  18.         RedisTemplate<String, Object> template = new RedisTemplate<>();
  19.         template.setConnectionFactory(factory);
  20.         // key采用String的序列化方式
  21.         template.setKeySerializer(new StringRedisSerializer());
  22.         // hash的key也采用String的序列化方式
  23.         template.setHashKeySerializer(new StringRedisSerializer());
  24.         // value序列化方式采用jackson
  25.         template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
  26.         // hash的value序列化方式采用jackson
  27.         template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
  28.         template.afterPropertiesSet();
  29.         return template;
  30.     }
  32. }

5、测试

  1. @RestController
  2. @RequestMapping("/redis")
  3. public class RedisTestController {
  5.     @Autowired
  6.     private RedisTemplate redisTemplate;
  7.     @Autowired
  8.     private RedisUtil redisUtil;
  10.     @GetMapping("test1")
  11.     public String test1() {
  13.         redisTemplate.opsForValue().set("name","lucy");
  14.         String name = (String)redisTemplate.opsForValue().get("name");
  15.         return name;
  16.     }
  18.     @GetMapping("test2")
  19.     public String test2() {
  21.         redisUtil.set("age", "12");
  22.         String age = (String) redisUtil.get("age");
  23.         return age;
  24.     }
  26. }

贴个RedisUtil：

  1. @Component
  2. public class RedisUtil {
  5.     @Resource
  6.     private RedisTemplate redisTemplate;
  8.     private static double size = Math.pow(2, 32);
  10.     /**
  11.      * 写入缓存
  12.      *
  13.      * @param key
  14.      * @param offset   位 8Bit=1Byte
  15.      * @return
  16.      */
  17.     public boolean setBit(String key, long offset, boolean isShow) {
  19.         boolean result = false;
  20.         try {
  22.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  23.             operations.setBit(key, offset, isShow);
  24.             result = true;
  25.         } catch (Exception e) {
  27.             e.printStackTrace();
  28.         }
  29.         return result;
  30.     }
  32.     /**
  33.      * 得到缓存
  34.      *
  35.      * @param key
  36.      * @param offset
  37.      * @return
  38.      */
  39.     public boolean getBit(String key, long offset) {
  41.         boolean result = false;
  42.         try {
  44.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  45.             result = operations.getBit(key, offset);
  46.         } catch (Exception e) {
  48.             e.printStackTrace();
  49.         }
  50.         return result;
  51.     }
  53.     /**
  54.      * 写入缓存
  55.      * @param key
  56.      * @param value
  57.      * @return
  58.      */
  59.     public boolean set(final String key, Object value) {
  61.         boolean result = false;
  62.         try {
  64.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  65.             operations.set(key, value);
  66.             result = true;
  67.         } catch (Exception e) {
  69.             e.printStackTrace();
  70.         }
  71.         return result;
  72.     }
  75.     /**
  76.      * 写入缓存设置时效时间
  77.      * @param key
  78.      * @param value
  79.      * @return
  80.      */
  81.     public boolean set(final String key, Object value, Long expireTime) {
  83.         boolean result = false;
  84.         try {
  86.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  87.             operations.set(key, value);
  88.             redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
  89.             result = true;
  90.         } catch (Exception e) {
  92.             e.printStackTrace();
  93.         }
  94.         return result;
  95.     }
  97.     /**
  98.      * 批量删除对应的value
  99.      *
  100.      * @param keys
  101.      */
  102.     public void remove(final String... keys) {
  104.         for (String key : keys) {
  106.             remove(key);
  107.         }
  108.     }
  110.     /**
  111.      * 删除对应的value
  112.      *
  113.      * @param key
  114.      */
  115.     public void remove(final String key) {
  117.         if (exists(key)) {
  119.             redisTemplate.delete(key);
  120.         }
  121.     }
  123.     /**
  124.      * 判断缓存中是否有对应的value
  125.      *
  126.      * @param key
  127.      * @return
  128.      */
  129.     public boolean exists(final String key) {
  131.         return redisTemplate.hasKey(key);
  132.     }
  134.     /**
  135.      * 读取缓存
  136.      *
  137.      * @param key
  138.      * @return
  139.      */
  140.     public Object get(final String key) {
  142.         Object result = null;
  143.         ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  144.         result = operations.get(key);
  145.         return result;
  146.     }
  148.     /**
  149.      * 哈希 添加
  150.      *
  151.      * @param key
  152.      * @param hashKey
  153.      * @param value
  154.      */
  155.     public void hmSet(String key, Object hashKey, Object value) {
  157.         HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
  158.         hash.put(key, hashKey, value);
  159.     }
  161.     /**
  162.      * 哈希获取数据
  163.      *
  164.      * @param key
  165.      * @param hashKey
  166.      * @return
  167.      */
  168.     public Object hmGet(String key, Object hashKey) {
  170.         HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
  171.         return hash.get(key, hashKey);
  172.     }
  174.     /**
  175.      * 列表添加
  176.      *
  177.      * @param k
  178.      * @param v
  179.      */
  180.     public void lPush(String k, Object v) {
  182.         ListOperations<String, Object> list = redisTemplate.opsForList();
  183.         list.leftPush(k, v);
  184.     }
  186.     /**
  187.      * 列表添加
  188.      *
  189.      * @param k
  190.      * @param v
  191.      */
  192.     public void rPush(String k, Object v) {
  194.         ListOperations<String, Object> list = redisTemplate.opsForList();
  195.         list.rightPush(k, v);
  196.     }
  198.     /**
  199.      * 左弹出数列
  200.      * @param key
  201.      * @return
  202.      */
  203.     public Object lPop(String key) {
  205.         ListOperations<String, Object> list = redisTemplate.opsForList();
  206.         return list.leftPop(key);
  207.     }
  209.     /**
  210.      * 右弹出数列
  211.      * @param key
  212.      * @return
  213.      */
  214.     public Object rPop(String key) {
  216.         ListOperations<String, Object> list = redisTemplate.opsForList();
  217.         return list.rightPop(key);
  218.     }
  220.     /**
  221.      * 列表获取
  222.      *
  223.      * @param k
  224.      * @param l
  225.      * @param l1
  226.      * @return
  227.      */
  228.     public List<Object> lRange(String k, long l, long l1) {
  230.         ListOperations<String, Object> list = redisTemplate.opsForList();
  231.         return list.range(k, l, l1);
  232.     }
  234.     /**
  235.      * 列表获取
  236.      * @param key
  237.      * @return
  238.      */
  239.     public List<Object> lRange(String key){
  241.         ListOperations<String, Object> list = redisTemplate.opsForList();
  242.         return list.range(key, 0, list.size(key));
  243.     }
  245.     /**
  246.      * 集合添加
  247.      *
  248.      * @param key
  249.      * @param value
  250.      */
  251.     public void add(String key, Object value) {
  253.         SetOperations<String, Object> set = redisTemplate.opsForSet();
  254.         set.add(key, value);
  255.     }
  257.     /**
  258.      * 集合获取
  259.      *
  260.      * @param key
  261.      * @return
  262.      */
  263.     public Set<Object> setMembers(String key) {
  265.         SetOperations<String, Object> set = redisTemplate.opsForSet();
  266.         return set.members(key);
  267.     }
  269.     /**
  270.      * 有序集合添加
  271.      *
  272.      * @param key
  273.      * @param value
  274.      * @param scoure
  275.      */
  276.     public void zAdd(String key, Object value, double scoure) {
  278.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  279.         zset.add(key, value, scoure);
  280.     }
  282.     /**
  283.      * 有序集合获取
  284.      *
  285.      * @param key
  286.      * @param scoure
  287.      * @param scoure1
  288.      * @return
  289.      */
  290.     public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
  292.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  293.         redisTemplate.opsForValue();
  294.         return zset.rangeByScore(key, scoure, scoure1);
  295.     }
  297.     /**
  298.      * 有序集合获取排名
  299.      *
  300.      * @param key 集合名称
  301.      * @param value 值
  302.      */
  303.     public Long zRank(String key, Object value) {
  305.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  306.         return zset.rank(key,value);
  307.     }
  310.     /**
  311.      * 有序集合获取排名
  312.      *
  313.      * @param key
  314.      */
  315.     public Set<ZSetOperations.TypedTuple<Object>> zRankWithScore(String key, long start,long end) {
  317.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  318.         Set<ZSetOperations.TypedTuple<Object>> ret = zset.rangeWithScores(key,start,end);
  319.         return ret;
  320.     }
  322.     /**
  323.      * 有序集合添加
  324.      *
  325.      * @param key
  326.      * @param value
  327.      */
  328.     public Double zSetScore(String key, Object value) {
  330.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  331.         return zset.score(key,value);
  332.     }
  335.     /**
  336.      * 有序集合添加分数
  337.      *
  338.      * @param key
  339.      * @param value
  340.      * @param scoure
  341.      */
  342.     public void incrementScore(String key, Object value, double scoure) {
  344.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  345.         zset.incrementScore(key, value, scoure);
  346.     }
  349.     /**
  350.      * 有序集合获取排名
  351.      *
  352.      * @param key
  353.      */
  354.     public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithScore(String key, long start,long end) {
  356.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  357.         Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeByScoreWithScores(key,start,end);
  358.         return ret;
  359.     }
  361.     /**
  362.      * 有序集合获取排名
  363.      *
  364.      * @param key
  365.      */
  366.     public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithRank(String key, long start, long end) {
  368.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  369.         Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeWithScores(key, start, end);
  370.         return ret;
  371.     }
  373.     //第一次加载的时候将数据加载到redis中
  374.     public void saveDataToRedis(String name) {
  376.         double index = Math.abs(name.hashCode() % size);
  377.         long indexLong = new Double(index).longValue();
  378.         boolean availableUsers = setBit("availableUsers", indexLong, true);
  379.     }
  381.     //第一次加载的时候将数据加载到redis中
  382.     public boolean getDataToRedis(String name) {
  385.         double index = Math.abs(name.hashCode() % size);
  386.         long indexLong = new Double(index).longValue();
  387.         return getBit("availableUsers", indexLong);
  388.     }
  391.     /**
  392.      * 删除对应的value
  393.      * @param key
  394.      */
  395.    /* public boolean remove(final String key) {
  396.         if (exists(key)) {
  397.             Boolean delete = redisTemplate.delete(key);
  398.             return delete;
  399.         }
  400.         return false;
  402.     }*/
  403. }

完毕，
有不对的地方请多多指正。

发表评论

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

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

相关阅读