English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
O EhCache é um cache open-source baseado em Java, usado para melhorar o desempenho. A versão atual do Ehcache é 3 . Ele fornece JSR-107 implementação do gerenciador de cache. Podemos usá-lo diretamente.
Elerápido,leve, escaláveleflexível。 Ele nos permite executarserializáveleobjeto Ele oferece funcionalidades como LRU, LFU, FIFO etca política de expulsão do cache. Ele armazenará o cache emmemóriaedisco(SSD)中. Ele depende de SLF4J para registrar. Ele já foi completamente implementado JSR-107 e Jcache Ele suporta através de JGroups ou JMS e RMI para realizar cache distribuído. Ele usaLinguagem de consulta fluentepara realizar buscas distribuídas.
O cache usa vários modos de acesso. O EhCache usa os seguintes modos:
Cache-lado Cache-como-SoR (sistema-de-registro) Read-through Write-through Write-behind
在 Cache reservaNo modelo, primeiramente, o aplicativo consulta o cache. Se encontrar dados, ele retornará diretamente os dados. No caso contrário, ele obterá dados do SoR, armazenará-os no cache e então retornará.
cache-como-SoR modos representam operações de leitura e escrita do cache no SoR. Reduz a responsabilidade do aplicativo. Usa combinações de modos de leitura e escrita, incluindo Leitura direta, escrita direta,e de escrita pós-uso. Isso reduz a dificuldade do aplicativo. Permite que o cache resolva problemas de raios
Read-throughO modo também replica o cache-ao ler dados do cache no modo de leitura reservada. A diferença entre o modo de leitura e o modo de leitura do cache é que o modo de leitura implementa CacheEntryFactory interface. Ele orienta o cache sobre como ler objetos do cache. Melhor usar EhCache instance como SelfPopulatingCache instância.
Write-throughO modo pode ainda replicar o modo de cache reserva ao escrever dados no cache. A diferença entre o modo de escrita direta e o modo de cache reserva é que o modo de escrita direta implementa CacheWriter interface. Ele configura o cache para modos de escrita direta e escrita pós-uso. Ele escreve dados no SoR no mesmo thread de execução.
Write-behind. Em comparação com os outros três modos, no modo de atraso configuráveldepois, ele modifica as entradas de cache. O atraso pode variar em segundos, minutos, um dia, uma semana,ou Por muito tempo. Ao mesmo tempo, ele também coloca os dados em fila para que sejam escritos no mesmo thread de execução posteriormente.
A gravação de dados após o uso ocorre fora do escopo da transação. Isso significa que ele cria uma nova transação para submeter dados diferentes da transação principal no SoR.
O EhCache nos permite usar várias áreas de armazenamento de dados, como pilha, disco e cluster. Podemos configurar um cache de múltiplos armazenamentos (usando várias áreas de armazenamento). Pode ser agendado como camada.
Essas camadas são organizadas em ordem. A mais baixa é camada autorizada，outra camada é camada de cache. Também conhecido como nearer ou near cache. A camada de cache pode ter várias áreas de armazenamento. Os dados mais quentes são mantidos na camada de cache, pois são mais rápidos do que a camada autorizada. Em comparação com a camada de cache, outros dados são mantidos na camada autorizada, mais lento mas mais rico.
Os tipos de armazenamento de dados suportados pelo EhCache são Quatro:
On-Heap Store Off-Heap Store Disk Store Clustered Store
Ele armazena entradas de cache na memória heap do Java. Ela compartilha o armazenamento com o aplicativo Java. Isso é rápido, porque usa a pilha, mas o espaço de armazenamento é limitado. O coletor de lixo também scanning o armazenamento em pilha.
Ele usa a memória principal (RAM) para armazenar entradas de cache. O coletor de lixo não o scanning. É mais lento do que o armazenamento em pilha, porque as entradas de cache são movidas para o armazenamento em pilha antes do uso. Seu tamanho é limitado.
Ele usa o disco para armazenar entradas de cache. É muito mais lento do que o armazenamento baseado em RAM (acima e abaixo da memória). Se usar o modo de armazenamento em disco, é melhor usar um disco dedicado.
它将缓存条目存储在远程服务器上。它比堆外存储慢。它可能具有提供高可用性的故障转移服务器。
上图显示了
一个应用程序可能具有多个缓存管理器。 许多缓存可以由缓存管理器处理。 缓存可以使用多个层来存储缓存条目。 EhCache将最近使用或经常使用的数据放在更快的层(缓存层)中。
将 EhCache jar放在类路径中。配置 xml 并将其放在类路径中。创建一个引用缓存。
在以下示例中，我们将在应用程序中配置EhCache。
Passos1: 打开 Spring Initializr https://start.spring.io/。
Passos2: 选择Spring Boot版本 2.3.0 M2 。
Passos3: 提供 Group名称。我们提供了组名 com.w3codebox。
Passos4: 提供 Artifact我们提供了Artifact spring-boot-ehcache-example。
Passos5: 添加 Spring Web 依赖项。
Passos6: 单击 Generate (生成)按钮。当我们单击"生成"按钮时，它将与应用程序相关的所有规范包装到一个 Jar 文件中，并将其下载到本地系统。
Passos7: 提取 jar文件。
Passos8: 复制文件夹并将其粘贴到STS工作区中。
第9步: 导入项目。
文件->导入->现有 Maven 项目->下一步->浏览->选择文件夹spring-boot-ehcache-example->选择文件夹->完成
导入项目需要时间。
Passos10: 从 Maven 存储库 https://mvnrepository.com/并将其粘贴到 pom.xml中arquivo.
spring-boot-starter-cache ehcache 3 cache API。
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>
Agora, precisamos configurar ehcache.xml arquivo.
Passos11: Abrir arquivo.properties arquivo, e configure o EhCache com as seguintes propriedades.
arquivo.properties
#configurar ehcache.xml spring.cache.jcache.config=classpath:ehcache.xml
Passos12: Abrir SpringBootEhcacheExampleApplication.java arquivo, e use a anotação @EnableCaching habilitar cache
SpringBootEhcacheExampleApplication.java
package com.w3codebox;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
//habilitar a função de gerenciamento de cache
@EnableCaching
public class SpringBootEhcacheExampleApplication
{
public static void main(String[] args)
{
SpringApplication.run(SpringBootEhcacheExampleApplication.class, args);
}
}
package com.w3codebox;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;
@Configuration
//habilitar caching
@EnableCaching
public class CacheConfig
{
}
Passos13: criar uma classe. Já criamos o pacote com.w3codebox no criou um nome de classe Student. dentro da classe, execute as seguintes operações:
criar cinco variáveisid, nome, genero,e gerarusar Constructor
clique com o botão direito no arquivo->origem->usar campo para gerar construtor->selecionar tudo->gerar gerarGetters and Setters。
clique com o botão direito no arquivo->origem->gerar Getter e Setter->selecionar tudo->gerar gerar toString() clique com o botão direito no arquivo->origem->gerar toString()->gerar
完成上述所有步骤后，类如下所示。
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 + "]";
}
}
Passos14: 创建用于管理学生的 服务类。我们已经创建了名称为 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>
Agora, já criamos todos os arquivos necessários. Após a criação de todos os arquivos, o diretório do projeto será como o seguinte:
Vamos executar o aplicativo.
Passos16: Abrir SpringBootEhcacheExampleApplication.java Arquivo, e como Aplicativo Java.
Ele exibe a seguinte saída:
Obtendo Estudantes do Cache [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]