Exécution du programme SpringBoot Thymeleaf Spring Boot

Cache SpringBoot

Spring框架透明地在Spring应用程序中提供缓存。在Spring中，缓存抽象是一种机制，它允许在不影响代码的情况下一致使用各种缓存方法。

缓存抽象

缓存抽象机制适用于 Java 方法。使用缓存抽象的主要目的是根据缓存中存在的信息减少执行次数。它适用于昂贵的方法，例如 CPU ou IO绑定。

每次调用方法时，抽象都会将缓存行为应用于该方法。它检查该方法是否已经针对给定参数执行。

如果是，则不执行实际方法就返回缓存的结果。如果否，则首先执行该方法，并将结果缓存并返回给用户。

注意：此方法仅适用于保证为给定输入返回相同结果的方法。该方法执行多少次并不重要。

开发人员在处理缓存抽象时会注意两件事。

缓存声明: 它标识需要缓存的方法。 缓存配置： 用于存储和读取数据的后备缓存。

Cache

缓存是临时内存的一部分( RAM )。它位于应用程序和持久性数据库之间。它存储最近使用的数据，从而尽可能减少数据库命中次数。换句话说，缓存是为了存储数据以供将来参考。

为什么要使用缓存？

使用缓存的主要原因是为了进行数据访问更快，更便宜。当多次请求高度请求的资源时，对于开发人员来说，缓存资源通常是有益的，这样它可以快速给出响应。在应用程序中使用缓存可以增强应用程序的性能。与从数据库中获取数据相比，从内存进行数据访问总是更快。它降低了货币成本和机会成本。

应缓存哪些数据？

不经常更改的数据。经常使用的读取查询，其查询结果在每个调用中至少一段时间没有变化。

缓存类型

有四种以下是一些缓存类型：

内存中缓存Cache de base de données Cache du serveur web mécanisme de cache CDN

内存缓存

内存缓存可提高应用程序的性能。这是经常使用的区域。 Memcached et Redis 是内存中缓存的示例。它在应用程序和数据库之间存储键值。 Redis是一种分布式内存中Outil de cache avancé,可用于备份和还原功能。我们还可以管理分布式集群中的缓存。

Cache de base de données

Le cache de base de données est un mécanisme qui génère dynamiquement des pages web en fonction des données demandées. De la base de données. Il fonctionne dans le contexte du client, du serveur d'application web et de la base de donnéescoucheenvironnement. En répartissant la charge de travail des requêtes, il amélioreévitabilitéetperformance. Le cache de niveau 1 le plus populaire est celui de Hibernate.

Cache du serveur web

Le cache du serveur web est un stockage de données pourréutilisation. Par exemple, les copies des pages web fournies par les serveurs web sont mises en cache lors de la première visite de l'utilisateur. Si l'utilisateur demande à nouveau le même contenu, le cache fournit une copie de la page. Cela évite le surcharge du serveur. Le cache du serveur web peut accélérer la livraison des pages et réduire le travail à faire par le serveur backend.

mécanisme de cache CDN

CDN représenteRéseau de distribution de contenuC'est un composant utilisé dans les applications web modernes. En utilisant。répliquesfichiers courants (par exemple, les pages HTML, les feuilles de style), il peut améliorer la distribution du contenu. JavaScript, images, vidéos, etc.) sont distribués sur un ensemble de serveurs de cache distribués à l'échelle mondiale

serveur de cache proche.C'est pourquoi le CDN est de plus en plus populaire. Le CDN allège la charge de l'origine de l'application et améliore l'expérience utilisateur. Il tire depuis lebordure de cache(plus proche du client final) ouPoint de présence (PoP)

fournissent des copies locales du contenu.

Cache	Cache et tampon
tamponCache basé sur。	l'utilisation la plus récentetampon basé sur
先进先出	C'est la taille du cache de page./C'est un bloc original en mémoire
longtempsO tampon.court	longtempsIl a vécucourt
lisons à partir du cachepériode.。	lisons à partir du cacheIl amélioreNous
dans le tampon.Il stockeréelles	données du fichier.Il stocke les fichiers。
lecture métadonnées écriture	lectureIl amélioreécriture

pour améliorer les performances.

@EnableCaching

les annotations de cache Spring Boot C'est une annotation de niveau de classe. Nous pouvons utiliserIl active le cache dans l'application Spring Boot avec l'annotation @EnableCaching. org.springframework.cache.annotation défini dans le paquet. Il fonctionne avec @Configuration les classes ensemble.

Si aucune instance de CacheManager n'est définie, l'auto-configuration active le cache et configure CacheManager Il scanne les fournisseurs spécifiques, s'il ne trouve pas, il utilise le cache concurrent HashMap crée un cache en mémoire.

Exemple

Dans l'exemple suivant, @EnableCaching L'annotation active le mécanisme de cache.

Exemple

@SpringBootApplication
@EnableCaching　
public class SpringBootCachingApplication　
{
public static void main(String[] args)　
{
SpringApplication.run(SpringBootCachingApplication.class, args);
}
}

@CacheConfig

C'est une annotation de niveau classe, qui fournit des paramètres communs concernant le cache. Elle indique à Spring où stocker le cache de la classe. Lorsque nous ajoutons une annotation à une classe, elle fournit un ensemble de paramètres par défaut pour toutes les opérations de cache définies dans la classe. Grâce à l'annotation, nous n'avons pas besoin de déclarer plusieurs fois.

Exemple

Dans l'exemple suivant,Employéest le nom du cache.

Exemple

@CacheConfig(cacheNames={"employee"})　
public class UserService
{
//some code
}

@Caching

lorsque nous avons besoin de deux annotations @CachePut ou @CacheEvict en utilisant la même méthode. Autrement dit, lorsque nous devons utiliser plusieurs annotations du même type, nous utilisons

Mais Java ne permet pas d'utiliser plusieurs annotations du même type pour une même déclarationméthode. Pour éviter ce problème, nous utilisons @Caching annotations.

Exemple

Dans l'exemple suivant, nous avons utilisé l'annotation @Caching et tous @CacheEvict de regroupement des annotations.

Exemple

@Caching(evict = {@CacheEvict("phone_number"), @CacheEvict(value="directory", key="#student.id")})public String getAddress(Student student)　
{
//some code
}

@Cacheable

C'est une annotation de niveau méthode. Elle définit un cache pour la valeur de retour de la méthode. Le cadre Spring gère les demandes et les réponses de cache spécifiées dans les attributs d'annotation. L'annotation @Cacheable contient plus d'options. Par exemple, nous pouvons utiliser value ou cacheNames fourni parnom du cache。

Nous pouvons également spécifier les attributs key Les attributs sont utilisés pour identifier de manière unique chaque entrée du cache. Si la clé n'est pas spécifiée, Spring utilise un mécanisme par défaut pour créer la clé.

Exemple

Dans l'exemple suivant, nous avons mis en cache< cacheStudentInfo,et id dans la méthode studentInfo()La valeur de retour est la clé unique, utilisée pour identifier le cache.

Exemple

@Cacheable(value="cacheStudentInfo", key="#id")public List studentInfo()
{
//some code　
return studentDetails;
}

Nous pouvons également appliquer des conditions en utilisant l'attribut condition dans les annotations. Lorsque nous appliquons des conditions dans les annotations, cela s'appelleCache conditionnel。

Par exemple, si la longueur du nom du paramètre est inférieure à20, alors mettez en cache la méthode suivante.

Exemple

@Cacheable(value="student", condition="#name.length<20)public Student findStudent(String name)
{
//some code
}

@CacheEvict

C'est une annotation de niveau méthode. Lorsque nous voulons supprimer des données obsolètes ou non utilisées du cache, nous utilisons cette annotation. Elle nécessite une ou plusieurs caches affectées par l'opération. Nous pouvons également y spécifier une clé ou une condition. Si nous voulons effectuer un nettoyage de cache large, l'annotation @CacheEvict fournit un nom allEntries des paramètres. Il éjecte tous les éléments, au lieu d'éjecter un élément en fonction de la clé.

Un point important concernant l'annotation @CacheEvict est qu'elle peut être utilisée avec des méthodes void, car cette méthode joue le rôle de déclencheur. Elle évite de renvoyer une valeur. D'autre part, l'annotation @Cacheable nécessite une valeur de retour, qui est utilisée pour ajouter/Mettre à jour les données dans la cache. Nous pouvons utiliser l'annotation @CacheEvict de la manière suivante:

éjecter tout le cache:

Exemple

@CacheEvict(allEntries=true)

éjecter des entrées par clé:

Exemple

@CacheEvict(key="#student.stud_name")

Exemple

Les méthodes annotées suivantes extraient de la cache student_data supprimer toutes les données.

Exemple

@CacheEvict(value="student_data", allEntries=true)　//supprimer toutes les entrées de la cache
public String getNames(Student student)　
{
//some code
}

@CachePut

C'est une annotation de niveau méthode. Lorsque nous voulonsmise à jourUtilisez-le lorsque vous souhaitez mettre en cache sans interférer avec l'exécution de la méthode. Cela signifie que cette méthode sera toujours exécutée et son résultat mis en cache. Il prend en charge les attributs de l'annotation @Cacheable.

Il convient de noter que @Cacheable et @CachePut ont des comportements différents, donc ils ne sont pas identiques. Il y a une distinction subtile entre @Cacheable et @CachePut, c'est @ Cacheable CommentaireSauter l'exécution de la méthodeet @CachePut CommentaireExécutez cette méthodeensuite, placez le résultat dans la cache.

Exemple

Les méthodes suivantes mettront à jour la cache elle-même.

Exemple

@CachePut(cacheNames="employee", key="#id")　　//mise à jour de la cachepublic Employee mise à jourEmp(ID id, EmployeeData data)
{
//some code
}

Spring Boot缓存依赖项

如果要在Spring Boot应用程序中启用缓存机制，则需要在pom.xml文件中添加缓存依赖项。它启用缓存并配置CacheManager。

Exemple

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

Spring Boot缓存示例

我们创建一个Spring Boot应用程序并在其中实现缓存机制。

Étape1: 打开Spring Initializr http://start.spring.io 。

Étape2: 选择Spring Boot版本 2.3.0.M1。

Étape2: 提供群组名称。我们提供了 Dans3codebox。

Étape3: 提供工件 ID。我们提供了 spring-boot-cache-example。

Étape5: 添加依赖项 Spring Web et Spring Cache抽象。

Étape6: 单击 Generate (生成)按钮。当我们单击"生成"按钮时，它将规格包装在 Jar 文件中，并将其下载到本地系统。

Étape7: 提取 Jar文件并将其粘贴到STS工作区中。

Étape8: 导入 STS中的项目文件夹。

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

导入需要一些时间。

让我们打开 pom.xml 文件，看看我们已经向其中添加了哪些依赖项。

pom.xml

Exemple

<?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.M1</version>
　　　　<relativePath/>　<!--　lookup parent from repository　-->
　　</parent>
　　<groupId>com.w3codebox</groupId>
　　<artifactId>spring-boot-cache-example</artifactId>
　　<version>0.0.1-SNAPSHOT</version>
　　<name>spring-boot-cache-example</name>
　　<description>Projet de démonstration pour 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-web</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>

Étape9: ouvrir SpringBootCacheExampleApplication.java fichier, en ajoutant l'annotation @EnableCaching activer le cache.

Exemple

SpringBootCacheExampleApplication.java
package　com.w3codebox;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
//activer le cache
@EnableCaching
public class SpringBootCacheExampleApplication　
{
public static void main(String[] args)　
{
SpringApplication.run(SpringBootCacheExampleApplication.class, args);
}
}

Étape10: dans le nom Dans3dossier codebox.model src/main/java créez un paquet dans

Étape11: Dans le paquet modèle, créez un nom de Customer définir le contenu suivant dans les classes:

définir troisaccountno, customername, acounttypeetbalance。Utiliser Constructor pour générerConstructeur 。
Cliquez avec le bouton droit sur le fichier->Source->Utiliser les champs pour générer le constructeur->Sélectionner tout->GenererGenererGetters and Setters.
Cliquez avec le bouton droit sur le fichier->Source->Generer Getter et Setters->Sélectionner tout->Generer

Customer.java

Exemple

package　com.w3codebox.model;
public class Customer　
{
　　　　private int accountno;
　　　　private String customername;
　　　　private String accounttype;
　　　　private double balance;
　　　　public Customer(int accountno, String customername, String accounttype, double balance)　
　　　　{
　　　　　　　　this.accountno = accountno;
　　　　　　　　this.customername = customername;
　　　　　　　　this.accounttype　=　accounttype;
　　　　　　　　this.balance　=　balance;
　　　　}
　　　　public int getAccountno()　
　　　　{
　　　　　　　　return accountno;
　　　　}
　　　　public void setAccountno(int accountno)　
　　　　{
　　　　　　　　this.accountno = accountno;
　　　　}
　　　　public String getCustomername()　
　　　　{
　　　　　　　　return customername;
　　　　}
　　　　public void setCustomername(String customername)　
　　　　{
　　　　　　　　this.customername = customername;
　　　　}
　　　　public　String　getAccounttype()　
　　　　{
　　　　　　　　return　accounttype;
　　　　}
　　　　public　void　setAccounttype(String　accounttype)　
　　　　{
　　　　　　　　this.accounttype　=　accounttype;
　　　　}
　　　　public　double　getBalance()　
　　　　{
　　　　　　　　return　balance;
　　　　}
　　　　public　void　setBalance(double　balance)　
　　　　{
　　　　　　　　this.balance　=　balance;
　　　　}
}

Étape11: Dans le dossier src/main/java Créer un paquet nommé Dans3codebox.controller

Étape12: Dans le paquet Controller, créer un paquet nommé CustomerController de contrôleur, puis exécuter les opérations suivantes:

Utiliser l'annotation @RestController pour marquer la classe Controller 。 Utiliser l'annotation @RequestMapping pour définirCorrespondance。Nous avons déjà défini la correspondance/customerinfo 。CréerCachePour utiliser l'annotation @Cacheable pour obtenir des données. Nous avons déjà utilisé l'annotation value la définition de la propriété du nom du cache.Nous avonsont ajouté deux détails de clients

CustomerController.java

Exemple

package　com.w3codebox.controller;
import　java.util.Arrays;
import　java.util.List;
import　org.springframework.cache.annotation.Cacheable;
import　org.springframework.web.bind.annotation.RequestMapping;
import　org.springframework.web.bind.annotation.RestController;
import　com.w3codebox.model.Customer;
@RestController
public　class　CustomerController　
{
　　　　@RequestMapping("/customerinfo")
　　　　//définit un cache pour la valeur de retour du méthode
　　　　@Cacheable(value="customerInfo")
　　　　public　List　customerInformation()
　　　　{
　　　　　　　　System.out.println("customer　information　from　cache");
　　　　　　　　//ajout des détails du client à la liste
　　　　　　　　　　List　detail=Arrays.asList(new　Customer(5126890,"Charlie　Puth","Current　A/c",　450000.00),
　　　　　　　　　　　　　　　　　　　　　　　　new　Customer(7620015,"Andrew　Flintoff","Saving　A/c",　210089.00)
　　　　　　　　　　　　　　　　　　　　　　　);
　　　　　　　　return　detail;
　　　　}
}

Maintenant, exécutez l'application.

Étape13: ouvrir SpringBootCacheExampleApplication.java Fichier et exécutez-le en tant qu'application Java.

Étape14: ouvrirPostmanet envoie une URL avec http: //locahost: 8080/custmerinfo GET La requête retourne les détails du client, comme suit.

Exécution du programme SpringBoot Thymeleaf Spring Boot

Tutoriel SpringBoot

Cache SpringBoot

缓存抽象

Cache

为什么要使用缓存？

应缓存哪些数据？

缓存类型

内存缓存

Cache de base de données

Cache du serveur web

mécanisme de cache CDN

fournissent des copies locales du contenu.

pour améliorer les performances.

@EnableCaching

@CacheConfig

@Caching

@Cacheable

@CacheEvict

@CachePut

Spring Boot缓存依赖项

Spring Boot缓存示例