SpringBoot EhCaching

EhCache

EhCache est un cache open source basé sur Java utilisé pour améliorer les performances. La version actuelle d'Ehcache est 3 . Il fournit JSR-107 L'implémentation du gestionnaire de cache. Nous pouvons l'utiliser directement.

Les fonctionnalités d'EhCache

Ilrapide,léger, extensibleetflexible。 Il nous permet d'exécuterserializableetobjet Il fournit des fonctionnalités telles que LRU, LFU, FIFO, etc.stratégie d'éjection du cache. Il stocke le cache dansMémoireetDisque(SSD). Il dépend de SLF4J pour l'enregistrement. Il a été complètement mis en œuvre JSR-107 et Jcache Il prend en charge l'accès via JGroups ou JMS et RMI pour le cache distribué. Il utiliseLangue de consultation fluidepour la recherche distribuée.

Les modes utilisés par EhCache

Le cache utilise plusieurs modes d'accès. EhCache utilise les modes suivants:

Cache-aside Cache-comme-SoR (système-of-record) Read-through Write-through Write-behind

Cache-aside

在 Cache de secoursDans le modèle, d'abord, l'application consulte le cache. Si elle trouve des données, elle les retourne directement. Dans le cas contraire, elle récupère les données du SoR, les stocke dans le cache et puis les retourne.

Cache-comme-SoR

cache-comme-SoR mode représente les opérations de lecture et d'écriture de cache dans SoR. Il réduit la responsabilité de l'application. Il utilise une combinaison de modes de lecture et d'écriture, y compris lecture directe, écriture directe,et post-écriture. Il réduit la difficulté de l'application. Il permet à la cache de résoudre le problème de

Read-through

Read-throughmode, il copie également la cache-mode lors de la lecture des données à partir du cache. La différence entre le mode de lecture et le mode de cache est que le mode de lecture implémente CacheEntryFactory interface. Il guide la cache sur la manière de lire des objets à partir de la cache. Il est préférable de encapsuler l'instance EhCache dans SelfPopulatingCache instance.

Write-through

Write-throughLe mode peut également copier le mode de cache de secours lors de l'écriture des données dans le cache. La différence entre le mode d'écriture directe et le mode de cache de secours réside en ce que le mode d'écriture directe implémente CacheWriter interface. Il configure le cache pour les modes d'écriture directe et après-écriture. Il écrit les données dans SoR dans le même thread d'exécution.

Write-behind

Write-behindmode. En délai configurableaprès, il modifie les entrées de cache. Le décalage peut être sous forme de secondes, minutes, un jour, une semaine,ou un long moment. En même temps, il met également les données en file d'attente pour être écrites plus tard dans le même thread d'exécution.

La écriture de données après l'écriture se produit en dehors de la portée de la transaction. Cela signifie qu'il crée une nouvelle transaction pour soumettre des données différentes de la transaction principale dans SoR.

EhCaching storage layer

EhCache nous permet d'utiliser diverses zones de stockage de données, telles que la pile, le disque et le cluster. Nous pouvons configurer un cache de multi-stockage (en utilisant plusieurs zones de stockage). Il peut être configuré comme couche.

Ces couches sont organisées en ordre. La couche la plus basse est couche autorisée，une autre couche est couche de cache. C'est aussi appelé nearer ou near cache. La couche de cache peut avoir plusieurs zones de stockage. Les données les plus chaudes sont conservées dans la couche de cache, car elles sont plus rapides que la couche autorisée. Comparativement à la couche de cache, d'autres données sont conservées dans la couche autorisée, plus lentes mais plus riches.

Les types de stockage de données pris en charge par EhCache sont Quatre:

On-Heap Store Off-Heap Store Disk Store Clustered Store

On-Heap Store

Il stocke les entrées de cache dans la mémoire heap de Java. Il partage le stockage avec l'application Java. C'est rapide, car il utilise la pile, mais l'espace de stockage est limité. Le collecteur de déchets scanne également le stockage sur la pile.

Off-Heap Store

Il utilise la mémoire principale (RAM) pour stocker les entrées de cache. Le collecteur de déchets ne les scanne pas. Il est plus lent que le stockage sur la pile, car les entrées de cache sont déplacées vers le stockage sur la pile avant leur utilisation. Sa taille est limitée.

Disk Store

Il utilise le disque pour stocker les entrées de cache. C'est beaucoup plus lent que le stockage basé sur la RAM (stockage en haut et en bas). Si le mode de stockage sur le disque est utilisé, il est préférable d'utiliser un disque dédié.

Clustered Store

它将缓存条目存储在远程服务器上。它比堆外存储慢。它可能具有提供高可用性的故障转移服务器。

上图显示了

一个应用程序可能具有多个缓存管理器。许多缓存可以由缓存管理器处理。缓存可以使用多个层来存储缓存条目。 EhCache将最近使用或经常使用的数据放在更快的层(缓存层)中。

配置EhCache

将 EhCache jar放在类路径中。配置 xml 并将其放在类路径中。创建一个引用缓存。

EhCache示例

在以下示例中，我们将在应用程序中配置EhCache。

步骤1: 打开 Spring Initializr https://start.spring.io/。

步骤2: 选择Spring Boot版本 2.3.0 M2 。

步骤3: 提供 Group名称。我们提供了组名 com.w3codebox。

步骤4: 提供 Artifact。我们提供了Artifact spring-boot-ehcache-example。

步骤5: 添加 Spring Web 依赖项。

步骤6: 单击 Generate (生成)按钮。当我们单击"生成"按钮时，它将与应用程序相关的所有规范包装到一个 Jar 文件中，并将其下载到本地系统。

步骤7: 提取 jar文件。

步骤8: 复制文件夹并将其粘贴到STS工作区中。

第9步: 导入项目。

文件->导入->现有 Maven 项目->下一步->浏览->选择文件夹spring-boot-ehcache-example->选择文件夹->完成

导入项目需要时间。

步骤10: 从 Maven 存储库 https://mvnrepository.com/并将其粘贴到 pom.xml中fichier .

spring-boot-starter-cache ehcache 3 cache API。

Attention : 请勿使用包net.sf.ehcache的ehcache。

pom.xml

示例

<?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.3.0.M2</version>
<relativePath/>　<!--　lookup parent from repository　-->
</parent>
<groupId>com.w3codebox</groupId>
<artifactId>spring-boot-ehcache-example</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring-boot-ehcache-example</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-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
<groupId>org.ehcache</groupId>
<artifactId>ehcache</artifactId>
</dependency>
<dependency>
<groupId>javax.cache</groupId>
<artifactId>cache-api</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring　Milestones</name>
<url>https://repo.spring.io/milestone</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>spring-milestones</id>
<name>Spring　Milestones</name>
<url>https://repo.spring.io/milestone</url>
</pluginRepository>
</pluginRepositories>
</project>

Maintenant, nous devons configurer ehcache.xml fichier .

步骤11: 打开 application.properties fichier, et configurer EhCache avec les propriétés suivantes .

application.properties

示例

# configuration ehcache.xml
spring.cache.jcache.config=classpath:ehcache.xml

步骤12: 打开 SpringBootEhcacheExampleApplication.java fichier, et utiliser les annotations @EnableCaching activer le cache .

SpringBootEhcacheExampleApplication.java

示例

package　com.w3codebox;
import org.springframework.boot.SpringApplication ;
import org.springframework.boot.autoconfigure.SpringBootApplication ;
import org.springframework.cache.annotation.EnableCaching ;
@SpringBootApplication
//activer la fonction de gestion du cache
@EnableCaching
public class SpringBootEhcacheExampleApplication　
{
　　　　public static void main(String[] args)　
　　　　{
　　　　　　　　SpringApplication.run(SpringBootEhcacheExampleApplication.class, args);
　　　　}
}

Attention : Si nous ne voulons pas utiliser l'annotation @EnableCaching dans le fichier principal de l'application, nous pouvons créer une classe CacheConfig distincte et utiliser l'annotation pour l'appel .

示例

package　com.w3codebox;
import org.springframework.cache.annotation.EnableCaching ;
import org.springframework.context.annotation.Configuration ;
@Configuration
//activer le cache
@EnableCaching
public class CacheConfig　
{
}

步骤13: créer une classe . Nous avons déjà créé un paquet com.w3codebox a créé un nom de classe Student . dans la classe, effectuer les opérations suivantes:

créer cinq variablesid, name, gender ,et générerutiliser Constructor
cliquez avec le bouton droit sur le fichier-> source-> utiliser le champ pour générer le constructeur-> tout sélectionner->生成 générerGetters and Setters。
cliquez avec le bouton droit sur le fichier-> source-> générer Getter et Setter-> tout sélectionner->生成 générer toString() cliquez avec le bouton droit sur le fichier-> source-> générer toString()->生成

完成上述所有步骤后，类如下所示。

Student.java

示例

package　com.w3codebox;
public　class　Student　
{
　　　　private　int　id;
　　　　private　String　name;
　　　　private　String　gender;
　　　　private　String　city;
　　　　public　Student(int　id,　String　name,　String　gender,　String　city)　
　　　　{
　　　　　　　　super();
　　　　　　　　this.id　=　id;
　　　　　　　　this.name　=　name;
　　　　　　　　this.gender　=　gender;
　　　　　　　　this.city　=　city;
　　　　}
　　　　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　String　getGender()　
　　　　{
　　　　return　gender;
　　　　}
　　　　public　void　setGender(String　gender)　
　　　　{
　　　　this.gender　=　gender;
　　　　}
　　　　public　String　getCity()　
　　　　{
　　　　return　city;
　　　　}
　　　　public　void　setCity(String　city)　
　　　　{
　　　　this.city　=　city;
　　　　}
　　　　@Override
　　　　public　String　toString()　
　　　　{
　　　　　　　　return　"Student　[id="　+　id　+　",　name="　+　name　+　",　gender="　+　gender　+　",　city="　+　city　+　"]";
　　　　}
}

步骤14: 创建用于管理学生的服务类。我们已经创建了名称为 StudentManager的服务类。 在本课程中，我们完成了以下操作:

使用注解 @Service注解类。 创建 HashMap 的实例。在静态块中，我们已在地图中添加了学生数据。通过使用注解 @Cacheable ，我们定义了缓存的名称所有数据都将保存在此缓存中。我们已经在注解的键属性中定义了 id 。缓存根据 id 来搜索学生。我们创建了一种方法 getStudentById()，该方法将id解析为参数。它返回学生的 id 。

StudentManager.java

示例

StudentManager.java
package　com.w3codebox;
import　java.util.HashMap;
import　org.springframework.cache.annotation.Cacheable;
import　org.springframework.stereotype.Service;
@Service
public　class　StudentManager　
{
　　　　static　HashMap<Integer,　Student>　student　=　new　HashMap<>();
　　　　static　
　　　　{
　　　　　　　　student.put(1,　new　Student(10,　"0",　"Alex",　"Male",　"Berlin");
　　　　　　　　student.put(2,　new　Student(101,　"Tony",　"Male",　"Maxico");
　　　　　　　　student.put(3,　new　Student(102,　"Andrew",　"Male",　"Chicago");
　　　　　　　　student.put(4,　new　Student(103,　"Alexa",　"Female",　"Brussels");
　　　　　　　　student.put(5,　new　Student(104,　"Maria",　"Female",　"Houston");
　　　　}
　　　　@Cacheable(cacheNames="demoCache",　key="#id")public　Student　getStudentById(Integer　id)　
　　　　{
　　　　　　　　System.out.println("Fetching　student　data　from　cache");
　　　　　　　　return　student.get(id);
　　　　}
}

现在，我们需要创建 ehcache.xml 文件。它包含与高速缓存相关的信息，例如高速缓存的名称，内存中的元素数量，高速缓存中的实时数据生存时间等。

第15步: 在 src/main/resources 文件夹中缓存名为 ehcache.xml 的配置文件。

ehcahe.xml

示例

<config
xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance
xmlns='http://www.ehcache.org/v3"
xmlns:jsr107='http://www.ehcache.org/v3/jsr107>
<ehcache>
<diskStore　path="java.io.tmpdir"　/>
<defaultCache　maxElementsInMemory="2000"　
　　　　　　　　　　　　eternal="true"
　　　　　　　　　　　　overflowToDisk="false"　
　　　　　　　　　　　　timeToLiveSeconds="1200"　/>
　　　　<cache name="demoCache"　
　　　　　　　　　　　　maxElementsInMemory="2000"
　　　　　　　　　　　　eternal="false"　
　　　　　　　　　　　　overflowToDisk="false"　
　　　　　　　　　　　　timeToLiveSeconds="10000"　/>
</ehcache>
</config>

现在，我们已经创建了所有必需的文件。创建所有文件后，项目目录如下所示:

让我们运行该应用程序。

步骤16: 打开 SpringBootEhcacheExampleApplication.java 文件，并以 Java 应用程序。

它显示以下输出:

示例

从缓存中获取学生
[id=100, name=Alex, gender=Male, city=Berlin]
[id=101, name=Tony, gender=Male, city=Mexico]
[id=102, name=Andrew, gender=Male, city=Chicago]
[id=103, name=Alexa, gender=Female, city=Brussels]
[id=104, name=Maria, gender=Female, city=Houston

SpringBoot 缓存提供程序

教程 SpringBoot