使用Redis

目录

使用原生Jedis

springboot中使用Jedis

springboot中使用Redistemplate

springboot中使用Redisson

---

使用原生Jedis

springboot中使用Jedis

1. 在pom文件引入依赖

           <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-pool2 -->
           <dependency>
               <groupId>org.apache.commons</groupId>
               <artifactId>commons-pool2</artifactId>
               <version>2.8.0</version>
           </dependency>
           <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
           <dependency>
               <groupId>redis.clients</groupId>
               <artifactId>jedis</artifactId>
               <version>3.2.0</version>
           </dependency>

2. 编写配置类

   @Configuration
   public class JedisConfig extends CachingConfigurerSupport {
       private Logger logger = LoggerFactory.getLogger(JedisConfig.class);
   
       /**
        * SpringSession  需要注意的就是redis需要2.8以上版本，然后开启事件通知，在redis配置文件里面加上
        * notify-keyspace-events Ex
        * Keyspace notifications功能默认是关闭的（默认地，Keyspace 时间通知功能是禁用的，因为它或多或少会使用一些CPU的资源）。
        * 或是使用如下命令：
        * redis-cli config set notify-keyspace-events Egx
        * 如果你的Redis不是你自己维护的，比如你是使用阿里云的Redis数据库，你不能够更改它的配置，那么可以使用如下方法：在applicationContext.xml中配置
        * <util:constant static-field="org.springframework.session.data.redis.config.ConfigureRedisAction.NO_OP"/>
        * @return
        */
   
       @Value("${spring.redis.host:127.0.0.1}")
       private String host;
   
       @Value("${spring.redis.port:6379}")
       private int port;
   
       @Value("${spring.redis.timeout:0}")
       private int timeout;
   
       @Value("${spring.redis.pool.max-active:200}")
       private int maxActive;
   
       @Value("${spring.redis.pool.max-idle:8}")
       private int maxIdle;
   
       @Value("${spring.redis.pool.min-idle:0}")
       private int minIdle;
   
       @Value("${spring.redis.pool.max-wait:-1}")
       private long maxWaitMillis;
   
   
   
       @Bean
       public JedisPool redisPoolFactory(){
           JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
           jedisPoolConfig.setMaxIdle(maxIdle);
           jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
           jedisPoolConfig.setMaxTotal(maxActive);
           jedisPoolConfig.setMinIdle(minIdle);
           JedisPool jedisPool = new JedisPool(jedisPoolConfig,host,port,timeout,null);
   
           logger.info("JedisPool注入成功！");
           logger.info("redis地址：" + host + ":" + port);
           return  jedisPool;
       }
   
   }

3. 使用JedisPool

   import java.util.ArrayList;
   import java.util.List;
   
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.beans.factory.annotation.Qualifier;
   import org.springframework.stereotype.Service;
   
   import com.alibaba.fastjson.JSON;
   
   import redis.clients.jedis.Jedis;
   import redis.clients.jedis.JedisPool;
   import redis.clients.jedis.ScanParams;
   import redis.clients.jedis.ScanResult;
   
   @Service
   public class RedisService {
   
   	@Autowired
   	JedisPool jedisPool;
   
   
   
   	/**
   	 * 获取当个对象
   	 * */
   	public <T> T get(String key,  Class<T> clazz) {
   		Jedis jedis = null;
   		try {
   			jedis =  jedisPool.getResource();
   			String  str = jedis.get(key);
   			T t =  stringToBean(str, clazz);
   			return t;
   		}finally {
   			returnToPool(jedis);
   		}
   	}
   
   	/**
   	 * 设置对象
   	 * */
   	public <T> String  set(String key,  T value) {
   		Jedis jedis = null;
   		try {
   			jedis =  jedisPool.getResource();
   			String str = beanToString(value);
   			if(str == null || str.length() <= 0) {
   				return false;
   			}
   			return  jedis.set(key, str);
   		}finally {
   			returnToPool(jedis);
   		}
   	}
   
   	/**
   	 * 判断key是否存在
   	 * */
   	public <T> boolean exists(String key) {
   		Jedis jedis = null;
   		try {
   			jedis =  jedisPool.getResource();
   			return  jedis.exists(key);
   		}finally {
   			returnToPool(jedis);
   		}
   	}
   
   	/**
   	 * 删除
   	 * */
   	public boolean delete(String key) {
   		Jedis jedis = null;
   		try {
   			jedis =  jedisPool.getResource();
   			long ret =  jedis.del(key);
   			return ret > 0;
   		}finally {
   			returnToPool(jedis);
   		}
   	}
   
   	/**
   	 * 增加值
   	 * */
   	public <T> Long incr(String key) {
   		Jedis jedis = null;
   		try {
   			jedis =  jedisPool.getResource();
   			return  jedis.incr(key);
   		}finally {
   			returnToPool(jedis);
   		}
   	}
   
   	/**
   	 * 减少值
   	 * */
   	public <T> Long decr(String key) {
   		Jedis jedis = null;
   		try {
   			jedis =  jedisPool.getResource();
   			return  jedis.decr(key);
   		}finally {
   			returnToPool(jedis);
   		}
   	}
   
   
   
   	public List<String> scanKeys(String key) {
   		Jedis jedis = null;
   		try {
   			jedis = jedisPool.getResource();
   			List<String> keys = new ArrayList<String>();
   			String cursor = "0";
   			ScanParams sp = new ScanParams();
   			sp.match(key+"*");
   			sp.count(100);
   			do{
   				ScanResult<String> ret = jedis.scan(cursor, sp);
   				List<String> result = ret.getResult();
   				if(result!=null && result.size() > 0){
   					keys.addAll(result);
   				}
   				cursor = ret.getStringCursor();
   			}while(!cursor.equals("0"));
   			return keys;
   		} finally {
   			if (jedis != null) {
   				jedis.close();
   			}
   		}
   	}
   	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 {
   			return JSON.toJSONString(value);
   		}
   	}
   	@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 {
   			return JSON.toJavaObject(JSON.parseObject(str), clazz);
   		}
   	}
   	private void returnToPool(Jedis jedis) {
   		if(jedis != null) {
   			jedis.close();
   		}
   	}
   }
   

    

    

springboot中使用Redistemplate

1. 在pom文件中引入依赖

   
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-data-redis</artifactId>
           </dependency>

2. 配置类

   @Configuration
   public class RedisConfig {
   
       @Bean
       public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
           //操作String类型的RedisTemplate
           StringRedisTemplate redisTemplate = new StringRedisTemplate();
           redisTemplate.setConnectionFactory(factory);
           return redisTemplate;
       }
   
       @Bean
       public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
           RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
           redisTemplate.setConnectionFactory(factory);
           //指定序列化策略
           redisTemplate.setKeySerializer(RedisSerializer.string());
           redisTemplate.setHashKeySerializer(RedisSerializer.string());
           redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
           redisTemplate.afterPropertiesSet();
           return redisTemplate;
       }
   }

3. 代码方法

   //string
   stringRedisTemplate.hasKey(String key);
   stringRedisTemplate.opsForValue().set(key, value);
   stringRedisTemplate.opsForValue().get(key);
   
   
   
   //list
   redisTemplate.opsForList();
   redisTemplate.opsForList().rightPush(key, value);
   
   //对应LRANGE key start stop，这里获取所有指定key的List
   redisTemplate.opsForList().range(key, 0, size);
   redisTemplate.opsForList().index(key, index);
   
   // count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT
   redisTemplate.opsForList().remove(key, 1, object);
   
   
   
   //set
   redisTemplate.opsForSet();
   redisTemplate.opsForSet().isMember(String key,value);//boolean
   redisTemplate.opsForSet().add(String key,value);
   redisTemplate.opsForSet().pop(String key);
   
   
   //zset
   redisTemplate.opsForZSet();
   redisTemplate.opsForZSet().score(key ,value);//double
   redisTemplate.opsForZSet().add(key ,value, score);
   redisTemplate.opsForZSet().incrementScore(key ,value, score);
   
   
   //hash
   redisTemplate.opsForHash();
   redisTemplate.opsForHash().put(key,field,value);
   redisTemplate.opsForHash().get(key,field);
   
   
   

    

    

springboot中使用Redisson

1. pom文件引入依赖

           <dependency>
               <groupId>org.redisson</groupId>
               <artifactId>redisson</artifactId>
               <version>3.11.3</version>
           </dependency>

2. 编写配置类

   @Component
   @Configuration
   public class RedissonConfig {
   
       private static final Logger log = LoggerFactory.getLogger(RedissonConfig.class);
   
       @Bean
       public RedissonClient getClient(){
           Config config = new Config();
           config.useSingleServer().setAddress("redis://127.0.0.1:6379");
           RedissonClient client = Redisson.create(config);
           return client;
       }
   }

    

    

3. 使用Redisson
   基础增删改查

   @RestController
   @RequestMapping(value = "redisson")
   public class TestCacheController {
   
       private static final Logger log = LoggerFactory.getLogger(TestCacheController.class);
   
       private static final String USER_KEY = "USER_BUCKET_KEY::";
   
       private final RedissonClient redissonClient;
   
       private final UserService userService;
   
       @Autowired
       public TestCacheController(RedissonClient redissonClient, UserService userService) {
           this.redissonClient = redissonClient;
           this.userService = userService;
       }
   
       @RequestMapping("/addUser")
       public Integer add(User u) {
           Integer integer = userService.addUser(u);
           if (integer > 0) {
               RBucket<User> bucket = redissonClient.getBucket(USER_KEY + u.getId());
               bucket.set(u);
           }
           return u.getId();
       }
   
       @RequestMapping("/getUser")
       public User getUser(Integer userId){
           RBucket<User> bucket = redissonClient.getBucket(USER_KEY + userId);
           if (bucket!=null){
               User user = bucket.get();
               return user;
           } else {
               return userService.getUser(userId);
           }
       }
   
       @RequestMapping("/updateUser")
       public Integer updateUser(User u){
           Integer integer = userService.updateUser(u);
           if (integer > 0) {
               RBucket<User> bucket = redissonClient.getBucket(USER_KEY + u.getId());
               bucket.set(u);
           }
           return u.getId();
       }
   
       @RequestMapping("/deleteUser")
       public User deleteUser(Integer userId){
           Integer integer = userService.deleteUser(userId);
           User user = null;
           if (integer > 0) {
               RBucket<User> bucket = redissonClient.getBucket(USER_KEY + userId);
               user = bucket.getAndDelete();
           }
           return user;
       }
   }