入门·使用Spring缓存数据

本指南将引导您完成在Spring托管Bean上启用缓存的过程。

你会建立什么

您将构建一个应用程序，该应用程序可以在简单的书籍存储库上进行缓存。

你需要什么

约15分钟
最喜欢的文本编辑器或IDE
JDK 1.8或更高版本
Gradle 4+或Maven 3.2+
您还可以将代码直接导入到IDE中：
- Spring Tool Suite (STS)
- IntelliJ IDEA

如何完成本指南

像大多数Spring 入门指南一样，您可以从头开始并完成每个步骤，也可以绕过您已经熟悉的基本设置步骤。无论哪种方式，您最终都可以使用工作代码。

要从头开始 ，请继续进行[scratch] 。

要跳过基础知识 ，请执行以下操作：

下载并解压缩本指南的源存储库，或使用Git对其进行克隆：git clone https://github.com/spring-guides/gs-caching.git
光盘进入gs-caching/initial
继续创建书库。

完成后 ，您可以根据中的代码检查结果gs-caching/complete 。

从Spring Initializr开始

对于所有Spring应用程序，您应该从Spring Initializr开始。Initializr提供了一种快速的方法来提取应用程序所需的所有依赖关系，并为您完成了许多设置。本示例仅需要Spring缓存抽象依赖项。下图显示了此示例项目的Initializr设置：

上图显示了选择Maven作为构建工具的Initializr。您也可以使用Gradle。它还显示了com.example和caching分别是Group和Artifact。在本示例的其余部分中，将使用这些值。

以下清单显示了pom.xml选择Maven时创建的文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.8.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.example</groupId>
	<artifactId>caching</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>caching</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-cache</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

以下清单显示了build.gradle选择Gradle时创建的文件：

plugins {
	id 'org.springframework.boot' version '2.1.8.RELEASE'
	id 'io.spring.dependency-management' version '1.0.8.RELEASE'
	id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

repositories {
	mavenCentral()
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-cache'
	testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

创建一个书库

首先，您需要为您的书创建一个简单的模型。以下清单（来自src/main/java/com/example/caching/Book.java ）显示了操作方法：

package com.example.caching;

public class Book {

    private String isbn;
    private String title;

    public Book(String isbn, String title) {
        this.isbn = isbn;
        this.title = title;
    }

    public String getIsbn() {
        return isbn;
    }

    public void setIsbn(String isbn) {
        this.isbn = isbn;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    @Override
    public String toString() {
        return "Book{" + "isbn='" + isbn + '\'' + ", title='" + title + '\'' + '}';
    }

}

您还需要该模型的存储库。以下清单（来自src/main/java/com/example/caching/BookRepository.java ）显示了这样的存储库：

package com.example.caching;

public interface BookRepository {

    Book getByIsbn(String isbn);

}

您可能已经使用Spring Data在各种SQL或NoSQL存储上提供了存储库的实现。但是，出于本指南的目的，您将仅使用模拟某些延迟（网络服务，缓慢的延迟或其他问题）的简单实施。以下清单（来自src/main/java/com/example/caching/SimpleBookRepository.java ）显示了这样的存储库：

package com.example.caching;

import org.springframework.stereotype.Component;

@Component
public class SimpleBookRepository implements BookRepository {

    @Override
    public Book getByIsbn(String isbn) {
        simulateSlowService();
        return new Book(isbn, "Some book");
    }

    // Don't do this at home
    private void simulateSlowService() {
        try {
            long time = 3000L;
            Thread.sleep(time);
        } catch (InterruptedException e) {
            throw new IllegalStateException(e);
        }
    }

}

simulateSlowService故意将三秒的延迟插入每个getByIsbn呼叫。稍后，您将通过缓存来加速此示例。

使用储存库

接下来，您需要连接存储库并使用它来访问一些书。以下清单（来自src/main/java/com/example/caching/CachingApplication.java ）显示了操作方法：

package com.example.caching;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class CachingApplication {

	public static void main(String[] args) {
		SpringApplication.run(CachingApplication.class, args);
	}

}

@SpringBootApplication是一个方便注释，它添加了以下所有内容：

@Configuration ：将类标记为应用程序上下文的Bean定义的源。
@EnableAutoConfiguration ：告诉Spring Boot根据类路径设置，其他bean和各种属性设置开始添加bean。例如，如果spring-webmvc在类路径上，此注释将应用程序标记为Web应用程序并激活关键行为，例如设置DispatcherServlet 。
@ComponentScan ：告诉Spring在其中寻找其他组件，配置和服务com/example包，让它找到控制器。

的main()方法使用Spring Boot的SpringApplication.run()启动应用程序的方法。您是否注意到没有一行XML？没有web.xml文件。该Web应用程序是100％纯Java，因此您无需处理任何管道或基础结构。

您还需要一个CommandLineRunner注入BookRepository并用不同的参数多次调用它。以下清单（来自src/main/java/com/example/caching/AppRunner.java ）显示该类：

package com.example.caching;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class AppRunner implements CommandLineRunner {

    private static final Logger logger = LoggerFactory.getLogger(AppRunner.class);

    private final BookRepository bookRepository;

    public AppRunner(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    @Override
    public void run(String... args) throws Exception {
        logger.info(".... Fetching books");
        logger.info("isbn-1234 -->" + bookRepository.getByIsbn("isbn-1234"));
        logger.info("isbn-4567 -->" + bookRepository.getByIsbn("isbn-4567"));
        logger.info("isbn-1234 -->" + bookRepository.getByIsbn("isbn-1234"));
        logger.info("isbn-4567 -->" + bookRepository.getByIsbn("isbn-4567"));
        logger.info("isbn-1234 -->" + bookRepository.getByIsbn("isbn-1234"));
        logger.info("isbn-1234 -->" + bookRepository.getByIsbn("isbn-1234"));
    }

}

如果此时尝试运行该应用程序，则应注意，即使您多次检索完全相同的书，它也非常慢。以下示例输出显示了我们的（故意糟糕的）代码创建的三秒延迟：

2014-06-05 12:15:35.783  ... : .... Fetching books
2014-06-05 12:15:40.783  ... : isbn-1234 -->Book{isbn='isbn-1234', title='Some book'}
2014-06-05 12:15:43.784  ... : isbn-1234 -->Book{isbn='isbn-1234', title='Some book'}
2014-06-05 12:15:46.786  ... : isbn-1234 -->Book{isbn='isbn-1234', title='Some book'}

我们可以通过启用缓存来改善这种情况。

启用缓存

现在，您可以在自己的服务器上启用缓存了SimpleBookRepository以便将书缓存在books缓存。以下清单（来自src/main/java/com/example/caching/SimpleBookRepository.java ）显示存储库定义：

package com.example.caching;

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;

@Component
public class SimpleBookRepository implements BookRepository {

    @Override
    @Cacheable("books")
    public Book getByIsbn(String isbn) {
        simulateSlowService();
        return new Book(isbn, "Some book");
    }

    // Don't do this at home
    private void simulateSlowService() {
        try {
            long time = 3000L;
            Thread.sleep(time);
        } catch (InterruptedException e) {
            throw new IllegalStateException(e);
        }
    }

}

现在，您需要启用对缓存注释的处理，如以下示例所示（来自src/main/java/com/example/caching/CachingApplication.java ）显示操作方法：

package com.example.caching;

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

@SpringBootApplication
@EnableCaching
public class CachingApplication {

    public static void main(String[] args) {
        SpringApplication.run(CachingApplication.class, args);
    }

}

的@EnableCaching注解触发一个后处理器，该后处理器检查每个Spring Bean是否存在公共方法上的缓存注解。如果找到了这样的注释，则会自动创建一个代理来拦截方法调用并相应地处理缓存行为。

后处理器处理@Cacheable ， @CachePut和@CacheEvict注释。您可以参考Javadoc和参考指南以获取更多详细信息。

Spring Boot自动配置合适的CacheManager充当相关缓存的提供者。请参阅Spring Boot文档以获取更多详细信息。

我们的示例未使用特定的缓存库，因此我们的缓存存储是使用ConcurrentHashMap 。缓存抽象支持广泛的缓存库，并且完全符合JSR-107（JCache）。

构建可执行的JAR

您可以使用Gradle或Maven从命令行运行该应用程序。您还可以构建一个包含所有必需的依赖项，类和资源的可执行JAR文件，然后运行该文件。构建可执行的jar使得在整个开发生命周期中，跨不同环境等等的情况下，可以轻松地将服务作为应用程序进行发布，版本化和部署。

如果您使用Gradle，则可以使用./gradlew bootRun 。或者，您可以通过使用以下命令构建JAR文件： ./gradlew build然后运行JAR文件，如下所示：

java -jar build/libs/gs-caching-0.1.0.jar

如果使用Maven，则可以通过使用以下命令运行应用程序./mvnw spring-boot:run 。或者，您可以使用以下命令构建JAR文件： ./mvnw clean package然后运行JAR文件，如下所示：

java -jar target/gs-caching-0.1.0.jar

此处描述的步骤将创建可运行的JAR。您还可以构建经典的WAR文件。

测试应用

现在启用了缓存，您可以再次运行该应用程序，并通过添加带有或不带有相同ISBN的其他调用来查看差异。它应该产生巨大的变化。以下清单显示了启用了缓存的输出：

2016-09-01 11:12:47.033  .. : .... Fetching books
2016-09-01 11:12:50.039  .. : isbn-1234 -->Book{isbn='isbn-1234', title='Some book'}
2016-09-01 11:12:53.044  .. : isbn-4567 -->Book{isbn='isbn-4567', title='Some book'}
2016-09-01 11:12:53.045  .. : isbn-1234 -->Book{isbn='isbn-1234', title='Some book'}
2016-09-01 11:12:53.045  .. : isbn-4567 -->Book{isbn='isbn-4567', title='Some book'}
2016-09-01 11:12:53.045  .. : isbn-1234 -->Book{isbn='isbn-1234', title='Some book'}
2016-09-01 11:12:53.045  .. : isbn-1234 -->Book{isbn='isbn-1234', title='Some book'}

在前面的示例输出中，第一次检索书仍需要三秒钟。但是，同一本书的第二次和后续时间要快得多，这表明缓存正在完成其工作。

摘要

恭喜你！您刚刚在Spring托管的bean上启用了缓存。

是否要编写新指南或为现有指南做出贡献？查看我们的贡献准则。

所有指南均以代码的ASLv2许可证和写作的Attribution，NoDerivatives创作共用许可证发布。