脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Spring Boot 数据缓存与性能优化

Spring Boot 数据缓存与性能优化实战指南

 更新时间：2026年04月20日 09:58:25   作者：星辰徐哥  
本文主要介绍了SpringBoot数据缓存与性能优化的相关内容,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧

Spring Boot 数据缓存与性能优化

23.1 学习目标与重点提示

学习目标：掌握Spring Boot数据缓存与性能优化的核心概念与使用方法，包括数据缓存的定义与特点、Spring Boot与数据缓存的集成、Spring Boot与数据缓存的配置、Spring Boot与数据缓存的基本方法、Spring Boot的实际应用场景，学会在实际开发中处理数据缓存与性能优化问题。
重点：数据缓存的定义与特点、Spring Boot与数据缓存的集成、Spring Boot与数据缓存的配置、Spring Boot与数据缓存的基本方法、Spring Boot的实际应用场景。

23.2 数据缓存概述

数据缓存是Java开发中的重要组件。

23.2.1 数据缓存的定义

定义：数据缓存是一种存储机制，用于将常用数据存储在高速存储设备中，以便快速访问。
作用：

  • 提高应用程序的性能。
  • 减少数据库的访问次数。
  • 提高用户体验。

常见的数据缓存：

  • EhCache：Apache EhCache是一款开源的缓存库。
  • Caffeine：Caffeine是一款高性能的缓存库。
  • Redis：Redis是一款开源的缓存服务器。

✅ 结论：数据缓存是一种存储机制，作用是提高应用程序的性能、减少数据库的访问次数、提高用户体验。

23.2.2 数据缓存的特点

定义：数据缓存的特点是指数据缓存的特性。
特点：

  • 高速访问：数据缓存提供高速访问。
  • 数据一致性：数据缓存提供数据一致性。
  • 可扩展性：数据缓存可以扩展到多个应用程序之间的缓存通信。
  • 易用性：数据缓存提供易用的编程模型。

✅ 结论：数据缓存的特点包括高速访问、数据一致性、可扩展性、易用性。

23.3 Spring Boot与数据缓存的集成

Spring Boot与数据缓存的集成是Java开发中的重要内容。

23.3.1 集成EhCache的步骤

定义：集成EhCache的步骤是指使用Spring Boot与EhCache集成的方法。
步骤：

  1. 创建Spring Boot项目。
  2. 添加所需的依赖。
  3. 配置EhCache。
  4. 创建数据访问层。
  5. 创建业务层。
  6. 创建控制器类。
  7. 测试应用。

示例：
pom.xml文件中的依赖：

<dependencies>
    <!-- Web依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Data JPA依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <!-- H2数据库依赖 -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- EhCache依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    <dependency>
        <groupId>net.sf.ehcache</groupId>
        <artifactId>ehcache</artifactId>
    </dependency>
    <!-- 测试依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

application.properties文件中的EhCache配置：

# 服务器端口
server.port=8080
# 数据库连接信息
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
# JPA配置
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
# H2数据库控制台
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
# EhCache配置
spring.cache.type=ehcache
spring.cache.ehcache.config=classpath:ehcache.xml

ehcache.xml配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">
    <defaultCache
            maxEntriesLocalHeap="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            overflowToDisk="false"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120">
    </defaultCache>
    <cache name="productCache"
           maxEntriesLocalHeap="1000"
           eternal="false"
           timeToIdleSeconds="60"
           timeToLiveSeconds="60"
           overflowToDisk="false"
           diskPersistent="false"
           diskExpiryThreadIntervalSeconds="120">
    </cache>
</ehcache>

实体类：

import javax.persistence.*;
@Entity
@Table(name = "product")
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String productId;
    private String productName;
    private double price;
    private int sales;
    public Product() {
    }
    public Product(String productId, String productName, double price, int sales) {
        this.productId = productId;
        this.productName = productName;
        this.price = price;
        this.sales = sales;
    }
    // Getter和Setter方法
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getProductId() {
        return productId;
    }
    public void setProductId(String productId) {
        this.productId = productId;
    }
    public String getProductName() {
        return productName;
    }
    public void setProductName(String productName) {
        this.productName = productName;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public int getSales() {
        return sales;
    }
    public void setSales(int sales) {
        this.sales = sales;
    }
    @Override
    public String toString() {
        return "Product{" +
                "id=" + id +
                ", productId='" + productId + '\'' +
                ", productName='" + productName + '\'' +
                ", price=" + price +
                ", sales=" + sales +
                '}';
    }
}

Repository接口：

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
}

Service类：

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;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Service
public class ProductService {
    @Autowired
    private ProductRepository productRepository;
    @Transactional
    @CachePut(value = "productCache", key = "#product.id")
    public Product addProduct(Product product) {
        return productRepository.save(product);
    }
    @Transactional
    @CachePut(value = "productCache", key = "#product.id")
    public Product updateProduct(Product product) {
        return productRepository.save(product);
    }
    @Transactional
    @CacheEvict(value = "productCache", key = "#id")
    public void deleteProduct(Long id) {
        productRepository.deleteById(id);
    }
    @Transactional(readOnly = true)
    @Cacheable(value = "productCache", key = "#id")
    public Product getProductById(Long id) {
        System.out.println("从数据库查询产品：" + id);
        return productRepository.findById(id).orElse(null);
    }
    @Transactional(readOnly = true)
    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }
}

控制器类：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/api/products")
public class ProductController {
    @Autowired
    private ProductService productService;
    @GetMapping("/")
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }
    @PostMapping("/")
    public Product addProduct(@RequestBody Product product) {
        return productService.addProduct(product);
    }
    @PutMapping("/{id}")
    public Product updateProduct(@PathVariable Long id, @RequestBody Product product) {
        product.setId(id);
        return productService.updateProduct(product);
    }
    @DeleteMapping("/{id}")
    public void deleteProduct(@PathVariable Long id) {
        productService.deleteProduct(id);
    }
    @GetMapping("/{id}")
    public Product getProductById(@PathVariable Long id) {
        return productService.getProductById(id);
    }
}

应用启动类：

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 ProductApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProductApplication.class, args);
    }
    @Autowired
    private ProductService productService;
    public void run(String... args) {
        // 初始化数据
        productService.addProduct(new Product("P001", "手机", 1000.0, 100));
        productService.addProduct(new Product("P002", "电脑", 5000.0, 50));
        productService.addProduct(new Product("P003", "电视", 3000.0, 80));
        productService.addProduct(new Product("P004", "手表", 500.0, 200));
        productService.addProduct(new Product("P005", "耳机", 300.0, 150));
    }
}

测试类：

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.web.server.LocalServerPort;
import static org.assertj.core.api.Assertions.assertThat;
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class ProductApplicationTests {
    @LocalServerPort
    private int port;
    @Autowired
    private TestRestTemplate restTemplate;
    @Test
    void contextLoads() {
    }
    @Test
    void testGetProductById() {
        Product product1 = restTemplate.getForObject("http://localhost:" + port + "/api/products/1", Product.class);
        assertThat(product1).isNotNull();
        assertThat(product1.getProductId()).isEqualTo("P001");
        Product product2 = restTemplate.getForObject("http://localhost:" + port + "/api/products/1", Product.class);
        assertThat(product2).isNotNull();
        assertThat(product2.getProductId()).isEqualTo("P001");
    }
    @Test
    void testAddProduct() {
        Product product = new Product("P006", "平板", 2000.0, 70);
        Product savedProduct = restTemplate.postForObject("http://localhost:" + port + "/api/products/", product, Product.class);
        assertThat(savedProduct).isNotNull();
        assertThat(savedProduct.getProductId()).isEqualTo("P006");
    }
    @Test
    void testUpdateProduct() {
        Product product = new Product("P001", "手机", 1500.0, 120);
        restTemplate.put("http://localhost:" + port + "/api/products/1", product);
        Product updatedProduct = restTemplate.getForObject("http://localhost:" + port + "/api/products/1", Product.class);
        assertThat(updatedProduct).isNotNull();
        assertThat(updatedProduct.getPrice()).isEqualTo(1500.0);
    }
    @Test
    void testDeleteProduct() {
        restTemplate.delete("http://localhost:" + port + "/api/products/2");
        Product product = restTemplate.getForObject("http://localhost:" + port + "/api/products/2", Product.class);
        assertThat(product).isNull();
    }
}

✅ 结论：集成EhCache的步骤包括创建Spring Boot项目、添加所需的依赖、配置EhCache、创建数据访问层、创建业务层、创建控制器类、测试应用。

23.4 Spring Boot与数据缓存的配置

Spring Boot与数据缓存的配置是Java开发中的重要内容。

23.4.1 配置Caffeine缓存

定义：配置Caffeine缓存是指使用Spring Boot与Caffeine缓存集成的方法。
步骤：

  1. 创建Spring Boot项目。
  2. 添加所需的依赖。
  3. 配置Caffeine缓存。
  4. 创建数据访问层。
  5. 创建业务层。
  6. 创建控制器类。
  7. 测试应用。

示例：
pom.xml文件中的依赖：

<dependencies>
    <!-- Web依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Data JPA依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <!-- H2数据库依赖 -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- Caffeine依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    <dependency>
        <groupId>com.github.ben-manes.caffeine</groupId>
        <artifactId>caffeine</artifactId>
    </dependency>
    <!-- 测试依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

application.properties文件中的Caffeine缓存配置：

# 服务器端口
server.port=8080
# 数据库连接信息
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
# JPA配置
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
# H2数据库控制台
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
# Caffeine缓存配置
spring.cache.type=caffeine
spring.cache.caffeine.spec=maximumSize=1000,expireAfterWrite=60s

控制器类：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/api/products")
public class ProductController {
    @Autowired
    private ProductService productService;
    @GetMapping("/")
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }
    @PostMapping("/")
    public Product addProduct(@RequestBody Product product) {
        return productService.addProduct(product);
    }
    @PutMapping("/{id}")
    public Product updateProduct(@PathVariable Long id, @RequestBody Product product) {
        product.setId(id);
        return productService.updateProduct(product);
    }
    @DeleteMapping("/{id}")
    public void deleteProduct(@PathVariable Long id) {
        productService.deleteProduct(id);
    }
    @GetMapping("/{id}")
    public Product getProductById(@PathVariable Long id) {
        return productService.getProductById(id);
    }
}

测试类：

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.web.server.LocalServerPort;
import static org.assertj.core.api.Assertions.assertThat;
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class ProductApplicationTests {
    @LocalServerPort
    private int port;
    @Autowired
    private TestRestTemplate restTemplate;
    @Test
    void contextLoads() {
    }
    @Test
    void testGetProductById() {
        Product product1 = restTemplate.getForObject("http://localhost:" + port + "/api/products/1", Product.class);
        assertThat(product1).isNotNull();
        assertThat(product1.getProductId()).isEqualTo("P001");
        Product product2 = restTemplate.getForObject("http://localhost:" + port + "/api/products/1", Product.class);
        assertThat(product2).isNotNull();
        assertThat(product2.getProductId()).isEqualTo("P001");
    }
    @Test
    void testAddProduct() {
        Product product = new Product("P006", "平板", 2000.0, 70);
        Product savedProduct = restTemplate.postForObject("http://localhost:" + port + "/api/products/", product, Product.class);
        assertThat(savedProduct).isNotNull();
        assertThat(savedProduct.getProductId()).isEqualTo("P006");
    }
    @Test
    void testUpdateProduct() {
        Product product = new Product("P001", "手机", 1500.0, 120);
        restTemplate.put("http://localhost:" + port + "/api/products/1", product);
        Product updatedProduct = restTemplate.getForObject("http://localhost:" + port + "/api/products/1", Product.class);
        assertThat(updatedProduct).isNotNull();
        assertThat(updatedProduct.getPrice()).isEqualTo(1500.0);
    }
    @Test
    void testDeleteProduct() {
        restTemplate.delete("http://localhost:" + port + "/api/products/2");
        Product product = restTemplate.getForObject("http://localhost:" + port + "/api/products/2", Product.class);
        assertThat(product).isNull();
    }
}

✅ 结论：配置Caffeine缓存是指使用Spring Boot与Caffeine缓存集成的方法，步骤包括创建Spring Boot项目、添加所需的依赖、配置Caffeine缓存、创建数据访问层、创建业务层、创建控制器类、测试应用。

23.5 Spring Boot与数据缓存的基本方法

Spring Boot与数据缓存的基本方法包括使用@Cacheable、@CachePut、@CacheEvict注解。

23.5.1 使用@Cacheable注解

定义：使用@Cacheable注解是指Spring Boot与数据缓存集成的基本方法之一。
作用：

  • 实现数据缓存。
  • 提高应用程序的性能。

示例：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Service
public class ProductService {
    @Autowired
    private ProductRepository productRepository;
    @Transactional(readOnly = true)
    @Cacheable(value = "productCache", key = "#id")
    public Product getProductById(Long id) {
        System.out.println("从数据库查询产品：" + id);
        return productRepository.findById(id).orElse(null);
    }
    @Transactional(readOnly = true)
    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }
}

✅ 结论：使用@Cacheable注解是指Spring Boot与数据缓存集成的基本方法之一，作用是实现数据缓存、提高应用程序的性能。

23.5.2 使用@CachePut注解

定义：使用@CachePut注解是指Spring Boot与数据缓存集成的基本方法之一。
作用：

  • 实现数据缓存。
  • 提高应用程序的性能。

示例：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CachePut;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Service
public class ProductService {
    @Autowired
    private ProductRepository productRepository;
    @Transactional
    @CachePut(value = "productCache", key = "#product.id")
    public Product addProduct(Product product) {
        return productRepository.save(product);
    }
    @Transactional
    @CachePut(value = "productCache", key = "#product.id")
    public Product updateProduct(Product product) {
        return productRepository.save(product);
    }
    @Transactional(readOnly = true)
    @Cacheable(value = "productCache", key = "#id")
    public Product getProductById(Long id) {
        System.out.println("从数据库查询产品：" + id);
        return productRepository.findById(id).orElse(null);
    }
    @Transactional(readOnly = true)
    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }
}

✅ 结论：使用@CachePut注解是指Spring Boot与数据缓存集成的基本方法之一，作用是实现数据缓存、提高应用程序的性能。

23.5.3 使用@CacheEvict注解

定义：使用@CacheEvict注解是指Spring Boot与数据缓存集成的基本方法之一。
作用：

  • 实现数据缓存。
  • 提高应用程序的性能。

示例：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Service
public class ProductService {
    @Autowired
    private ProductRepository productRepository;
    @Transactional
    @CachePut(value = "productCache", key = "#product.id")
    public Product addProduct(Product product) {
        return productRepository.save(product);
    }
    @Transactional
    @CachePut(value = "productCache", key = "#product.id")
    public Product updateProduct(Product product) {
        return productRepository.save(product);
    }
    @Transactional
    @CacheEvict(value = "productCache", key = "#id")
    public void deleteProduct(Long id) {
        productRepository.deleteById(id);
    }
    @Transactional(readOnly = true)
    @Cacheable(value = "productCache", key = "#id")
    public Product getProductById(Long id) {
        System.out.println("从数据库查询产品：" + id);
        return productRepository.findById(id).orElse(null);
    }
    @Transactional(readOnly = true)
    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }
}

✅ 结论：使用@CacheEvict注解是指Spring Boot与数据缓存集成的基本方法之一，作用是实现数据缓存、提高应用程序的性能。

23.6 Spring Boot的实际应用场景

在实际开发中，Spring Boot数据缓存与性能优化的应用场景非常广泛，如：

  • 实现产品信息的缓存。
  • 实现用户信息的缓存。
  • 实现订单信息的缓存。
  • 实现日志信息的缓存。

示例：

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 ProductApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProductApplication.class, args);
    }
    @Autowired
    private ProductService productService;
    public void run(String... args) {
        // 初始化数据
        productService.addProduct(new Product("P001", "手机", 1000.0, 100));
        productService.addProduct(new Product("P002", "电脑", 5000.0, 50));
        productService.addProduct(new Product("P003", "电视", 3000.0, 80));
        productService.addProduct(new Product("P004", "手表", 500.0, 200));
        productService.addProduct(new Product("P005", "耳机", 300.0, 150));
    }
}
@Service
class ProductService {
    @Autowired
    private ProductRepository productRepository;
    @Transactional
    @CachePut(value = "productCache", key = "#product.id")
    public Product addProduct(Product product) {
        return productRepository.save(product);
    }
    @Transactional
    @CachePut(value = "productCache", key = "#product.id")
    public Product updateProduct(Product product) {
        return productRepository.save(product);
    }
    @Transactional
    @CacheEvict(value = "productCache", key = "#id")
    public void deleteProduct(Long id) {
        productRepository.deleteById(id);
    }
    @Transactional(readOnly = true)
    @Cacheable(value = "productCache", key = "#id")
    public Product getProductById(Long id) {
        System.out.println("从数据库查询产品：" + id);
        return productRepository.findById(id).orElse(null);
    }
    @Transactional(readOnly = true)
    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }
}
@RestController
@RequestMapping("/api/products")
class ProductController {
    @Autowired
    private ProductService productService;
    @GetMapping("/")
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }
    @PostMapping("/")
    public Product addProduct(@RequestBody Product product) {
        return productService.addProduct(product);
    }
    @PutMapping("/{id}")
    public Product updateProduct(@PathVariable Long id, @RequestBody Product product) {
        product.setId(id);
        return productService.updateProduct(product);
    }
    @DeleteMapping("/{id}")
    public void deleteProduct(@PathVariable Long id) {
        productService.deleteProduct(id);
    }
    @GetMapping("/{id}")
    public Product getProductById(@PathVariable Long id) {
        return productService.getProductById(id);
    }
}
// 测试类
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class ProductApplicationTests {
    @LocalServerPort
    private int port;
    @Autowired
    private TestRestTemplate restTemplate;
    @Test
    void contextLoads() {
    }
    @Test
    void testGetProductById() {
        Product product1 = restTemplate.getForObject("http://localhost:" + port + "/api/products/1", Product.class);
        assertThat(product1).isNotNull();
        assertThat(product1.getProductId()).isEqualTo("P001");
        Product product2 = restTemplate.getForObject("http://localhost:" + port + "/api/products/1", Product.class);
        assertThat(product2).isNotNull();
        assertThat(product2.getProductId()).isEqualTo("P001");
    }
    @Test
    void testAddProduct() {
        Product product = new Product("P006", "平板", 2000.0, 70);
        Product savedProduct = restTemplate.postForObject("http://localhost:" + port + "/api/products/", product, Product.class);
        assertThat(savedProduct).isNotNull();
        assertThat(savedProduct.getProductId()).isEqualTo("P006");
    }
    @Test
    void testUpdateProduct() {
        Product product = new Product("P001", "手机", 1500.0, 120);
        restTemplate.put("http://localhost:" + port + "/api/products/1", product);
        Product updatedProduct = restTemplate.getForObject("http://localhost:" + port + "/api/products/1", Product.class);
        assertThat(updatedProduct).isNotNull();
        assertThat(updatedProduct.getPrice()).isEqualTo(1500.0);
    }
    @Test
    void testDeleteProduct() {
        restTemplate.delete("http://localhost:" + port + "/api/products/2");
        Product product = restTemplate.getForObject("http://localhost:" + port + "/api/products/2", Product.class);
        assertThat(product).isNull();
    }
}

输出结果：

  • 访问http://localhost:8080/api/products/1：第一次访问从数据库查询，第二次访问从缓存查询。
  • 控制台输出：
    从数据库查询产品：1

✅ 结论：在实际开发中，Spring Boot数据缓存与性能优化的应用场景非常广泛，需要根据实际问题选择合适的缓存策略。

总结

本章我们学习了Spring Boot数据缓存与性能优化，包括数据缓存的定义与特点、Spring Boot与数据缓存的集成、Spring Boot与数据缓存的配置、Spring Boot与数据缓存的基本方法、Spring Boot的实际应用场景，学会了在实际开发中处理数据缓存与性能优化问题。其中，数据缓存的定义与特点、Spring Boot与数据缓存的集成、Spring Boot与数据缓存的配置、Spring Boot与数据缓存的基本方法、Spring Boot的实际应用场景是本章的重点内容。从下一章开始，我们将学习Spring Boot的其他组件、微服务等内容。

到此这篇关于Spring Boot 数据缓存与性能优化实战指南的文章就介绍到这了,更多相关Spring Boot 数据缓存与性能优化内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • 关于Java中重定向传参与取值

    关于Java中重定向传参与取值

    这篇文章主要介绍了Java中重定向传参与取值问题,重定向不仅可以重定向到当前应用程序中的其他资源，还可以重定向到同一个站点上的其他应用程序中的资源，甚至是使用绝对URL重定向到其他站点的资源，本文给大家介绍的非常详细，需要的朋友可以参考下
    2023-05-05
  • Java 带参数与带返回值的方法的定义和调用

    Java 带参数与带返回值的方法的定义和调用

    在java中，方法就是用来完成解决某件事情或实现某个功能的办法。方法实现的过程中，会包含很多条语句用于完成某些有意义的功能——通常是处理文本，控制输入或计算数值，这篇文章我们来探究一下带参数与带返回值的方法的定义和调用
    2022-04-04
  • springboot logback调整mybatis日志级别无效的解决

    springboot logback调整mybatis日志级别无效的解决

    这篇文章主要介绍了springboot logback调整mybatis日志级别无效的解决,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2020-10-10
  • Springboot之整合Socket连接案例

    Springboot之整合Socket连接案例

    这篇文章主要介绍了Springboot之整合Socket连接案例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2021-01-01
  • MyBatis与SpringMVC相结合实现文件上传、下载功能

    MyBatis与SpringMVC相结合实现文件上传、下载功能

    这篇文章主要介绍了MyBatis与SpringMVC相结合实现文件上传、下载功能的相关资料,非常不错，具有参考借鉴价值，需要的朋友可以参考下
    2016-06-06
  • Spring @Scheduled定时器注解使用方式

    Spring @Scheduled定时器注解使用方式

    这篇文章主要介绍了Spring @Scheduled定时器注解使用方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2024-08-08
  • 如何解决zookeeper集群重启Error contacting service.It is probably not running问题

    如何解决zookeeper集群重启Error contacting service.It 

    本文详细介绍了Zookeeper集群启动异常的排查步骤,包括网络问题、防火墙配置、Java环境、端口占用、网卡问题、网络问题以及节点配置信息的检查,通过逐一排查和解决这些问题,可以有效地启动Zookeeper集群
    2024-12-12
  • Java中Arraylist的最大长度

    Java中Arraylist的最大长度

    这篇文章主要介绍了Java中Arraylist的最大长度，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2022-02-02
  • 解决SpringBoot连接SqlServer出现的问题

    解决SpringBoot连接SqlServer出现的问题

    在尝试通过SSL与SQL Server建立安全连接时,如果遇到“PKIX path building failed”错误,可能是因为未能正确配置或信任服务器证书,当"Encrypt"属性设置为"true"且"trustServerCertificate"属性设置为"false"时,要求驱动程序使用安全套接字层(SSL)加密与SQL Server建立连接
    2024-10-10
  • Java中double和float类型的区别与使用方法

    Java中double和float类型的区别与使用方法

    float和double都是用来表示浮点数的数据类型,但是它们之间有一些区别,这篇文章主要给大家介绍了关于Java中double和float类型的区别与使用方法的相关资料,需要的朋友可以参考下
    2024-07-07

最新评论