8 分钟带你学会 SpringBoot 整合 Redis 来实现缓存技术

<!—配置 redis 依赖-->
 <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-data-redis</artifactId>            <version>2.1.5.RELEASE</version> </dependency> <dependency>            <groupId>org.apache.commons</groupId>            <artifactId>commons-pool2</artifactId>            <version>2.6.2</version>        </dependency>//依赖解释​Spring-data-redis提供了在Spring应用中通过简单的配置访问redis服务，RedisTemplate对reids底层开发包(Jedis, JRedis, and RJC,lettuce)进行了高度封装，封装了 RedisTemplate 对象来进行对Redis的各种操作、异常处理及序列化，支持发布订阅，并对Spring 3.1 cache进行了实现，它支持所有的Redis原生的 API。

    server:      port: 80    spring:      cache:        type: redis      redis:          # redis数据库索引(默认为0)，我们使用索引为3的数据库，避免和其他数据库冲突          #database: 3          # redis服务器地址（默认为loaclhost）          host: localhost          # redis端口（默认为6379）          port: 6379          # redis访问密码（默认为空）          #password: pwd123          # redis连接超时时间（单位毫秒）          timeout: 3000          # redis连接池配置          pool:            # 最大可用连接数（默认为8，负数表示无限）            max-active: 8            # 最大空闲连接数（默认为8，负数表示无限）            max-idle: 4            # 最小空闲连接数（默认为0，该值只有为正数才有用）            min-idle: 0            # 从连接池中获取连接最大等待时间（默认为-1，单位为毫秒，负数表示无限）            max-wait: -1

        @Configuration        public class RedisConfig {            /**             * 设置Redis序列化方式，默认使用的JDKSerializer的序列化方式，效率低，这里我们使用 jackson             *             * @param factory             * @return             */            @Bean            public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {                //创建模板类对象                RedisTemplate<String, Object> template = new RedisTemplate<>();                //创建String序列化类                RedisSerializer<String> redisSerializer = new StringRedisSerializer();                //指定使用jackson工具负责具体的序列化操作                Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);                //创建jackson的核心api的 ObjectMapper ,将bean,list,map,数组等等转成字符串                ObjectMapper om = new ObjectMapper();                //使用objectmapper设置bean的属性,修饰符                om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);                //设置默认类型                om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);                //设置将本地时间转成字符串                om.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);                //将核心api objectmapper设置给jackson                jackson2JsonRedisSerializer.setObjectMapper(om);                //通过工厂得到连接对象                template.setConnectionFactory(factory);                //设置key序列化方式: 转成字符串                template.setKeySerializer(redisSerializer);                //设置value序列化: 字符串                template.setValueSerializer(jackson2JsonRedisSerializer);                //value hashmap序列化                template.setHashValueSerializer(jackson2JsonRedisSerializer);                return template;            }                      //获取缓存管理器对象:管理缓存            @Bean            public CacheManager cacheManager(RedisConnectionFactory factory) {                RedisSerializer<String> redisSerializer = new StringRedisSerializer();                Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);                //解决查询缓存转换异常的问题                ObjectMapper om = new ObjectMapper();                om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);                om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);                jackson2JsonRedisSerializer.setObjectMapper(om);                // 配置序列化（解决乱码的问题）,过期时间600秒                RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()                        .entryTtl(Duration.ofSeconds(600))                        .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))                        .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))                        .disableCachingNullValues();                RedisCacheManager cacheManager = RedisCacheManager.builder(factory)                        .cacheDefaults(config)                        .build();                return cacheManager;            }
        }

-   步骤三: 可以测试
    在测试类里面,注入@RedisTemplate操作redis数据库.

        package com.user;
        import com.system.SpringApplicationConfig11;        import com.system.user.domain.User;        import org.junit.Test;        import org.junit.runner.RunWith;        import org.springframework.beans.factory.annotation.Autowired;        import org.springframework.boot.test.context.SpringBootTest;        import org.springframework.data.redis.core.ListOperations;        import org.springframework.data.redis.core.RedisTemplate;        import org.springframework.test.context.junit4.SpringRunner;        import org.springframework.util.StringUtils;
        import java.util.List;        import java.util.Set;
        @RunWith(SpringRunner.class)        @SpringBootTest(classes = {SpringApplicationConfig11.class})        public class DemoRedisTemplate {            @Autowired            private RedisTemplate<String, Object>  redisTemplate;            @Test// hash类型: key-value(key-value)就是map            public void testX9(){                redisTemplate.boundHashOps("myhash").put("username","jack");                redisTemplate.boundHashOps("myhash").put("password","1111");                Set<Object> myhash = redisTemplate.boundHashOps("myhash").keys();                System.out.println("获取map的所有key:");                for (Object key : myhash) {                    System.out.print(key+",");                }                System.out.println();                List<Object> myhash1 = redisTemplate.boundHashOps("myhash").values();                System.out.println("获取map的所有value");                for (Object value : myhash1) {                    System.out.print(value+",");                }                    System.out.println();            }            @Test//sortedset类型: redisTemplate            public void testX8(){                redisTemplate.boundZSetOps("myset2withscore").add("jack",10.0);                redisTemplate.boundZSetOps("myset2withscore").add("rose",9.0);                redisTemplate.boundZSetOps("myset2withscore").add("ship",20.0);                Set<Object> myset2withscore = redisTemplate.boundZSetOps("myset2withscore").range(0, -1);                for (Object o : myset2withscore) {                    System.out.println(o);                }            }            @Test//set类型:  redisTemplate            public void testX7(){                redisTemplate.boundSetOps("myset1noscore").add("jack");                redisTemplate.boundSetOps("myset1noscore").add("jack");                redisTemplate.boundSetOps("myset1noscore").add("rose");                Set<Object> myset1noscore = redisTemplate.boundSetOps("myset1noscore").members();                for (Object o : myset1noscore) {                    System.out.println(myset1noscore);                }
            }            @Test//list类型的数据: ListOperations            public void testX5(){                Boolean flag = redisTemplate.hasKey("mylist");//判断缓存数据库是否有这个key                System.out.println("mylist:"+flag);                Boolean flag2 = redisTemplate.hasKey("username");//判断缓存数据库是否有这个key                System.out.println("username:"+flag2);
            }            @Test//list类型的数据: RedisTemplate            public void testX6(){               redisTemplate.boundListOps("mylist").leftPush("jack");               redisTemplate.boundListOps("mylist").leftPush("rose");               redisTemplate.boundListOps("mylist").rightPush("ship");                List<Object> mylist = redisTemplate.boundListOps("mylist").range(0, -1);                for (Object o : mylist) {                    System.out.println(o);                }
            }            @Test//list类型的数据: ListOperations            public void testX4(){                redisTemplate.opsForList().leftPush("mylist","jack");                Object mylist = redisTemplate.opsForList().leftPop("mylist");                System.out.println(mylist);                //ListOperations<String, Object> operation= redisTemplate.opsForList();
            }
             @Test//操作string             public void testX(){                 redisTemplate.opsForValue().set("username","jack");//底层用的就是jedis                 Object username = redisTemplate.opsForValue().get("username");                 System.out.println(username);             }            @Test//操作string            public void testX2(){               redisTemplate.boundValueOps("username").set("rose");//向缓存中设置数据                Object username = redisTemplate.boundValueOps("username").get();                System.out.println(username);            }            @Test//操作string            public void testX3(){                 User user2 = new User(10L,"大马猴","dmh@sina.com","666","12");                //底层: 用指定的Jackson2JsonRedisSerializer的objectMapper将user转成json,设置到缓存中                 redisTemplate.boundValueOps("user").set(user2);
            }

        }

        1.  在添加方法中,执行完添加后,再次查询数据库,最终实现缓存的同步

                @CachePut(cacheNames = "listA" ,key="'aa'")                public List<User> addUser2(User user){                    //1.先添加                    userMapper.insert(user);                    //2.再查询                    List<User> users = userMapper.selectAll();                    return users;                }

1.  @CacheEvict: 直接清空缓存中的数据

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

    @SpringBootApplication    @MapperScan("com.dao")    @EnableCaching//开启缓存支持    public class SpringApplicationConfig {        public static void main(String[] args){            //自动扫描包, 自动装配,启动tomcat插件            SpringApplication.run(SpringApplicationConfig.class);        }    }

@Servicepublic class TestService {
@Autowiredprivate PersonRepo personRepo;
/**
*  @Cacheable 应用到读取数据的方法上，先从缓存中读取，如果没有再从 DB 获取数据，然后把数据添加到缓存中
*  unless 表示条件表达式成立的话不放入缓存
*/
@Cacheable(value = "user", key = "#root.targetClass + #username", unless = "#result eq null" , condition="") public Person getPersonByName(String username) {      Person person = personRepo.getPersonByName(username); return person;  }
/**

*  @CachePut 应用到写数据的方法上，如新增方法，调用方法时会自动把相应的数据放入缓存,同步更新缓存为什么没有更新缓存因为CachePut是方法运行完成之后然后再往缓存中放入数据，所以使用以下的方式进行操作这个是以方法的参数ID进行缓存操作,当然还可以使用下面这种方式进行操作。拿出返回值的id。在这里需要注意的一点是Cacheable的key是不能用#result取出对应的返回值的。*/
@CachePut(value = "user", key = "#person.id", unless = "#person eq null")  public Person savePerson(Person person) {
  return personRepo.savePerson(person);
}
/**
*  @CacheEvict 应用到删除或者修改数据的方法上，调用方法时会将指定key的缓存数据清空, 再次重新查询数据库
*/
@CacheEvict(value = "user", key = "#root.targetClass + #username", condition = "#result eq true")public boolean removePersonByName(String username) {        return  personRepo.removePersonByName(username) > 0;                                                    }
public boolean isExistPersonName(Person person) {     return personRepo.existPersonName(person) > 0;  
}

      @Cacheable(cacheNames = "listA",key = "'aa'")        public List<User> findUsers(){            List<User> list = userMapper.selectAll();            return list;        }    //源码(手动整合缓存的话,一般使用Ehcache)    //1.通过缓存管理器得到指定名称的缓存            Cache cache = cacheManager.getCache("listA");            //2.通过指定名称: 获取保存数据的缓存区域            Cache.ValueWrapper cacheValue = cache.get("aa");            if(cacheValue!=null){                //3.根据key从缓存中查询数据                //3.1 判断缓存中有没有数据                //3.2 缓存中有数据,说明不是第一次访问                Object o = cacheValue.get();                System.out.println(o);                System.out.println("将从缓存中拿出的数据响应到前台页面");
            }else{                //3.3 缓存中没有数据,说明是第一次访问,查询mysql的数据,存到缓存                List<User> users = userMapper.selectAll();                //3.4 将users集合转成json,存到缓存中                String json ="";                //将json存到缓存里面
            }

// @since 3.1  可以标注在方法上、类上  下同@Target({ElementType.METHOD, ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Inherited@Documentedpublic @interface Cacheable {//缓存查询 作用: 先查询缓存,没有再查询关系数据库存到缓存  // 缓存名称  可以写多个~  @AliasFor("cacheNames")  String[] value() default {};  @AliasFor("value")  String[] cacheNames() default {};
  // 支持写SpEL，切可以使用#root  String key() default "";  // Mutually exclusive：它和key属性互相排斥。请只使用一个  String keyGenerator() default "";
  String cacheManager() default "";  String cacheResolver() default "";
  // SpEL，可以使用#root。  只有true时，才会作用在这个方法上  String condition() default "";  // 可以写SpEL #root，并且可以使用#result拿到方法返回值~~~  String unless() default "";    // true：表示强制同步执行。（若多个线程试图为**同一个键**加载值，以同步的方式来进行目标方法的调用）  // 同步的好处是：后一个线程会读取到前一个缓存的缓存数据，不用再查库了~~~   // 默认是false，不开启同步one by one的  // @since 4.3  注意是sync而不是Async  // 它的解析依赖于Spring4.3提供的Cache.get(Object key, Callable<T> valueLoader);方法  boolean sync() default false;}

@Target({ElementType.METHOD, ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Inherited@Documentedpublic @interface CachePut {//缓存更新: 先查询数据库,然后更新缓存
  @AliasFor("cacheNames")  String[] value() default {};  @AliasFor("value")  String[] cacheNames() default {};
  // 注意：它和上面区别是。此处key它还能使用#result  String key() default "";  String keyGenerator() default "";
  String cacheManager() default "";  String cacheResolver() default "";
  String condition() default "";  String unless() default "";}
Target({ElementType.METHOD, ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Inherited@Documentedpublic @interface CacheEvict  {//缓存清除
  @AliasFor("cacheNames")  String[] value() default {};  @AliasFor("value")  String[] cacheNames() default {};
  // 它也能使用#result  String key() default "";  String keyGenerator() default "";
  String cacheManager() default "";  String cacheResolver() default "";  String condition() default "";
  // 是否把上面cacheNames指定的所有的缓存都清除掉，默认false  boolean allEntries() default false;  // 是否让清理缓存动作在目标方法之前执行，默认是false（在目标方法之后执行）  // 注意：若在之后执行的话，目标方法一旦抛出异常了，那缓存就清理不掉了~~~~  boolean beforeInvocation() default false;
}

@Component@Path("personMgr")public class PersonMgrResource {
@Autowiredprivate PersonService personService;
@GET@Path("getPersonByName")@Produces(MediaType.APPLICATION_JSON)public JsonResp getPersonByName(@QueryParam("username") String username) {       Person person = personService.getPersonByName(username);
  return JsonResp.success(person);
}
@POST@Path("removePersonByName")@Produces(MediaType.APPLICATION_JSON)public JsonResp removePersonByName(@QueryParam("username") String username) {          if(personService.removePersonByName(username)) {
    return JsonResp.success();
  }
  return JsonResp.fail("系统错误！");
}
@POST@Path("savePerson")@Produces(MediaType.APPLICATION_JSON)public JsonResp savePerson(Person person) {
  if (personService.isExistPersonName(person)) {                return JsonResp.fail("用户名已存在！");
    }
  if (personService.savePerson(person).getId() > 0) {            return   JsonResp.success();  }
  return JsonResp.fail("系统错误！");
  }
}