springboot cache缓存之访问数据库（以mysql为例）
本文给出了springboot cache缓存在访问数据库中的应用，首先给出了缓存的概念、适用场景，然后给出了完整的java程序和代码注释，最后指出了使用springboot cache常见的问题和解决方案。写下此文为了记录下最近研究springboot cache遇到的坑和解决方案，也希望能够对其他的初学者有一些帮助。
什么是缓存cache？
外存：可以简单的理解为电脑上的CDEF盘和U盘；此类储存器一般断电后仍然能保存数据。
内存：内存(Memory)也被称为内存储器，其作用是用于暂时存放CPU中的运算数据，以及与硬盘等外部存储器交换的数据。只要计算机在运行中，CPU就会把需要运算的数据调到内存中进行运算，当运算完成后CPU再将结果传送出来，一般断电后数据就会被清空。
高速缓存cache：高速缓存是用来协调CPU与主存之间的差异而设置的。一般情况下，CPU的工作速度高，但内存的工作速度相对较低，为了解决这个问题，通常使用高速缓存，高速缓存的存取速度介于CPU和主存之间。系统将一些CPU在近几个时间段经常访问的内容存入高速缓冲，当CPU需要使用数据时，先在高速缓存中找，如果找到，就不必访问内存了，找不到时，再找内存，这样就在一定程度上缓解了由于主存速度低造成的CPU“停工待料”的情况
java程序中什么情况下需要用到缓存cache？
java程序的性能在很多情况下会受制于数据库的访问，这是因为访问数据库是一个很耗时的操作。但是高速缓存cache的访问速度是非常快的，因此为了提高java程序的执行效率，一些频繁访问且一般来说不会变化的数据会被放置在缓存中，而非访问数据库。
springboot缓存注解
缓存注解一般写在service层的方法上，在本文的例子中是使用@Cacheable注解在UserServiceImpl类中queryAllPerson方法上来声明改方法中读取数据库表person所有row缓存在内存中（即首次select * from person时访问数据库，之后使用缓存来代替访问耗时的数据库访问）。
完整的java程序和相关配置
首先在springboot配置文件application.properties添加数据库的相关配置信息。
# 日志中打印所执行的sql查询语句
spring.jpa.show-sql=true
spring.jpa.database = MYSQL
spring.datasource.url=jdbc:mysql://localhost:3306/alex?useSSL=false
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
/**
* 定义object relationship mapping
* 即java类和数据库table的对应关系
* @Entity申明此类是一个实体类
* @Table声明表的对应关系
* 注意@Id是javax.persistence.Id
* */
package com.example.cache;
//import org.springframework.data.annotation.Id;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "person")
public class Person {
// @Id注解必须要有，否则编译时会报错找不到identifier（Caused by: org.hibernate.AnnotationException: No identifier specified for entity: com.example.dbaccess.Person）
// 被@Id注解的成员变量对应着table的主键，且被@Id注解的成员变量的数据类型必须和UserRepository的JpaRepository中的ID一致，但是可以和table中对应的字段数据类型不同（比如person表中的id字段就是int类型）。其中第一个参数是bean类，第二个参数是ID
// @GeneratedValue(strategy=GenerationType.AUTO)
// @GeneratedValue和@Id配合使用，用于指定主键生成的方式，不显式声明的情况下默认是AUTO，即jpa自动选择。
@Id
private Integer id;
private String name;
private Integer age;
private Boolean gender;
/**
* java教程中：强调写了有参数的构造方法就最好加一个无参数的构造方法.
* 但是springboot教程中：当声明了有参的构造方法的话，必须显式地声明无参的构造方法否则报如下错误：
* No default constructor for entity: : com.example.dbaccess.Person; nested exception is org.hibernate.InstantiationException: No default constructor for entity: :
*
* */
// 有参构造方法
public Person(Integer id, String name, Integer age, boolean gender) {
this.id = id;
this.name = name;
this.age = age;
this.gender = gender;
}
// 无参构造方法
public Person() {
}
public int getId() {
return id;
}
public void setId(int id) { this.id = id; }
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public boolean isGender() {
return gender;
}
public void setGender(boolean gender) {
this.gender = gender;
}
@Override
public String toString() {
return String.format("{person:{id:%s, name=%s, age=%s, gender=%s}}", id, name, age, gender);
//return "person.tostring";
}
}
/**
* dao/repository层
* 对数据库进行操作的代码
* 由于我们导入了JPA依赖，很多通常的查询，删除，更新等操作可以不用在此编写
* @Repository注解是告诉Spring Boot这是一个仓库类，会在启动的时候帮你自动注入(查询，删除，更新等操作的代码，比如jdbc)。
* JpaRepository里面含有一般数据库操作所需要的接口，我们会在service层中调用他们
* */
package com.example.cache;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface UserRepository extends JpaRepository<Person, Integer> {
// 其中Person是与数据库表person对应的entity类，Integer是@Id注解的主键列
// Spring Data Jpa 默认实现时hibernate，我们都知道hibernate使用HQL查询（Hibernate时JPA的实现之一），
// 而不推荐使用sql查询，因为这样子就跟具体数据库耦合了。
// 但是如果需要使用原生的sql查询语句就需要将nativeQuery设置为true（默认是false）。
// @Query--执行sql语句并将结果作为被@Query注解的方法return的内容
@Query(value = "select name from person", nativeQuery = true)
List<String> queryAllName();
@Query(value = "select * from person", nativeQuery = true)
List<Person> queryAllPerson();
}
/**
* service层：主要负责业务逻辑处理
* 在此处我们编写了一个接口和一个实现类。
* 接口的设计是为了满足松耦合的需求。
*
* */
package com.example.cache;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public interface UserService {
List<Person> getAll();
List<String> queryAllName();
List<Person> queryAllPerson(String key);
}
/**
* service层：主要负责业务逻辑处理
* */
package com.example.cache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserServiceImpl implements UserService {
@Autowired
UserRepository userRepository;
@Override
public List<Person> getAll() {
return userRepository.findAll();
}
@Override
public List<String> queryAllName() {
return userRepository.queryAllName();
}
// 缓存cache注解
@Cacheable(cacheNames = "queryPerson", key = "'user_'.concat(#a0)")
@Override
public List<Person> queryAllPerson(String key) {
System.out.println(">>>> queryPerson executed.");
return userRepository.queryAllPerson();
}
public void delById(int id){
userRepository.deleteById(id);
}
public void addRecord(Person person){
userRepository.save(person);
}
}
/**
* 编写Control层
* 此层主要进行对页面的处理（和页面有mapping），包括跳转或者传参等等。
* */
package com.example.cache;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.bind.annotation.*;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
@Configuration
@RestController
@RequestMapping("controller")
public class UserController implements Serializable {
private static Logger logger = LoggerFactory.getLogger(UserController.class);
@Autowired
private UserServiceImpl userServiceImpl;
@RequestMapping("/name")
@ResponseBody
private List<Person> getNames(){
List<String> nameArr = new ArrayList<>();
List<Person> personArr = new ArrayList<>();
for (Person person: userServiceImpl.getAll()){
String name = person.getName();
//logger.info(">>>>>> name is: " + name);
nameArr.add(name);
personArr.add(person);
}
System.out.println(">>>>>> execute method.");
return personArr;
}
/**
* 注意：class和method上面都需要@RequestMapping标注，这样访问的网址是：
* localhost:port/controller/name
* 其中host默认是8080，如果在application.properties中修改了server.port，则以配置文件为准
* */
@RequestMapping("/del")
private String delRecord(@RequestParam("id") int id){
userServiceImpl.delById(id);
return String.format(">>>>>> record (id=%s) deleted.", id);
}
@RequestMapping(value = "/add", method = RequestMethod.GET)
private String addRecord(@RequestParam(name="id", required = true) Integer id, @RequestParam(name="name",required=false) String name, @RequestParam(name="age",required=false) Integer age, @RequestParam(name="gender",required=false) Boolean gender) {
userServiceImpl.addRecord(new Person(id, name, age, gender));
System.out.println(">>>>>> execute method.");
return String.format(">>>>>> record (id=%s, name=%s, age=%s, gender=%s) added.", id, name, age, gender);
//return "add succeed.";
}
@ResponseBody
@RequestMapping(value = "/query", method = RequestMethod.GET)
private List<String> queryAllNames(){
return userServiceImpl.queryAllName();
}
@ResponseBody
@RequestMapping(value = "/queryPerson", method = RequestMethod.GET)
private List<Person> queryAllPersons(){
return userServiceImpl.queryAllPerson("queryP");
}
}
/**
* 主类
* */
package com.example.cache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
@EnableCaching // 开启缓存
public class UserMain {
@Autowired
private UserController controller;
public static void main(String[] args){
SpringApplication.run(UserMain.class);
}
}
程序执行结果
step 1. 在web端发起读取mysql中person表所有row的请求
console中打印显示执行了一次读取数据库的操作
>>>> queryPerson executed.
Hibernate: select * from person
step 2. 刷新页面以再次发起同样的请求
此时console中并没有打印新的sql，如下图所示：
>>>> queryPerson executed.
Hibernate: select * from person
因此可以看出当web端第2、3…次发起请求后，web server端并没有再次去访问数据库而是从cache中读取了之前缓存的结果并返回到web端。
使用springboot cache常见问题和解决方案：
// 会出错的写法，引用 参数 name作为Cache的key。
@Cacheable(cachnames="user", key="#name")
public User findByName(String name);
报错信息：java.lang.IllegalArgumentException: Null key returned for cache operation (maybe you are using named params on classes without debug info......
原因分析：上述代自定义了Key，因此Key generator不起效，它会用SpEL来把 name 这个参数作为Key。这是官网教程的例子，为什么会行不通呢？再反复斟酌官网教程，终于明白它说什么了，就是如果编译没选debug模式，编译出来的class文件是没有参数名的信息的，那么反射机制来获取这个参数的值，就找不到参数名字！只能用 #a0或者#p0来指代第一个参数，依此类推。（If for some reason the names are not available (e.g. no debug information), the argument names are also available under the #a<#arg> where #arg stands for the argument index (starting from 0).）
正确的万能写法，这里把 user_ 作为 key的前缀，传参 name作为后缀。
@Cacheable(cachnames=“user”, key="‘user_’.concat(#a0)")
public User findByName(String name);
关于原因分析：参考了大神的博客，https://www.jianshu.com/p/6196dd5870c7.
如有错误敬请大神指正！