English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutorial de SpringBoot

Cache do SpringBoot

O framework Spring fornece cache de forma transparente em aplicações Spring. No Spring,Abstração de cacheÉ um mecanismo que permite usar consistentemente várias métodos de cache sem afetar o código.

Abstração de cache

O mecanismo de abstração de cache é aplicável a Métodos Java. O principal objetivo do uso da abstração de cache é, com base na informação existente no cacheReduzirNúmero de execuções. Ele é aplicável a métodos caros, como CPU ou Ligação IO.

Cada vez que o método é chamado, a abstração aplica o comportamento de cache ao método. Ele verifica se o método já foi executado para os parâmetros dados.

Se sim, retorne o resultado do cache sem executar o método real.Se não, execute primeiro este método, armazene o resultado no cache e retorne-o ao usuário.

Atenção: Este método é aplicável apenas para garantir que o mesmo resultado seja retornado para a entrada dada. O número de execuções deste método não importa.

Os desenvolvedores notam duas coisas ao lidar com abstração de cache.

Declaração de cache: Ele identifica o método que precisa ser cacheado. Configuração de cache: Usado para armazenar e ler dados de cache de backup.

cache

O cache é uma parte temporária da memória (RAM). Ele está entre o aplicativo e o banco de dados persistente. Ele armazena dados usados recentemente, assim minimizando o número de acertos no banco de dados. Em outras palavras, o cache é para armazenar dados para referência futura.

Por que usar cache?

A principal razão para usar cache é acelerar e tornar mais barato o acesso aos dados. Quando recursos altamente solicitados são solicitados várias vezes, o cache de recursos é geralmente benéfico para os desenvolvedores, pois pode fornecer respostas rápidas. O uso de cache no aplicativo pode melhorar o desempenho do aplicativo. Em comparação com a obtenção de dados do banco de dados, o acesso aos dados da memória é sempre mais rápido. Isso reduz os custos monetários e de oportunidade.

Quais dados devem ser cacheados?

Dados que não são alterados frequentemente.Consultas de leitura frequentemente usadas, cujos resultados não mudam pelo menos por um tempo durante cada chamada.

Tipos de cache

HáQuatroOs tipos de cache são os seguintes:

Cache na memória数据库缓存 O cache mais popular de banco de dados é o cache de nível 1 do Hibernate. por exemplo, cópias de páginas da web fornecidas por servidores web. Quando o usuário acessa a página pela primeira vez, ela é armazenada em cache. Se o usuário solicitar o mesmo conteúdo novamente, o cache fornecerá a cópia da página. Isso evita a sobrecarga do servidor. O cache do servidor web pode melhorar a velocidade de entrega da página e reduzir o trabalho que o servidor backend precisa fazer.

Cache em memória

O cache em memória pode melhorar o desempenho do aplicativo. Este é um área frequentemente usada. Memcached e Redis É um exemplo de cache na memória. Ele armazena pares de chave-valor entre o aplicativo e o banco de dados. O Redis é umDistribuído na memóriaFerramenta de cache avançada, usada para backup e restore de funções. Também podemos gerenciar o cache em clusters distribuídos.

数据库缓存

cache do banco de dadosO cache do banco de dados é um mecanismo que gera páginas dinamicamente conforme necessário (dinâmico) a partir de dados do banco. Do banco de dados. Ele envolve o cliente, o servidor do aplicativo web e o banco de dados.multiplosambiente. Ao distribuir o trabalho de consulta, ele melhoraeescalabilidadeperformance

O cache mais popular de banco de dados é o cache de nível 1 do Hibernate.

cache do servidor webO cache do servidor web é um tipo de armazenamento de dados parareutilização

por exemplo, cópias de páginas da web fornecidas por servidores web. Quando o usuário acessa a página pela primeira vez, ela é armazenada em cache. Se o usuário solicitar o mesmo conteúdo novamente, o cache fornecerá a cópia da página. Isso evita a sobrecarga do servidor. O cache do servidor web pode melhorar a velocidade de entrega da página e reduzir o trabalho que o servidor backend precisa fazer.

mechanismo de cache do CDN CDNrepresentarede de entrega de conteúdoÉ um componente usado em aplicativos web modernos. Atravéscópiaarquivos comuns (por exemplo, páginas HTML, folhas de estilo), que pode melhorar a entrega de conteúdo. JavaScript, imagens, vídeos, etc.) distribuídos em um grupo de cópias globalmente distribuídas

servidor de cache próximo.Esta é a razão pela qual o CDN está se tornando cada vez mais popular. O CDN alivia a carga da fonte do aplicativo e melhora a experiência do usuário. Ele pega domargem de cache(servidor de cache mais próximo do usuário final) ouPonto de Presença (PoP)

o cache fornece cópias locais do conteúdo.

cacheo cache e o buffer
o buffero cache é baseado em.o buffer é baseado emBuffer FIFO
É o tamanho do cache de página.É um bloco original em memória./O buffer.
ele viveumuito longoperíodo.ele viveucurtoperíodo.
nósler do cache.nósescreverpara o buffer.
ele armazenarealdados do arquivo.ele armazena arquivosmetadados.
ele melhora ler desempenho.ele melhoraescreverdesempenho.

anotações de cache do Spring Boot

@EnableCaching

Esta é uma anotação de nível de classe. Podemos usar ativa o cache no aplicativo Spring Boot com a anotação @EnableCaching.Ele org.springframework.cache.annotation definido no pacote. Ele trabalha com @Configuration usar classes juntas.

Se não houver instância de CacheManager definida, a configuração automática ativa o cache e configura CacheManager Ele scanning específicos provedores, se não encontrar, usará cache concorrente HashMap cria cache em memória.

Exemplo

No seguinte exemplo, @EnableCaching Anotação ativa o mecanismo de cache.

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

@CacheConfig

É uma anotação de nível de classe, que oferece configurações gerais de cache. Ela diz ao Spring onde armazenar o cache da classe. Quando usamos anotações para adicionar anotações à classe, ela fornece um conjunto de configurações padrão para qualquer operação de cache definida na classe. Usando anotações, não precisamos declarar várias vezes.

Exemplo

Neste exemplo,funcionáriosé o nome do cache.

@CacheConfig(cacheNames={"employee"})　
public class UserService
{
//algum código
}

@Caching

Quando precisamos de duas anotações ao mesmo tempo @CachePut ou @CacheEvict usando o mesmo método. Em outras palavras, quando queremos usar várias anotações do mesmo tipo, usamos.

Mas O Java não permite que várias anotações do mesmo tipo sejam declaradas para a mesma declaraçãométodo. Para evitar esse problema, usamos @Caching anotação.

Exemplo

Neste exemplo, usamos a anotação @Caching E todos @CacheEvict anotação de grupo.

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

@Cacheable

É uma anotação de nível de método. Ela define um cache para o valor de retorno do método. O framework Spring gerencia as solicitações e respostas de cache especificadas nas propriedades da anotação. A anotação @Cacheable contém mais opções. Por exemplo, podemos usar value ou cacheNames da anotaçãonome do cache.

Também podemos especificar a propriedade chave propriedade, usada para identificar cada entrada no cache de forma única. Se o chave não for especificada, o Spring usará o mecanismo padrão para criar a chave.

Exemplo

Neste exemplo, cacheamos< cacheStudentInfo,e id método studentInfo()O valor de retorno é a chave única, usada para identificar o cache.

@Cacheable(value="cacheStudentInfo", key="#id")public List studentInfo()
{
//algum código　
return studentDetails;
}

Também podemos aplicar condições usando a propriedade condition em anotações. Quando aplicamos condições em anotações, elas são chamadas deCache condicional.

Por exemplo, se o comprimento do nome do parâmetro for menor que20, então o método seguinte será cacheado.

@Cacheable(value="student",　condition="#name.length<20)public　Student　findStudent(String　name)
{
//algum código
}

@CacheEvict

é uma anotação de nível de método. Quando queremos deletar dados antigos ou não usados do cache, usaremos isso. Ela precisa de um ou mais caches afetados pela operação. Também podemos especificar uma chave ou condição nele. Se quisermos uma remoção de cache ampla, a anotação @CacheEvict oferece um nome allEntries dos parâmetros. Ele expulsa todos os itens, em vez de expulsar um item com base na chave.

Um ponto importante sobre a anotação @CacheEvict é que ela pode ser usada com métodos void, pois esse método atua como gatilho. Ele evita o retorno de valores. Por outro lado, a anotação @Cacheable precisa de um valor de retorno, que é usado para adicionar/atualizar os dados no cache. Podemos usar a anotação @CacheEvict da seguinte forma:

remover todo o cache:

@CacheEvict(allEntries=true)

remover itens por chave:

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

Exemplo

Os seguintes métodos anotados a seguir são removidos do cache student_data remover todos os dados.

@CacheEvict(value="student_data",　allEntries=true)　//remover todas as entradas do cache
public　String　getNames(Student　student)　
{
//algum código
}

@CachePut

é uma anotação de nível de método. Quando queremosatualizarusar isso quando o cache deve ser atualizado sem interferir na execução do método. Isso significa que o método sempre será executado e seu resultado será colocado no cache. Ele suporta os atributos da anotação @Cacheable.

É importante notar que, devido ao comportamento diferente dos anotações @Cacheable e @CachePut, elas são diferentes. A diferença sutil entre as anotações @Cacheable e @CachePut é que @ Cacheable Comentáriospular a execução do métodoenquanto @CachePut ComentáriosExecute este métodoe, em seguida, colocará o resultado no cache.

Exemplo

Os seguintes métodos atualizarão o cache em si.

@CachePut(cacheNames="employee",　key="#id")　　//atualizando　cachepublic　Employee　updateEmp(ID　id,　EmployeeData　data)
{
//algum código
}

Spring Boot缓存依赖项

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

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

Spring Boot缓存示例

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

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

Passos2: 选择Spring Boot版本 2.3.0.M1.

Passos2: 提供群组名称。我们提供了 com.w3codebox。

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

Passos5: 添加依赖项 Spring Web e Spring Cache抽象。

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

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

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

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

导入需要一些时间。

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

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.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>Projeto de demonstração para 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>

Passos9: abrir SpringBootCacheExampleApplication.java arquivo, adicionando anotações @EnableCaching ativa o cache. 

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

Passos10: No nome com.w3pasta codebox.model src/main/java Crie um pacote.

Passos11: No pacote model, crie um nome de Customer definir o seguinte conteúdo:

definir trêsaccountno, customername, acounttypeebalance.>Usar Constructor para gerarConstrutor .
Clique com o botão direito no arquivo->Fonte->Usar campo para gerar construtor->Selecionar tudo->GerarGerarGetters and Setters.
Clique com o botão direito no arquivo->Fonte->Gerar Getter e Setter->Selecionar tudo->Gerar

Customer.java 

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;
　　　　}
}

Passos11: na pasta src/main/java crie um pacote chamado com.w3codebox.controller

Passos12: no pacote Controller, crie um pacote chamado CustomerController classe controladora, e então execute as seguintes operações:

usar a anotação @RestController marca a classe como Controller . usar a anotação @RequestMapping define para o controladormapeamento.já definimos o mapeamento/customerinfo .criarcachepara usar a anotação @Cacheable para obter dados. já utilizamos a anotação value definimos o nome da cache.Nósadicionou duas detalhes de clientes.

CustomerController.java 

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")
　　　　//define um cache para o valor de retorno do método
　　　　@Cacheable(value="customerInfo")
　　　　public　List　customerInformation()
　　　　{
　　　　　　　　System.out.println("informações do cliente do cache");
　　　　　　　　//adicionando detalhes do cliente na Lista
　　　　　　　　　　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;
　　　　}
}

Agora execute o aplicativo.

Passos13: abrir SpringBootCacheExampleApplication.java Arquivo e execute-o como aplicativo Java.

Passos14: abrirPostman, e envia uma URL com http: //locahost: 8080/custmerinfo do GET Solicitação. Ela retorna detalhes do cliente, conforme abaixo.


provedor de cache do SpringBootSpringBoot EhCaching
Execução do programa SpringBootThymeleaf no Spring Boot