秒杀——集成redis

迷南。 2022-05-09 12:28 297阅读 0赞

首先第一步肯定是导入依赖啊

70

jedis就是集成了redis的一些命令操作，封装了redis的java客户端。提供了连接池管理。一般不直接使用jedis，而是在其上在封装一层，作为业务的使用，我们也是自己在其上封装了，下面你就会看到。

fastjson是序列化的一个包，它可以把我们的java对象转换成我们的一个json对象放入redis中

然后在配置文件中添加基本配置

70 1

然后开始写代码咯

首先我们要写一个配置类，Redisconfig来读取配置文件中的配置

  1. package com.yy.miaosha.redis;
  3. import org.springframework.boot.context.properties.ConfigurationProperties;
  4. import org.springframework.stereotype.Component;
  6. @Component
  7. @ConfigurationProperties(prefix="redis")  //读取前缀为redis的配置信息，将这些信息注入到下面属性参数中
  8. public class RedisConfig {
  9.     private String host;
  10.     private int port;
  11.     private int timeout;//秒
  12.     private String password;
  13.     private int poolMaxTotal;
  14.     private int poolMaxIdle;
  15.     private int poolMaxWait;//秒
  17.     //getter和setter方法在这里省略
  18. }

然后我们再创建一个JedisPool的工厂类，利用上面的RedisConfig获得的配置信息，传入到JedisPoolConfig创建的实例中，然后通过这个实例和RedisConfig获得的配置信息来创建JedisPool

  1. package com.yy.miaosha.redis;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.stereotype.Service;
  6. import redis.clients.jedis.JedisPool;
  7. import redis.clients.jedis.JedisPoolConfig;
  9. @Service
  10. public class RedisPoolFactory {
  12.     @Autowired
  13.     RedisConfig redisConfig;
  15.          //在方法上打上注解 @Bean即表示声明该方法返回的实例是受 Spring 管理的 Bean。
  16.     @Bean
  17.     public JedisPool JedisPoolFactory() {
  18.         JedisPoolConfig poolConfig = new JedisPoolConfig();
  19.         poolConfig.setMaxIdle(redisConfig.getPoolMaxIdle());
  20.         poolConfig.setMaxTotal(redisConfig.getPoolMaxTotal());
  21.         poolConfig.setMaxWaitMillis(redisConfig.getPoolMaxWait() * 1000);
  22.         JedisPool jp = new JedisPool(poolConfig, redisConfig.getHost(), redisConfig.getPort(),
  23.                 redisConfig.getTimeout()*1000, redisConfig.getPassword(), 0);
  24.         return jp;
  25.     }
  27. }

注意：JedisPoolFactory上必须加@Bean注解，否则在启动时，下面代码中注入的JedisPool会找不到，会爆出下图错误

70 2

最后我们来写RedisService类，我们在此类中定义对redis中的各种操作

  1. package com.yy.miaosha.redis;
  3. import com.alibaba.fastjson.JSON;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Service;
  6. import redis.clients.jedis.Jedis;
  7. import redis.clients.jedis.JedisPool;
  9. @Service
  10. public class RedisService {
  12.     @Autowired
  13.     JedisPool jedisPool;
  15.     /**
  16.      * 获取当个对象
  17.      * */
  18.     public <T> T get(KeyPrefix prefix, String key,  Class<T> clazz) {
  19.          Jedis jedis = null;
  20.          try {
  21.              jedis =  jedisPool.getResource();
  22.              //生成真正的key
  23.              String realKey  = prefix.getPrefix() + key;
  24.              String  str = jedis.get(realKey);  //get出来的是String类型
  25.              T t =  stringToBean(str, clazz);  //将字符串转换为一个bean对象
  26.              return t;
  27.          }finally {
  28.                //最后要释放连接池
  29.               returnToPool(jedis);
  30.          }
  31.     }
  33.     /**
  34.      * 设置对象
  35.      * */
  36.     public <T> boolean set(KeyPrefix prefix, String key,  T value) {
  37.          Jedis jedis = null;
  38.          try {
  39.              jedis =  jedisPool.getResource();
  40.              //存入到redis中的value必须是string类型
  41.              String str = beanToString(value);
  42.              if(str == null || str.length() <= 0) {
  43.                  return false;
  44.              }
  45.             //生成真正的key
  46.              String realKey  = prefix.getPrefix() + key;
  47.              int seconds =  prefix.expireSeconds();
  48.              if(seconds <= 0) {
  49.                   //永不过期
  50.                  jedis.set(realKey, str);
  51.              }else {
  52.                   //过期时间为seconds
  53.                  jedis.setex(realKey, seconds, str);
  54.              }
  55.              return true;
  56.          }finally {
  57.               returnToPool(jedis);
  58.          }
  59.     }
  61.     /**
  62.      * 判断key是否存在
  63.      * */
  64.     public <T> boolean exists(KeyPrefix prefix, String key) {
  65.          Jedis jedis = null;
  66.          try {
  67.              jedis =  jedisPool.getResource();
  68.             //生成真正的key
  69.              String realKey  = prefix.getPrefix() + key;
  70.             return  jedis.exists(realKey);
  71.          }finally {
  72.               returnToPool(jedis);
  73.          }
  74.     }
  76.     /**
  77.      * 删除
  78.      * */
  79.     public boolean delete(KeyPrefix prefix, String key) {
  80.          Jedis jedis = null;
  81.          try {
  82.              jedis =  jedisPool.getResource();
  83.             //生成真正的key
  84.             String realKey  = prefix.getPrefix() + key;
  85.             long ret =  jedis.del(key);
  86.             return ret > 0;
  87.          }finally {
  88.               returnToPool(jedis);
  89.          }
  90.     }
  92.     /**
  93.      * 增加值
  94.      * */
  95.     public <T> Long incr(KeyPrefix prefix, String key) {
  96.          Jedis jedis = null;
  97.          try {
  98.              jedis =  jedisPool.getResource();
  99.             //生成真正的key
  100.              String realKey  = prefix.getPrefix() + key;
  101.             return  jedis.incr(realKey);
  102.          }finally {
  103.               returnToPool(jedis);
  104.          }
  105.     }
  107.     /**
  108.      * 减少值
  109.      * */
  110.     public <T> Long decr(KeyPrefix prefix, String key) {
  111.          Jedis jedis = null;
  112.          try {
  113.              jedis =  jedisPool.getResource();
  114.             //生成真正的key
  115.              String realKey  = prefix.getPrefix() + key;
  116.             return  jedis.decr(realKey);
  117.          }finally {
  118.               returnToPool(jedis);
  119.          }
  120.     }
  122.     public static  <T> String beanToString(T value) {
  123.         if(value == null) {
  124.             return null;
  125.         }
  126.         Class<?> clazz = value.getClass();
  127.         if(clazz == int.class || clazz == Integer.class) {
  128.              return ""+value;
  129.         }else if(clazz == String.class) {
  130.              return (String)value;
  131.         }else if(clazz == long.class || clazz == Long.class) {
  132.             return ""+value;
  133.         }else {
  134.                           //fastjason中的方法
  135.             return JSON.toJSONString(value);
  136.         }
  137.     }
  140.     /**
  141.      *  将字符串转换为一个bean对象
  142.      */
  143.     @SuppressWarnings("unchecked")
  144.     public static  <T> T stringToBean(String str, Class<T> clazz) {
  145.         if(str == null || str.length() <= 0 || clazz == null) {
  146.              return null;
  147.         }
  148.         if(clazz == int.class || clazz == Integer.class) {
  149.              return (T)Integer.valueOf(str);
  150.         }else if(clazz == String.class) {
  151.              return (T)str;
  152.         }else if(clazz == long.class || clazz == Long.class) {
  153.             return  (T)Long.valueOf(str);
  154.         }else {
  155.                         //fastjason中的方法
  156.             return JSON.toJavaObject(JSON.parseObject(str), clazz);
  157.         }
  158.     }
  160.     //jedis用完了就要返回给jedisPool
  161.     private void returnToPool(Jedis jedis) {
  162.          if(jedis != null) {
  163.              jedis.close();
  164.          }
  165.     }
  167. }

其中要注意的是，RedisService中的增删改的方法都是调用了jedis自己原生的方法

注意，jedis将一个对象转变成String放入redis中，从redis中拿出String同样需要转回成原对象，所以上面代码对应为stringToBean(String str, Class clazz) 和 beanToString(T value)

这样我们就写完了，最后我们可以写个controller然后试试是否成功

70 3

发表评论

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

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

相关阅读

    相关 Redis实现商品秒杀

    随着互联网的发展和消费者的需求越来越高，商品的销售也变得越来越激烈。而对于商家来说，最直观的解决方式即为促销活动。然而，促销活动也会引发一定的风险。如果处理得不当，可能会出现“

    阳光穿透心脏的1/2处阳光穿透心脏的1/2处/ 0 赞/ 124 阅读

    相关 秒杀——集成redis

    首先第一步肯定是导入依赖啊 ![70][] jedis就是集成了redis的一些命令操作，封装了redis的java客户端。提供了连接池管理。一般不直接使用jedis，而是

    迷南。迷南。/ 0 赞/ 298 阅读

    相关 Redis实现秒杀功能

    在实际生活中，秒杀功能是比较常见的，如12306抢票、电商系统的秒杀活动等。所谓秒杀，从应用业务角度来看，是指在短时间内多个用户“争抢”某个资源，这里的资源在大部分秒杀场景里是

    秒速五厘米秒速五厘米/ 0 赞/ 557 阅读