SpringBoot整合Redis

1.对字符串的增删改查

• pom.xml

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

• application.properties

  #redis配置
  #Redis服务器地址
  spring.redis.host=192.168.126.144
  #Redis服务器连接端口
  spring.redis.port=6379
  #Redis数据库索引（默认为0）
  spring.redis.database=0  
  #连接池最大连接数（使用负值表示没有限制）
  spring.redis.jedis.pool.max-active=50
  #连接池最大阻塞等待时间（使用负值表示没有限制）
  spring.redis.jedis.pool.max-wait=3000
  #连接池中的最大空闲连接
  spring.redis.jedis.pool.max-idle=20
  #连接池中的最小空闲连接
  spring.redis.jedis.pool.min-idle=2
  #连接超时时间（毫秒）
  spring.redis.timeout=5000
  

• RedisUtils.java

  package com.ddmzx.springbootredis.utils;
  
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.stereotype.Component;
  
  /**
   * redis操作工具类
   * (基于RedisTemplate)
   */
  @Component
  public class RedisUtils {
  
      @Autowired
      private RedisTemplate<String, String> redisTemplate;
  
      /**
       * 读取缓存
       *
       * @param key
       * @return
       */
      public String get(final String key) {
          return redisTemplate.opsForValue().get(key);
      }
  
      /**
       * 写入缓存
       */
      public boolean set(final String key, String value) {
          boolean result = false;
          try {
              redisTemplate.opsForValue().set(key, value);
              result = true;
          } catch (Exception e) {
              e.printStackTrace();
          }
          return result;
      }
  
      /**
       * 更新缓存
       */
      public boolean getAndSet(final String key, String value) {
          boolean result = false;
          try {
              redisTemplate.opsForValue().getAndSet(key, value);
              result = true;
          } catch (Exception e) {
              e.printStackTrace();
          }
          return result;
      }
  
      /**
       * 删除缓存
       */
      public boolean delete(final String key) {
          boolean result = false;
          try {
              redisTemplate.delete(key);
              result = true;
          } catch (Exception e) {
              e.printStackTrace();
          }
          return result;
      }
  }
  

• SpringbootredisApplicationTests.java

  package com.ddmzx.springbootredis;
  
  import com.ddmzx.springbootredis.utils.RedisUtils;
  import org.junit.jupiter.api.Test;
  import org.junit.runner.RunWith;
  import org.springframework.boot.test.context.SpringBootTest;
  import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  
  import javax.annotation.Resource;
  
  @RunWith(SpringJUnit4ClassRunner.class)
  @SpringBootTest
  class SpringbootredisApplicationTests {
      @Resource
      private RedisUtils redisUtils;
  
      /**
       * 插入缓存数据
       */
      @Test
      public void set() {
          redisUtils.set("redis_key", "redis_vale");
      }
  
      /**
       * 读取缓存数据
       */
      @Test
      public void get() {
          String value = redisUtils.get("redis_key");
          System.out.println(value);
      }
  }
  

2.如果是对其他数据类型的操作

• 更换工具类就行了

  package com.ddmzx.springbootredis.utils;
  
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.concurrent.TimeUnit;
  
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.context.annotation.Lazy;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.stereotype.Component;
  import org.springframework.util.CollectionUtils;
  
  @Lazy
  @Component
  public class RedisUtil{
  
  	@Autowired
  	private RedisTemplate redisTemplate;
  
  	public void setRedisTemplate(RedisTemplate redisTemplate) {
  		this.redisTemplate = redisTemplate;
  	}
  	//=============================common============================
  	/**
  	 * 指定缓存失效时间
  	 * @param key 键
  	 * @param time 时间(秒)
  	 * @return
  	 */
  	public boolean expire(String key,long time){
  		try {
  			if(time>0){
  				redisTemplate.expire(key, time, TimeUnit.SECONDS);
  			}
  			return true;
  		} catch (Exception e) {
  			e.printStackTrace();
  			return false;
  		}
  	}
  
  	/**
  	 * 根据key 获取过期时间
  	 * @param key 键 不能为null
  	 * @return 时间(秒) 返回0代表为永久有效
  	 */
  	public long getExpire(String key){
  		return redisTemplate.getExpire(key,TimeUnit.SECONDS);
  	}
  
  	/**
  	 * 判断key是否存在
  	 * @param key 键
  	 * @return true 存在 false不存在
  	 */
  	public boolean hasKey(String key){
  		try {
  			return redisTemplate.hasKey(key);
  		} catch (Exception e) {
  			e.printStackTrace();
  			return false;
  		}
  	}
  
  	/**
  	 * 删除缓存
  	 * @param key 可以传一个值 或多个
  	 */
  	@SuppressWarnings("unchecked")
  	public void del(String ... key){
  		if(key!=null&&key.length>0){
  			if(key.length==1){
  				redisTemplate.delete(key[0]);
  			}else{
  				redisTemplate.delete(CollectionUtils.arrayToList(key));
  			}
  		}
  	}
  
  	//============================String=============================
  	/**
  	 * 普通缓存获取
  	 * @param key 键
  	 * @return 值
  	 */
  	public Object get(String key, int indexdb){
  		return key==null?null:redisTemplate.opsForValue().get(key);
  	}
  
  	/**
  	 * 普通缓存放入
  	 * @param key 键
  	 * @param value 值
  	 * @return true成功 false失败
  	 */
  	public boolean set(String key,Object value,int indexdb) {
  		try {
  			redisTemplate.opsForValue().set(key, value);
  			return true;
  		} catch (Exception e) {
  			e.printStackTrace();
  			return false;
  		}
  
  	}
  
  	/**
  	 * 普通缓存放入并设置时间
  	 * @param key 键
  	 * @param value 值
  	 * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
  	 * @return true成功 false 失败
  	 */
  	public boolean set(String key,Object value,long time){
  		try {
  			if(time>0){
  				redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  			}else{
  				redisTemplate.opsForValue().set(key, value);
  			}
  			return true;
  		} catch (Exception e) {
  			e.printStackTrace();
  			return false;
  		}
  	}
  
  	/**
  	 * 递增
  	 * @param key 键
  	 * @param by 要增加几(大于0)
  	 * @return
  	 */
  	public long incr(String key, long delta){
  		if(delta<0){
  			throw new RuntimeException("递增因子必须大于0");
  		}
  		return redisTemplate.opsForValue().increment(key, delta);
  	}
  
  	/**
  	 * 递减
  	 * @param key 键
  	 * @param by 要减少几(小于0)
  	 * @return
  	 */
  	public long decr(String key, long delta){
  		if(delta<0){
  			throw new RuntimeException("递减因子必须大于0");
  		}
  		return redisTemplate.opsForValue().increment(key, -delta);
  	}
  
  	//================================Map=================================
  	/**
  	 * HashGet
  	 * @param key 键 不能为null
  	 * @param item 项 不能为null
  	 * @return 值
  	 */
  	public Object hget(String key,String item){
  		return redisTemplate.opsForHash().get(key, item);
  	}
  
  	/**
  	 * 获取hashKey对应的所有键值
  	 * @param key 键
  	 * @return 对应的多个键值
  	 */
  	public Map<Object,Object> hmget(String key){
  		return redisTemplate.opsForHash().entries(key);
  	}
  
  	/**
  	 * HashSet
  	 * @param key 键
  	 * @param map 对应多个键值
  	 * @return true 成功 false 失败
  	 */
  	public boolean hmset(String key, Map<String,Object> map){
  		try {
  			redisTemplate.opsForHash().putAll(key, map);
  			return true;
  		} catch (Exception e) {
  			e.printStackTrace();
  			return false;
  		}
  	}
  
  	/**
  	 * HashSet 并设置时间
  	 * @param key 键
  	 * @param map 对应多个键值
  	 * @param time 时间(秒)
  	 * @return true成功 false失败
  	 */
  	public boolean hmset(String key, Map<String,Object> map, long time){
  		try {
  			redisTemplate.opsForHash().putAll(key, map);
  			if(time>0){
  				expire(key, time);
  			}
  			return true;
  		} catch (Exception e) {
  			e.printStackTrace();
  			return false;
  		}
  	}
  
  	/**
  	 * 向一张hash表中放入数据,如果不存在将创建
  	 * @param key 键
  	 * @param item 项
  	 * @param value 值
  	 * @return true 成功 false失败
  	 */
  	public boolean hset(String key,String item,Object value) {
  		try {
  			redisTemplate.opsForHash().put(key, item, value);
  			return true;
  		} catch (Exception e) {
  			e.printStackTrace();
  			return false;
  		}
  	}
  
  	/**
  	 * 向一张hash表中放入数据,如果不存在将创建
  	 * @param key 键
  	 * @param item 项
  	 * @param value 值
  	 * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
  	 * @return true 成功 false失败
  	 */
  	public boolean hset(String key,String item,Object value,long time) {
  		try {
  			redisTemplate.opsForHash().put(key, item, value);
  			if(time>0){
  				expire(key, time);
  			}
  			return true;
  		} catch (Exception e) {
  			e.printStackTrace();
  			return false;
  		}
  	}
  
  	/**
  	 * 删除hash表中的值
  	 * @param key 键 不能为null
  	 * @param item 项 可以使多个 不能为null
  	 */
  	public void hdel(String key, Object... item){
  		redisTemplate.opsForHash().delete(key,item);
  	}
  
  	/**
  	 * 判断hash表中是否有该项的值
  	 * @param key 键 不能为null
  	 * @param item 项 不能为null
  	 * @return true 存在 false不存在
  	 */
  	public boolean hHasKey(String key, String item){
  		return redisTemplate.opsForHash().hasKey(key, item);
  	}
  
  	/**
  	 * hash递增 如果不存在,就会创建一个 并把新增后的值返回
  	 * @param key 键
  	 * @param item 项
  	 * @param by 要增加几(大于0)
  	 * @return
  	 */
  	public double hincr(String key, String item,double by){
  		return redisTemplate.opsForHash().increment(key, item, by);
  	}
  
  	/**
  	 * hash递减
  	 * @param key 键
  	 * @param item 项
  	 * @param by 要减少记(小于0)
  	 * @return
  	 */
  	public double hdecr(String key, String item,double by){
  		return redisTemplate.opsForHash().increment(key, item,-by);
  	}
  
  	//============================set=============================
  	/**
  	 * 根据key获取Set中的所有值
  	 * @param key 键
  	 * @return
  	 */
  	public Set<Object> sGet(String key){
  		try {
  			return redisTemplate.opsForSet().members(key);
  		} catch (Exception e) {
  			e.printStackTrace();
  			return null;
  		}
  	}
  
  	/**
  	 * 根据value从一个set中查询,是否存在
  	 * @param key 键
  	 * @param value 值
  	 * @return true 存在 false不存在
  	 */
  	public boolean sHasKey(String key,Object value){
  		try {
  			return redisTemplate.opsForSet().isMember(key, value);
  		} catch (Exception e) {
  			e.printStackTrace();
  			return false;
  		}
  	}
  
  	/**
  	 * 将数据放入set缓存
  	 * @param key 键
  	 * @param values 值 可以是多个
  	 * @return 成功个数
  	 */
  	public long sSet(String key, Object...values) {
  		try {
  			return redisTemplate.opsForSet().add(key, values);
  		} catch (Exception e) {
  			e.printStackTrace();
  			return 0;
  		}
  	}
  
  	/**
  	 * 将set数据放入缓存
  	 * @param key 键
  	 * @param time 时间(秒)
  	 * @param values 值 可以是多个
  	 * @return 成功个数
  	 */
  	public long sSetAndTime(String key,long time,Object...values) {
  		try {
  			Long count = redisTemplate.opsForSet().add(key, values);
  			if(time>0) {
  				expire(key, time);
  			}
  			return count;
  		} catch (Exception e) {
  			e.printStackTrace();
  			return 0;
  		}
  	}
  
  	/**
  	 * 获取set缓存的长度
  	 * @param key 键
  	 * @return
  	 */
  	public long sGetSetSize(String key){
  		try {
  			return redisTemplate.opsForSet().size(key);
  		} catch (Exception e) {
  			e.printStackTrace();
  			return 0;
  		}
  	}
  
  	/**
  	 * 移除值为value的
  	 * @param key 键
  	 * @param values 值 可以是多个
  	 * @return 移除的个数
  	 */
  	public long setRemove(String key, Object ...values) {
  		try {
  			Long count = redisTemplate.opsForSet().remove(key, values);
  			return count;
  		} catch (Exception e) {
  			e.printStackTrace();
  			return 0;
  		}
  	}
  	//===============================list=================================
  
  	/**
  	 * 获取list缓存的内容
  	 * @param key 键
  	 * @param start 开始
  	 * @param end 结束  0 到 -1代表所有值
  	 * @return
  	 */
  	public List<Object> lGet(String key,long start, long end){
  		try {
  			return redisTemplate.opsForList().range(key, start, end);
  		} catch (Exception e) {
  			e.printStackTrace();
  			return null;
  		}
  	}
  
  	/**
  	 * 获取list缓存的长度
  	 * @param key 键
  	 * @return
  	 */
  	public long lGetListSize(String key){
  		try {
  			return redisTemplate.opsForList().size(key);
  		} catch (Exception e) {
  			e.printStackTrace();
  			return 0;
  		}
  	}
  
  	/**
  	 * 通过索引 获取list中的值
  	 * @param key 键
  	 * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
  	 * @return
  	 */
  	public Object lGetIndex(String key,long index){
  		try {
  			return redisTemplate.opsForList().index(key, index);
  		} catch (Exception e) {
  			e.printStackTrace();
  			return null;
  		}
  	}
  
  	/**
  	 * 将list放入缓存
  	 * @param key 键
  	 * @param value 值
  	 * @param time 时间(秒)
  	 * @return
  	 */
  	public boolean lSet(String key, Object value) {
  		try {
  			redisTemplate.opsForList().rightPush(key, value);
  			return true;
  		} catch (Exception e) {
  			e.printStackTrace();
  			return false;
  		}
  	}
  
  	/**
  	 * 将list放入缓存
  	 * @param key 键
  	 * @param value 值
  	 * @param time 时间(秒)
  	 * @return
  	 */
  	public boolean lSet(String key, Object value, long time) {
  		try {
  			redisTemplate.opsForList().rightPush(key, value);
  			if (time > 0) expire(key, time);
  			return true;
  		} catch (Exception e) {
  			e.printStackTrace();
  			return false;
  		}
  	}
  
  	/**
  	 * 将list放入缓存
  	 * @param key 键
  	 * @param value 值
  	 * @param time 时间(秒)
  	 * @return
  	 */
  	public boolean lSet(String key, List<Object> value) {
  		try {
  			redisTemplate.opsForList().rightPushAll(key, value);
  			return true;
  		} catch (Exception e) {
  			e.printStackTrace();
  			return false;
  		}
  	}
  
  	/**
  	 * 将list放入缓存
  	 * @param key 键
  	 * @param value 值
  	 * @param time 时间(秒)
  	 * @return
  	 */
  	public boolean lSet(String key, List<Object> value, long time) {
  		try {
  			redisTemplate.opsForList().rightPushAll(key, value);
  			if (time > 0) expire(key, time);
  			return true;
  		} catch (Exception e) {
  			e.printStackTrace();
  			return false;
  		}
  	}
  
  	/**
  	 * 根据索引修改list中的某条数据
  	 * @param key 键
  	 * @param index 索引
  	 * @param value 值
  	 * @return
  	 */
  	public boolean lUpdateIndex(String key, long index,Object value) {
  		try {
  			redisTemplate.opsForList().set(key, index, value);
  			return true;
  		} catch (Exception e) {
  			e.printStackTrace();
  			return false;
  		}
  	}
  
  	/**
  	 * 移除N个值为value
  	 * @param key 键
  	 * @param count 移除多少个
  	 * @param value 值
  	 * @return 移除的个数
  	 */
  	public long lRemove(String key,long count,Object value) {
  		try {
  			Long remove = redisTemplate.opsForList().remove(key, count, value);
  			return remove;
  		} catch (Exception e) {
  			e.printStackTrace();
  			return 0;
  		}
  	}
  
  	public static void main(String[] args) {
  		/*JedisPool jedisPool = new JedisPool(null,"localhost",6379,100,"123456");
  		Jedis jedis = jedisPool.getResource();
  		//r.get("", RedisConstants.datebase4);
  		jedis.select(RedisConstants.datebase4);
  		Set<String> str =  jedis.keys("*");
  		for (String string : str) {
  			System.out.println(string);
  		}*/
  	}
  }
  

3.缓存对象

• application.yml

  spring:
    datasource:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/studentdb?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
      username: root
      password: root
    redis:
      host: 192.168.126.144
  ## 打印mybatis的日志
  logging:
    level:
      com.ddmzx.springboot_redis_student.mapper.*: debug
  ## 以调试的方式打印信息
  debug: true
  

• StudentServiceImpl.java

  package com.ddmzx.springboot_redis_student.service.impl;
  
  import com.alibaba.fastjson.JSON;
  import com.alibaba.fastjson.JSONObject;
  import com.ddmzx.springboot_redis_student.mapper.StudentMapper;
  import com.ddmzx.springboot_redis_student.pojo.Student;
  import com.ddmzx.springboot_redis_student.service.StudentService;
  import com.google.gson.Gson;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.data.redis.core.ValueOperations;
  import org.springframework.stereotype.Service;
  
  @Service
  public class StudentServiceImpl implements StudentService {
      @Autowired
      private RedisTemplate redisTemplate;
  
      @Autowired
      private StudentMapper studentMapper;
  
      @Override
      public Student findById(Integer id) {
  
          Student student = null;
          //查询之后一定要进行缓存
          String key = "student_"+id;
          if(redisTemplate.hasKey(key)){
              //存在键的话说明Redis中(内存/缓存)有数据
              //直接从Redis中获取就行了
              ValueOperations<String,Object> ops = redisTemplate.opsForValue();
              Gson gson = new Gson();
              student = gson.fromJson(ops.get(key).toString(),Student.class);
  
              //student = JSON.parseObject(ops.get(key).toString(),Student.class);
              //JSON.
              //JSONObject jsonObject = JSON.parseObject(ops.get(key).toString());
              //System.out.println(jsonObject);
              //student = (Student) jsonObject;
  
          }else{
              //缓存中没有从数据库中获取,获取完之后应该添加到缓存
              student = studentMapper.findById(id);
              redisTemplate.opsForValue().set(key,student);
          }
          return student;
      }
  }
  
  

• RedisConfig.java

  package com.ddmzx.springboot_redis_student.config;
  
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.data.redis.connection.RedisConnectionFactory;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  
  import java.net.UnknownHostException;
  
  @Configuration
  public class RedisConfig {
      //覆盖默认的自动配置
      @Bean
      public RedisTemplate<Object, Object> redisTemplate(
              RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
          RedisTemplate<Object, Object> template = new RedisTemplate<>();
          template.setConnectionFactory(redisConnectionFactory);
          //修改默认的序列化规则
          //1.创建序列化规则对象
          Jackson2JsonRedisSerializer jackson2JsonRedisSerializer=new Jackson2JsonRedisSerializer(Object.class);
          //2.更改默认的序列化规则
          template.setDefaultSerializer(jackson2JsonRedisSerializer);
          return template;
      }
  }
  

• Student.java

  package com.ddmzx.springboot_redis_student.pojo;
  
  import lombok.Data;
  
  import java.io.Serializable;
  
  @Data
  public class Student implements Serializable {
  
      private Integer id;
  
      private String name;
  
      private String sex;
  
      private Integer gradeId;
  }