@Cacheable 对当前的对象做缓存处理
@Cacheable 作用：把方法的返回值添加到 Ehcache 中做缓存
@Cacheable （value=“xxx”，key="xxxx"）
Value 属性：指定一个 Ehcache 配置文件中的缓存策略，如果没有给定 value，那么则表示使用默认的缓存策略
key的作用：给存储的值起个名称，在查询时如果有名称相同时，则从已知的名称中取值。 否则重新查询数据库。
<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>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> {
}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 + "]";
}
}
接口层：
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);
}
}
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.xml2.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>
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!" );
}
}
@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次查询数据库
在分页的方法上假如缓存，已分页的pageable作为key
通过执行结果看到：第一次执行查询数据库，第二次查询内存，当分页pageable= PageRequest.of(0, 10);改为pageable= PageRequest.of(0, 5);，再次执行时，重新查询数据库
