springboot(五)-使用Redis

Redis服务器

springboot要使用redis,首先当然要确保redis服务器能够正常跑起来。

pom.xml

这里添加redis的依赖，当然也是springboot集成好的。

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

application.properties

增加redis相关配置
同时让hibernate的sql语句显示出来，这样才知道到底是通过 Redis 取到的数据，还是依然是从数据库取到的数据

 spring.mvc.view.prefix=/WEB-INF/jsp/
 spring.mvc.view.suffix=.jsp
 spring.datasource.url=jdbc:mysql://127.0.0.1:3306/how2java?characterEncoding=UTF-8
 spring.datasource.username=root
 spring.datasource.password=admin
 spring.datasource.driver-class-name=com.mysql.jdbc.Driver
 spring.jpa.properties.hibernate.hbm2ddl.auto=update

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

 spring.jpa.show-sql=true

Application.java

增加注解，以开启缓存

@EnableCaching

 package com.how2java.springboot;

 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.cache.annotation.EnableCaching;

 @SpringBootApplication
 @EnableCaching
 public class Application {

     public static void main(String[] args) {
         SpringApplication.run(Application.class, args);
     }

 }

RedisConfig.java

Redis 缓存配置类。
这个配置，一个作用： 让保存到 Redis 里的 key 和 value 都转换为可读的 json 格式。 否则会是二进制格式，通过RedisClient 工具也无法识别。

 package com.how2java.springboot.config;
 import org.springframework.cache.CacheManager;
 import org.springframework.cache.annotation.CachingConfigurerSupport;
 import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.redis.cache.RedisCacheManager;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
 import org.springframework.data.redis.serializer.RedisSerializer;
 import org.springframework.data.redis.serializer.StringRedisSerializer;

 import com.fasterxml.jackson.annotation.JsonAutoDetect;
 import com.fasterxml.jackson.annotation.PropertyAccessor;
 import com.fasterxml.jackson.databind.ObjectMapper;

 @Configuration
 @EnableCaching
 //Redis 缓存配置类
 public class RedisConfig extends CachingConfigurerSupport {

     @Bean
     public CacheManager cacheManager(RedisTemplate<?,?> redisTemplate) {
         RedisSerializer stringSerializer = new StringRedisSerializer();
         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
         ObjectMapper om = new ObjectMapper();
         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.PUBLIC_ONLY);
         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
         jackson2JsonRedisSerializer.setObjectMapper(om);
         redisTemplate.setKeySerializer(stringSerializer);
         redisTemplate.setHashKeySerializer(stringSerializer);  

         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
         CacheManager cacheManager = new RedisCacheManager(redisTemplate);
         return cacheManager;

     }
 }

点击展开

Page4Navigator

创建一个工具类 Page4Navigator 用以替换 原本分页查询要返回的 org.springframework.data.domain.Page 类。 原因是 Page 类对json 还原不支持，在放如 Redis 之后，再拿出来，就会报错失败。
使用 Page4Navigator 对其包裹，就解决了这个问题了。

 package com.how2java.springboot.util;

 import java.util.List;

 import org.springframework.data.domain.Page;

 public class Page4Navigator<T> {
     Page<T> page4jpa;
     int navigatePages;

     int totalPages;

     int number;

     long totalElements;

     int size;

     int numberOfElements;

     List<T> content;

     boolean isHasContent;

     boolean first;

     boolean last;

     boolean isHasNext;

     boolean isHasPrevious;

     int[] navigatepageNums;

     public Page4Navigator() {
         //这个空的分页是为了 Redis 从 json格式转换为 Page4Navigator 对象而专门提供的
     }

     public Page4Navigator(Page<T> page4jpa,int navigatePages) {
         this.page4jpa = page4jpa;
         this.navigatePages = navigatePages;

         totalPages = page4jpa.getTotalPages();

         number  = page4jpa.getNumber() ;

         totalElements = page4jpa.getTotalElements();

         size = page4jpa.getSize();

         numberOfElements = page4jpa.getNumberOfElements();

         content = page4jpa.getContent();

         isHasContent = page4jpa.hasContent();

         first = page4jpa.isFirst();

         last = page4jpa.isLast();

         isHasNext = page4jpa.hasNext();

         isHasPrevious  = page4jpa.hasPrevious();       

         calcNavigatepageNums();

     }

     private void calcNavigatepageNums() {
         int navigatepageNums[];
         int totalPages = getTotalPages();
         int num = getNumber();
         //当总页数小于或等于导航页码数时
         if (totalPages <= navigatePages) {
             navigatepageNums = new int[totalPages];
             for (int i = 0; i < totalPages; i++) {
                 navigatepageNums[i] = i + 1;
             }
         } else { //当总页数大于导航页码数时
             navigatepageNums = new int[navigatePages];
             int startNum = num - navigatePages / 2;
             int endNum = num + navigatePages / 2;

             if (startNum < 1) {
                 startNum = 1;
                 //(最前navigatePages页
                 for (int i = 0; i < navigatePages; i++) {
                     navigatepageNums[i] = startNum++;
                 }
             } else if (endNum > totalPages) {
                 endNum = totalPages;
                 //最后navigatePages页
                 for (int i = navigatePages - 1; i >= 0; i--) {
                     navigatepageNums[i] = endNum--;
                 }
             } else {
                 //所有中间页
                 for (int i = 0; i < navigatePages; i++) {
                     navigatepageNums[i] = startNum++;
                 }
             }
         }
         this.navigatepageNums = navigatepageNums;
     }

     public int getNavigatePages() {
         return navigatePages;
     }

     public void setNavigatePages(int navigatePages) {
         this.navigatePages = navigatePages;
     }

     public int getTotalPages() {
         return totalPages;
     }

     public void setTotalPages(int totalPages) {
         this.totalPages = totalPages;
     }

     public int getNumber() {
         return number;
     }

     public void setNumber(int number) {
         this.number = number;
     }

     public long getTotalElements() {
         return totalElements;
     }

     public void setTotalElements(long totalElements) {
         this.totalElements = totalElements;
     }

     public int getSize() {
         return size;
     }

     public void setSize(int size) {
         this.size = size;
     }

     public int getNumberOfElements() {
         return numberOfElements;
     }

     public void setNumberOfElements(int numberOfElements) {
         this.numberOfElements = numberOfElements;
     }

     public List<T> getContent() {
         return content;
     }

     public void setContent(List<T> content) {
         this.content = content;
     }

     public boolean isHasContent() {
         return isHasContent;
     }

     public void setHasContent(boolean isHasContent) {
         this.isHasContent = isHasContent;
     }

     public boolean isFirst() {
         return first;
     }

     public void setFirst(boolean first) {
         this.first = first;
     }

     public boolean isLast() {
         return last;
     }

     public void setLast(boolean last) {
         this.last = last;
     }

     public boolean isHasNext() {
         return isHasNext;
     }

     public void setHasNext(boolean isHasNext) {
         this.isHasNext = isHasNext;
     }

     public boolean isHasPrevious() {
         return isHasPrevious;
     }

     public void setHasPrevious(boolean isHasPrevious) {
         this.isHasPrevious = isHasPrevious;
     }

     public int[] getNavigatepageNums() {
         return navigatepageNums;
     }

     public void setNavigatepageNums(int[] navigatepageNums) {
         this.navigatepageNums = navigatepageNums;
     }

 }

点击展开

CategoryService

增加 Service接口。 注意： list 返回的是 Page4Navigator 而不再是 Page 类型了。

 package com.how2java.springboot.service;

 import org.springframework.data.domain.Pageable;

 import com.how2java.springboot.pojo.Category;
 import com.how2java.springboot.util.Page4Navigator;

 public interface CategoryService {

     public Page4Navigator<Category> list(Pageable pageable);

     public void save(Category category);

     public void delete(int id);

     public Category get(int id);
 }

CategoryServiceImpl

实现类CategoryServiceImp 做了一下工作：
1. 实现 CategoryService 接口，提供 crud

2. 在相应方法实现的时候，都是通过调用 dao 实现的

3. CacheConfig，表示 分类数据在 redis 中都放在 category 这个分组里。

@CacheConfig(cacheNames="category")

4. list方法讲解：
先说注解

@Cacheable(key="'category '+#p0.offset + '-' + #p0.pageSize ")

假如是第一页，即offset=0，pageSize=0，那么会创建一个 key: "category 0-5"
首先根据这个key 到 redis中查询数据。 第一次是不会有数据的，那么就会从数据库中取到这5条数据，然后以这个 key: "category 0-5" 保存到 redis 数据库中。
下一次再次访问的时候，根据这个key，就可以从 redis 里取到数据了。

5. get 方法讲解
先说注解：

@Cacheable(key="'category '+ #p0")

假如是获取id=71的数据，那么
就会以 key= "category 71" 到reids中去获取，如果没有就会从数据库中拿到，然后再以 key= "category 71" 这个值存放到 redis 当中。
下一次再次访问的时候，根据这个key，就可以从 redis 里取到数据了。

6. add 方法讲解
先说注解：

@CacheEvict(allEntries=true)

// @CachePut(key="'category '+ #p0")

可以看到，本来有个 CachePut，但是被注释掉了。 按理说，本来是应该用这个的。 这样会到在，在增加数据之后，就会在Redis 中以 key= "category 71" 缓存一条数据。 但是为什么被注释掉不用呢？ 
因为加入这样做了，那么 list 对应的数据，在缓存在对应的数据，并没有发生变化呀？ 因为 list 对应的数据是这样的 key: "category 0-5"。 如果用这种方式，就会导致数据不同步，即，虽然增加了，并且也增加到缓存中了，但是因为 key 不一样，通过查询拿到的数据，是不会包含新的这一条的。 
所以，才会使用CacheEvict 这个注解，这个注解就表示清除掉缓存。 allEntries= true 是表示清除掉 category 分组 下所有的keys. 注意看截图，里面有一个 category~keys ，里面就表明了都有哪些 keys,都会被清除掉。 
假如这个时候，还有一个分组 cacheNames="product", 那么它下面对应的缓存，都是不会被影响到的。 这样就保证了，只清楚当前分组下的缓存，而不是清除 redis 所有的数据了。

7. delete 方法讲解
先说注解：

@CacheEvict(allEntries=true)

// @CacheEvict(key="'category '+ #p0")

这个道理和 add 是一样的，仅仅删除 key= "category 71" ，没有什么意义， key: "category 0-5" 里面的数据没有影响呀。 所以还是通过 CacheEvict删除掉所有的缓存就好了。

 package com.how2java.springboot.service.impl;

 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.cache.annotation.CacheConfig;
 import org.springframework.cache.annotation.CacheEvict;
 import org.springframework.cache.annotation.CachePut;
 import org.springframework.cache.annotation.Cacheable;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;

 import com.how2java.springboot.dao.CategoryDAO;
 import com.how2java.springboot.pojo.Category;
 import com.how2java.springboot.service.CategoryService;
 import com.how2java.springboot.util.Page4Navigator;

 @Service
 @CacheConfig(cacheNames="category")
 public class CategoryServiceImpl implements CategoryService{

     @Autowired CategoryDAO categoryDAO;

     @Override
     @Cacheable(key="'category '+#p0.offset + '-' + #p0.pageSize ")
     public Page4Navigator<Category> list(Pageable pageable) {
         Page<Category> pageFromJPA=  categoryDAO.findAll(pageable);
         Page4Navigator<Category> page = new Page4Navigator<>(pageFromJPA,5);
         return page;
     }

     @Override
     @Cacheable(key="'category '+ #p0")
     public Category get(int id) {
         Category c =categoryDAO.findOne(id);
         return c;
     }  

     @Override
     @CacheEvict(allEntries=true)
 //  @CachePut(key="'category '+ #p0")
     public void save(Category category) {
         // TODO Auto-generated method stub
         categoryDAO.save(category);
     }

     @Override
     @CacheEvict(allEntries=true)
 //  @CacheEvict(key="'category '+ #p0")
     public void delete(int id) {
         // TODO Auto-generated method stub
         categoryDAO.delete(id);
     }

 }

点击展开

CategoryController

 package com.how2java.springboot.web;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;

 import com.how2java.springboot.pojo.Category;
 import com.how2java.springboot.service.CategoryService;
 import com.how2java.springboot.util.Page4Navigator;

 @Controller
 public class CategoryController {
     @Autowired CategoryService categoryService;

     @RequestMapping("/listCategory")

     public String listCategory(Model m,@RequestParam(value = "start", defaultValue = "0") int start,@RequestParam(value = "size", defaultValue = "5") int size) throws Exception {
         start = start<0?0:start;
         Sort sort = new Sort(Sort.Direction.DESC, "id");
         Pageable pageable = new PageRequest(start, size, sort);
         Page4Navigator<Category> page =categoryService.list(pageable);
         m.addAttribute("page", page);
         return "listCategory";
     }

     @RequestMapping("/addCategory")
     public String addCategory(Category c) throws Exception {
         categoryService.save(c);
         return "redirect:listCategory";
     }
     @RequestMapping("/deleteCategory")
     public String deleteCategory(Category c) throws Exception {
         categoryService.delete(c.getId());
         return "redirect:listCategory";
     }
     @RequestMapping("/updateCategory")
     public String updateCategory(Category c) throws Exception {
         categoryService.save(c);
         return "redirect:listCategory";
     }
     @RequestMapping("/editCategory")
     public String ediitCategory(int id,Model m) throws Exception {
         Category c= categoryService.get(id);
         m.addAttribute("c", c);
         return "editCategory";
     }
 }

运行

我们来看运行结果。

1.向上面一样，打开redis服务器。

2.打开redis客户端，并建立连接。

就是这个，安装这个可以很清晰的看到redis里面的值。

运行springboot工程，访问http://127.0.0.1:8080/listCategory?start=0

在控制台上你会看到这个：

Hibernate: select category0_.id as id1_0_, category0_.name as name2_0_ from category_ category0_ order by category0_.id desc limit ?
Hibernate: select count(category0_.id) as col_0_0_ from category_ category0_

第一次访问，需要查询数据库。然后再看redis客户端：

我这里用的是db2,上面application.properties代码里是db0.这个可以随便该，每个项目用一个嘛。

第一次查询的内容保存到redis里面了。然后你刷新下页面，也就是再访问一次，控制台就没有打印sql语句了。

好了，你现在多点几次下一页，目的是给redis缓存多一点数据。

你在下面添加一条数据。

控制台打印三条sql语句

Hibernate: insert into category_ (name) values (?)
Hibernate: select category0_.id as id1_0_, category0_.name as name2_0_ from category_ category0_ order by category0_.id desc limit ?
Hibernate: select count(category0_.id) as col_0_0_ from category_ category0_

很明显的呀，一条插入，两条查询。这两条查询语句对应着第一页记录。

这时候再看redis客户端：

这就说明，我们在修改数据之后，redis中的数据就清空了。实现了我们想要的结果。

---

代码下载地址：https://gitee.com/fengyuduke/my_open_resources/blob/master/springboot-redis.zip