秒杀——集成redis

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

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

![70][]

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

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

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

![70 1][]

然后开始写代码咯

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

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

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

package com.yy.miaosha.redis;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.stereotype.Service;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    
    @Service
    public class RedisPoolFactory {
    
    	@Autowired
    	RedisConfig redisConfig;
     	
             //在方法上打上注解 @Bean即表示声明该方法返回的实例是受 Spring 管理的 Bean。
    	@Bean
    	public JedisPool JedisPoolFactory() {
    		JedisPoolConfig poolConfig = new JedisPoolConfig();
    		poolConfig.setMaxIdle(redisConfig.getPoolMaxIdle());
    		poolConfig.setMaxTotal(redisConfig.getPoolMaxTotal());
    		poolConfig.setMaxWaitMillis(redisConfig.getPoolMaxWait() * 1000);
    		JedisPool jp = new JedisPool(poolConfig, redisConfig.getHost(), redisConfig.getPort(),
    				redisConfig.getTimeout()*1000, redisConfig.getPassword(), 0);
    		return jp;
    	}
    	
    }

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

![70 2][]

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

package com.yy.miaosha.redis;
    
    import com.alibaba.fastjson.JSON;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    
    @Service
    public class RedisService {
    
    	@Autowired
    	JedisPool jedisPool;
    
    	/**
    	 * 获取当个对象
    	 * */
    	public <T> T get(KeyPrefix prefix, String key,  Class<T> clazz) {
    		 Jedis jedis = null;
    		 try {
    			 jedis =  jedisPool.getResource();
    			 //生成真正的key
    			 String realKey  = prefix.getPrefix() + key;
    			 String  str = jedis.get(realKey);  //get出来的是String类型
    			 T t =  stringToBean(str, clazz);  //将字符串转换为一个bean对象
    			 return t;
    		 }finally {
    		 	  //最后要释放连接池
    			  returnToPool(jedis);
    		 }
    	}
    
    	/**
    	 * 设置对象
    	 * */
    	public <T> boolean set(KeyPrefix prefix, String key,  T value) {
    		 Jedis jedis = null;
    		 try {
    			 jedis =  jedisPool.getResource();
    			 //存入到redis中的value必须是string类型
    			 String str = beanToString(value);
    			 if(str == null || str.length() <= 0) {
    				 return false;
    			 }
    			//生成真正的key
    			 String realKey  = prefix.getPrefix() + key;
    			 int seconds =  prefix.expireSeconds();
    			 if(seconds <= 0) {
    			 	 //永不过期
    				 jedis.set(realKey, str);
    			 }else {
    			 	 //过期时间为seconds
    				 jedis.setex(realKey, seconds, str);
    			 }
    			 return true;
    		 }finally {
    			  returnToPool(jedis);
    		 }
    	}
    	
    	/**
    	 * 判断key是否存在
    	 * */
    	public <T> boolean exists(KeyPrefix prefix, String key) {
    		 Jedis jedis = null;
    		 try {
    			 jedis =  jedisPool.getResource();
    			//生成真正的key
    			 String realKey  = prefix.getPrefix() + key;
    			return  jedis.exists(realKey);
    		 }finally {
    			  returnToPool(jedis);
    		 }
    	}
    	
    	/**
    	 * 删除
    	 * */
    	public boolean delete(KeyPrefix prefix, String key) {
    		 Jedis jedis = null;
    		 try {
    			 jedis =  jedisPool.getResource();
    			//生成真正的key
    			String realKey  = prefix.getPrefix() + key;
    			long ret =  jedis.del(key);
    			return ret > 0;
    		 }finally {
    			  returnToPool(jedis);
    		 }
    	}
    	
    	/**
    	 * 增加值
    	 * */
    	public <T> Long incr(KeyPrefix prefix, String key) {
    		 Jedis jedis = null;
    		 try {
    			 jedis =  jedisPool.getResource();
    			//生成真正的key
    			 String realKey  = prefix.getPrefix() + key;
    			return  jedis.incr(realKey);
    		 }finally {
    			  returnToPool(jedis);
    		 }
    	}
    	
    	/**
    	 * 减少值
    	 * */
    	public <T> Long decr(KeyPrefix prefix, String key) {
    		 Jedis jedis = null;
    		 try {
    			 jedis =  jedisPool.getResource();
    			//生成真正的key
    			 String realKey  = prefix.getPrefix() + key;
    			return  jedis.decr(realKey);
    		 }finally {
    			  returnToPool(jedis);
    		 }
    	}
    
    	public static  <T> String beanToString(T value) {
    		if(value == null) {
    			return null;
    		}
    		Class<?> clazz = value.getClass();
    		if(clazz == int.class || clazz == Integer.class) {
    			 return ""+value;
    		}else if(clazz == String.class) {
    			 return (String)value;
    		}else if(clazz == long.class || clazz == Long.class) {
    			return ""+value;
    		}else {
                              //fastjason中的方法
    			return JSON.toJSONString(value);
    		}
    	}
    
    
    	/**
    	 *  将字符串转换为一个bean对象
    	 */
    	@SuppressWarnings("unchecked")
    	public static  <T> T stringToBean(String str, Class<T> clazz) {
    		if(str == null || str.length() <= 0 || clazz == null) {
    			 return null;
    		}
    		if(clazz == int.class || clazz == Integer.class) {
    			 return (T)Integer.valueOf(str);
    		}else if(clazz == String.class) {
    			 return (T)str;
    		}else if(clazz == long.class || clazz == Long.class) {
    			return  (T)Long.valueOf(str);
    		}else {
                            //fastjason中的方法
    			return JSON.toJavaObject(JSON.parseObject(str), clazz);
    		}
    	}
    
        //jedis用完了就要返回给jedisPool
    	private void returnToPool(Jedis jedis) {
    		 if(jedis != null) {
    			 jedis.close();
    		 }
    	}
    
    }

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

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

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

![70 3][]

[70]: /images/20220509/fae2a37e7ee3441685dcb190983020ab.png
[70 1]: /images/20220509/466c191615174072ad51b636fe43a596.png
[70 2]: /images/20220509/5ca0f8e8a318467b95ef89afa2c72664.png
[70 3]: /images/20220509/ea09f5f26ea54ab6a7b7062d0f674865.png