java application缓存_SpringBoot2.x系列教程57--SpringBoot中默认缓存实现方案

SpringBoot2.x系列教程57--SpringBoot中默认缓存实现方案

作者：一一哥

在上一节中，我带大家学习了在Spring Boot中对缓存的实现方案，尤其是结合Spring Cache的注解的实现方案，接下来在本章节中，我带大家通过代码来实现。

一. Spring Boot实现默认缓存

1. 创建web项目

我们按照之前的经验，创建一个web程序，并将之改造成Spring Boot项目，具体过程略。

2. 添加依赖包

org.springframework.boot

spring-boot-starter-data-jpa

mysql

mysql-connector-java

org.springframework.boot

spring-boot-starter-cache

3. 创建application.yml配置文件

server:

port: 8080

spring:

application:

name: cache-demo

datasource:

driver-class-name: com.mysql.cj.jdbc.Driver

username: root

password: syc

url: jdbc:mysql://localhost:3306/spring-security?useUnicode=true&characterEncoding=utf8&characterSetResults=utf8&useSSL=false&serverTimezone=UTC

#cache:

#type: generic #由redis进行缓存,一共有10种缓存方案

jpa:

database: mysql

show-sql: true #开发阶段,打印要执行的sql语句.

hibernate:

ddl-auto: update

4. 创建一个缓存配置类

主要是在该类上添加@EnableCaching注解，开启缓存功能。

package com.yyg.boot.config;

import org.springframework.cache.annotation.EnableCaching;

/**

* @Author 一一哥Sun

* @Date Created in 2020/4/14

* @Description Description

* EnableCaching启用缓存

*/

@Configuration

@EnableCaching

public class CacheConfig {

}

5. 创建User实体类

package com.yyg.boot.domain;

import lombok.Data;

import lombok.ToString;

import javax.persistence.*;

import java.io.Serializable;

@Entity

@Table(name="user")

@Data

@ToString

public class User implements Serializable {

//IllegalArgumentException: DefaultSerializer requires a Serializable payload

// but received an object of type [com.syc.redis.domain.User]

@Id

@GeneratedValue(strategy = GenerationType.AUTO)

private Long id;

@Column

private String username;

@Column

private String password;

}

6. 创建User仓库类

package com.yyg.boot.repository;

import com.yyg.boot.domain.User;

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository {

}

7. 创建Service服务类

定义UserService接口

package com.yyg.boot.service;

import com.yyg.boot.domain.User;

public interface UserService {

User findById(Long id);

User save(User user);

void deleteById(Long id);

}

实现UserServiceImpl类

package com.yyg.boot.service.impl;

import com.yyg.boot.domain.User;

import com.yyg.boot.repository.UserRepository;

import com.yyg.boot.service.UserService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.cache.annotation.CacheEvict;

import org.springframework.cache.annotation.CachePut;

import org.springframework.cache.annotation.Cacheable;

import org.springframework.stereotype.Service;

@Service

public class UserServiceImpl implements UserService {

@Autowired

private UserRepository userRepository;

//普通的缓存+数据库查询代码实现逻辑:

//User user=RedisUtil.get(key);

// if(user==null){

// user=userDao.findById(id);

// //redis的key="product_item_"+id

// RedisUtil.set(key,user);

// }

// return user;

/**

* 注解@Cacheable:查询的时候才使用该注解!

* 注意:在Cacheable注解中支持EL表达式

* redis缓存的key=user_1/2/3....

* redis的缓存雪崩,缓存穿透,缓存预热,缓存更新...

* condition = "#result ne null",条件表达式,当满足某个条件的时候才进行缓存

* unless = "#result eq null":当user对象为空的时候,不进行缓存

*/

@Cacheable(value = "user", key = "#id", unless = "#result eq null")

@Override

public User findById(Long id) {

return userRepository.findById(id).orElse(null);

}

/**

* 注解@CachePut:一般用在添加和修改方法中

* 既往数据库中添加一个新的对象,于此同时也往redis缓存中添加一个对应的缓存.

* 这样可以达到缓存预热的目的.

*/

@CachePut(value = "user", key = "#result.id", unless = "#result eq null")

@Override

public User save(User user) {

return userRepository.save(user);

}

/**

* CacheEvict:一般用在删除方法中

*/

@CacheEvict(value = "user", key = "#id")

@Override

public void deleteById(Long id) {

userRepository.deleteById(id);

}

}

8. 创建Controller接口方法

package com.yyg.boot.web;

import com.yyg.boot.domain.User;

import com.yyg.boot.service.UserService;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.web.bind.annotation.*;

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {

@Autowired

private UserService userService;

@PostMapping

public User saveUser(@RequestBody User user) {

return userService.save(user);

}

@GetMapping("/{id}")

public ResponseEntity getUserById(@PathVariable("id") Long id) {

User user = userService.findById(id);

log.warn("user="+user.hashCode());

HttpStatus status = user == null ? HttpStatus.NOT_FOUND : HttpStatus.OK;

return new ResponseEntity<>(user, status);

}

@DeleteMapping("/{id}")

public String removeUser(@PathVariable("id") Long id) {

userService.deleteById(id);

return "ok";

}

}

9. 创建入口类

package com.yyg.boot;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class CacheApplication {

public static void main(String[] args) {

SpringApplication.run(CacheApplication.class, args);

}

}

10. 完整项目结构

11. 启动项目进行测试

我们首先调用添加接口，往数据库中添加一条数据。

可以看到数据库中，已经成功的添加了一条数据。

然后测试一下查询接口方法。

此时控制台打印的User对象的hashCode如下:

我们再多次执行查询接口，发现User对象的hashCode值不变，说明数据都是来自于缓存，而不是每次都重新查询。

至此，我们就实现了Spring Boot中默认的缓存方案。