springboot 整合EHcache 实现分页缓存

一 简要概述

@Cacheable 对当前的对象做缓存处理

@Cacheable 作用：把方法的返回值添加到 Ehcache 中做缓存

@Cacheable （value=“xxx”，key="xxxx"）

Value 属性：指定一个 Ehcache 配置文件中的缓存策略，如果没有给定 value，那么则表示使用默认的缓存策略

key的作用：给存储的值起个名称，在查询时如果有名称相同时，则从已知的名称中取值。 否则重新查询数据库。

二 案例

2.1 工程结构

2.2 pom文件

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13</version>
      <scope>test</scope>
    </dependency>
    <!-- springBoot 的启动器 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- springBoot 的启动器 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <!-- springBoot 的启动器 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <!-- 测试工具的启动器 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
    <!-- mysql -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!-- druid连接池 -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.10</version>
    </dependency>
    <!-- Spring Boot 缓存支持启动器 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    <!-- Ehcache 坐标 -->
    <dependency>
      <groupId>net.sf.ehcache</groupId>
      <artifactId>ehcache</artifactId>
    </dependency>

2.3 dao

package com.ljf.spring.boot.demo.dao;

import com.ljf.spring.boot.demo.model.Users;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * 参数一 T :当前需要映射的实体
 * 参数二 ID :当前映射的实体中的OID的类型
 *
 */
public interface UserRepository extends JpaRepository<Users,Integer> {

}

2.4 model

package com.ljf.spring.boot.demo.model;

import javax.persistence.*;
import java.io.Serializable;

/**
 * @ClassName: Users
 * @Description: TODO
 * @Author: liujianfu
 * @Date: 2020/09/02 08:50:18 
 * @Version: V1.0
 **/
    @Entity
    @Table(name="tb_users_tb")
    public class Users implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;

    @Column(name = "name")
    private String name;

    @Column(name = "age")
    private Integer age;

    @Column(name = "address")
    private String address;


    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Users [id=" + id + ", name=" + name + ", age=" + age + ", address=" + address + "]";
    }
}

2.5 service

接口层：

package com.ljf.spring.boot.demo.service;

import com.ljf.spring.boot.demo.model.Users;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;

import java.util.List;

public interface UserService {
    List<Users> findUserAll();
    public Page<Users> findUserByPage(Pageable pageable );
}

实现层：

package com.ljf.spring.boot.demo.service.impl;

import com.ljf.spring.boot.demo.dao.UserRepository;
import com.ljf.spring.boot.demo.model.Users;
import com.ljf.spring.boot.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @ClassName: UserServiceImpl
 * @Description: TODO
 * @Author: liujianfu
 * @Date: 2020/09/02 08:57:11 
 * @Version: V1.0
 **/
@Service
public class UserServiceImpl  implements UserService {
    @Autowired
    private UserRepository userRepository;
    @Override
    //@Cacheable 对当前的对象做缓存处理
    //@Cacheable 作用：把方法的返回值添加到 Ehcache 中做缓存
    // Value 属性：指定一个 Ehcache 配置文件中的缓存策略，如果没有给定 value，那么则表示使用默认的缓存策略
    @Cacheable(value = "users")
    public List<Users> findUserAll() {
        return this.userRepository.findAll();
    }

   // @Cacheable(value="users",key="#pageable") //默认key的值为pageable
   // @Cacheable(value="users",key="#pageable.pageSize") //指定key的值为#pageable.pageSize
    public Page<Users> findUserByPage(Pageable pageable ){
        return this.userRepository.findAll(pageable);
    }

}

2.6 配置文件

1.application配置文件

#spring的配置mysql
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test_db?serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root
#ali
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.cache.ehcache.cofnig=ehcache.xml

2.ehcache缓存文件

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">

    <diskStore path="java.io.tmpdir"/>

  <!--defaultCache:echcache的默认缓存策略  -->
    <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            maxElementsOnDisk="10000000"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
        <persistence strategy="localTempSwap"/>
    </defaultCache>
    <!-- 自定义缓存策略 -->
    <cache name="users"
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            maxElementsOnDisk="10000000"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
        <persistence strategy="localTempSwap"/>
    </cache>
</ehcache>

2.7 启动类

package com.ljf.spring.boot.demo;

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

/**
 * Hello world!
 *
 */
@SpringBootApplication
@EnableCaching
public class StartApp
{
    public static void main( String[] args )
    {
        SpringApplication.run(StartApp.class, args);
        System.out.println( "Hello World!" );

    }
}

2.8 测试类

    @Test
    public void queryByPage(){
        Pageable pageable= PageRequest.of(0, 10);
        Page<Users> list=us.findUserByPage(pageable);
        System.out.println("第1次:"+list.getContent().get(0).getAddress());
        Page<Users> list2=us.findUserByPage(pageable);
        System.out.println("第2次:"+list2.getContent().get(0).getAddress());
         pageable= PageRequest.of(0, 5);
        Page<Users> list3=us.findUserByPage(pageable);
        System.out.println("第3次:"+list3.getContent().get(0).getAddress());
    }

不加缓存，查询执行了3次查询数据库

2.9 添加缓存

在分页的方法上假如缓存，已分页的pageable作为key

通过执行结果看到：第一次执行查询数据库，第二次查询内存，当分页pageable= PageRequest.of(0, 10);改为pageable= PageRequest.of(0, 5);，再次执行时，重新查询数据库