Explicação detalhada do ehcache integrado do Springboot para implementar o mecanismo de cache

O Ehcache é uma estrutura de cache em processo de java pura, com recursos rápidos e enxutos, e é o cacheProvider padrão no hibernado.

O Ehcache fornece uma variedade de estratégias de cache, divididas principalmente nos níveis de memória e disco, portanto, não há necessidade de se preocupar com problemas de capacidade.

O Spring-Boot é uma estrutura de integração rápida projetada para simplificar o processo inicial de construção e desenvolvimento de novas aplicações de mola. A estrutura usa uma maneira específica de configurá -la, para que os desenvolvedores não precisem mais definir configurações de caldeira.

Como o Spring-Boot não requer nenhum arquivo de configuração de caldeira, o Spring-Boot será um pouco diferente ao integrar algumas outras estruturas.

1. Spring-boot é uma estrutura para pacotes JAR gerenciados através do MAVEN. As dependências necessárias para a integração do ehcache são as seguintes

 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context-support</artifactId></dependency><dependency> <groupId>net.sf.ehcache</groupId> <artifactId>ehcache</artifactId> <version>2.8.3</version></dependency>

O arquivo pom.xml específico é o seguinte

 <? xml versão = "1.0" coding = "utf-8"?> <Projeto xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.ww3.org/2001/xmlschaMance xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.lclc.boot</groupId> <artifactId>boot-cache</artifactId> <Version> 0.0.1-SNAPSHOT </Version> <!-herdar os padrões de Spring Boot-> <aporel> <puperid> org.springframework.boot </groupid> <ArtifactId> Spring-Boot-Starter-Parent </Artifactid> <Versão> 1.1.3.Release </Versador> </Superiores </Superições <GrupidId> org.springframework.boot </frugiD> <stifactId> primavera-boot-starter-web </artifactId> </dependency> <pendence> <puperid> org.springframework.boot </frupid> <stiftid> spring-boot-starter-data-jpa <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>17.0</version> </dependency> <dependency> <groupId>org.sspringframework</groupId> <artifactId>spring-context-support</artifactId> </dependency> <dependency> <groupId>net.sf.ehcache</groupId> <TeRtifactId> ehcache </storkactid> <versão> 2.8.3 </sipers> </dependency> </dependências> <pendencyManagement> <pendências> </dependências> </dependências> </dependências> </dependências> </dependências> </dependências> </dependências> <burgins> </GroupInId> ou.PRUBRESM> </GroupS> </Groupins> </GroupS> </Groupins> </GroupS> </Groupins> </GroupS> </Groupins> </Groupins> </Groupins> </GroupS> </GroupS> </GroupS> </GroupS> </GroupS> <BroupS> ou. <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> <repositories> <repository> <id>spring-snapshots</id> <url>http://repo.spring.io/snapshot</url> <snapshots> <enabled>true</enabled> </snapshots> </repositório> <Ppository> <d> spring-me-milestones </dod> <url> http://repo.spring.io/milestone </url> </positório> </repository> </positório> <lampyRepository> <plupinRepository> <dring> springshapshots <wluginReposy> <lginRepository> <dring> spring-snapshots <wluginReposition> <luginReposition> <dring> springsnapshotes <url> http://repo.spring.io/snapshot </url> </pluginRepository> <cluginRepository> <id> spring-milestones </dod> <url> http://repo.spring.io/milestone </url> </cluginReposky> </url> </buflreposkery> </url> </cluginReposkery> </url> </cluginReposkery> </url> </cluginReposymery>

2. Usando o ehcache, precisamos de um ehcache.xml para definir alguns atributos de cache.

 <? xml versão = "1.0" coding = "utf-8"?> <ehcache xmlns: xsi = "http://www.w3.org/2001/xmlschema-innstance" xsi: nonamesChemalocation = "htttp:/ehche <diskStore path="java.io.tmpdir/Tmp_EhCache" /> <defaultCache eternal="false" maxElementsInMemory="1000" overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="0" timeToLiveSeconds="600" memoryStoreEvictionPolicy="LRU" /> <cache name = "Demo" eternal = "false" maxElementsInMemory = "100" OverflowTodisk = "False" DiskPerSistent = "False" TimeToidleSeconds = "0" timeToliveSeconds = "300" MemoryStoreEvictionPolicy = "LRU" /> < /ehcache>

Explique as tags neste arquivo XML.

(1) .DiskStore: é o caminho do cache, o ehcache é dividido em dois níveis: memória e disco. Esta propriedade define o local do cache do disco. Os parâmetros são explicados da seguinte forma:

1. User.home User Directory
2. User.dir Diretório de trabalho atual do usuário
3. java.io.tmpdir

(2) .DefaultCache: a política de cache padrão. Quando o Ehcache não consegue encontrar o cache definido, essa política de cache será usada. Apenas um pode ser definido.

(3) .cache: política de cache personalizada, uma política de cache personalizada. Os parâmetros são explicados da seguinte forma:

1. Propriedades do elemento de cache:
2. Nome: Nome do cache
3. MaxElementsInMemory: Número máximo de objetos em cache na memória
4. MaxElementsOndisk: o número máximo de objetos em cache no disco rígido. Se for 0, significa infinito
5. Eterno: Verdadeiro significa que o objeto nunca expira. Neste momento, as propriedades TimeToidleSeconds e TimetoliveSonds serão ignoradas, e o padrão é falso
6. OverflowTodisk: true significa que, quando o número de objetos em cache na memória atingir o limite MaxElementsInMemory, os objetos transbordados serão gravados no cache do disco rígido. NOTA: Se o objeto em cache deve ser gravado no disco rígido, o objeto deve implementar a interface serializável.
7. DiskspoolBufferSizemb: tamanho do cache do disco, o padrão é de 30 MB. Cada cache deve ter sua própria área de cache.
8. DiskPersistent: se deve reiniciar a máquina virtual de reiniciar os dados durante os dados
9. DiskexpirythReadIntervalSeconds: Thread de falha do disco Intervalo de tempo de execução, o padrão é de 120 segundos
10. TimeToidleSeconds: define o tempo máximo para permitir que o objeto fique ocioso, em segundos. Quando o objeto for acessado pela última vez, se o valor da propriedade TimeToidleSeconds exceder o valor da propriedade TimeToidleSeconds, o objeto expirará e o ehcache o limpará do cache. Esta propriedade é válida apenas se a propriedade eterna for falsa. Se o valor da propriedade for 0, significa que o objeto pode estar ocioso indefinidamente
11. TimetoliveSeconds: define o tempo máximo que o objeto permite existir no cache, em segundos. Quando o objeto for armazenado no cache, se o tempo no cache exceder o valor da propriedade TimetoliveSeconds, o objeto expirará e o ehcache o limpará do cache. Esta propriedade é válida apenas se a propriedade eterna for falsa. Se o valor da propriedade for 0, significa que o objeto pode existir no cache indefinidamente. TimetoliveSegunds deve ser maior que a propriedade TimeToidleSeconds para fazer sentido
12. MemoryStoreEvictionPolicy: Quando o limite MaxElementsInMemory for atingido, o ehcache limpa a memória de acordo com a política especificada. As políticas opcionais são: LRU (Política Padrão Recentemente usada, FIFO (Primeira In, Primeira Out) e LFU (número mínimo de visitas).

O Springboot suporta muitos métodos de cache: Redis, Goiaba, Ehcahe, Jcache, etc.

Explique a diferença entre Redis e Ehcache:

Redis: É um programa de corrida independente. Após a instalação, é manipulada usando JEDIS em Java. Por ser independente, se você escrever um programa de teste de unidade, coloque alguns dados no Redis e, em seguida, escreva outro programa para obter os dados, poderá obter os dados. , Assim,
Ehcache: É obviamente diferente de Redis, está ligado aos programas Java. Quando o programa Java está vivo, ele está vivo. Por exemplo, se você escrever um programa independente para colocar dados e, em seguida, gravar um programa independente para obter dados, não obterá dados. Os dados só podem ser obtidos em programas independentes.

3. Exponha o gerente EHCACHE ao contêiner de contexto de primavera.

 @Configuration // A anotação inicia o cache @enableCachingpublic Class CacheConfiguration {/** Ehcache Principal Manager*/ @Bean (name = "AppehcachEcachemanager") Public Ehcachecanager Ehcachemanager (EhCachemanagerFeanGoryBeanBeaniCeanArtEnBeanBeanArtEnBeanager (ehcachemanager ") (ehcachecheManager ehcachemanager (ehecAmEnTeMaTeNaCeanBeanBeanBeanAnCeanAr. } / * * De acordo com as configurações de compartilhado ou não, a primavera cria uma base de ehcache através de Cachemanager.Create () ou New Cachemanager (), respectivamente. */ @Bean public ehcachemanagerFactoryBean ehcachemanagerFactoryBean () {EhcachemanagerFactoryBean CachemanagerFactoryBean = new EhcachemanagerFactoryBean (); CachemanagerFactoryBean.SetConfigLocation (novo ClassPathResource ("conf/ehcache-app.xml")); CachemanagerFactoryBean.Setshared (True); Retornar CachemanagerFactoryBean; }}

@Configuration: ANOTATADO PARA Spring-Boot, anotado principalmente como uma classe de configuração, e a prioridade é dada para digitalização.

@Bean: Adicione o feijão ao recipiente da mola.

Todas as configurações são feitas até agora, e a integração da estrutura através da botem mola é simples.

4. Use Ehcache

O uso do ehcache é principalmente através do mecanismo de cache da mola. Implementamos o mecanismo de cache da mola usando o EHCACHE, para que possamos usar o mecanismo de cache da mola completamente em termos de uso.

Algumas notas estão envolvidas:

@Cacheable: responsável por adicionar o valor de retorno do método ao cache, parâmetro 3
@Cacheevict: responsável pela limpeza do cache, parâmetro 4

Explicação do parâmetro:

1. Valor: o nome da localização do cache não pode estar vazio. Se o ehcache for usado, é o nome do cache declarado em ehcache.xml
2. Chave: A chave em cache, o padrão está vazio, o que significa o tipo de parâmetro e o valor do parâmetro do método usado como chave, e suporta Spel
3. Condição: condição de acionamento, somente se a condição for atendida será adicionada ao cache. O padrão está vazio, o que significa que todos eles são adicionados ao cache e suporta spel
4. Allentries: Parâmetro Cacheevict, True significa limpar todos os caches no valor, o padrão é falso

Sem mais delongas, basta fazer o upload do código:

 @ServicePublic Class CacheDemoserviceImpl implementa Cachedemoservice {/** * Chave do cache */public static final string thing_all_key = "/" thing_all/""; /*** O atributo de valor indica qual política de cache usar. A política de cache está em ehcache.xml */ public static final string Demo_cache_name = "Demo"; @Cacheevict (value = Demo_cache_name, key = thing_all_key) @Override public void Create (coisa da coisa) {long id = getNextId (); coisa.setId (id); data.put (id, coisa); } @Cacheable (value = Demo_cache_name, key = "#thing.getId () + 'coisa'") @Override Public Things FindById (longo id) {System.err.println ("sem cache!" + ID); retornar data.get (id); } @Cacheable (value = Demo_cache_name, key = thing_all_key) @Override public List <Shing> findall () {return lists.newArrayList (data.values ​​()); } @Override @cacheput (value = Demo_cache_name, key = "#thing.getid ()+'coisa'") @cacheevict (value = Demo_cache_name, key = thing_all_key) public What update (coisa coisa) {System.out.println (coisa); data.put (thing.getId (), coisa); coisa de retornar; } @Cacheevict (value = Demo_cache_name) @Override public void Delete (longo id) {data.remove (id); }}

5. Você só precisa anotar o método da camada de serviço por meio de anotações e pode usar o cache, armazenar o cache no Find ** e limpar o cache em excluir ** e atualizar **.

Explicação detalhada das anotações de cache

@CacheConfig: É usado principalmente para configurar algumas configurações de cache comuns que serão usadas nesta classe. Aqui @CacheConfig (Cachenames = "Usuários"): o conteúdo retornado no objeto de acesso a dados está configurado para ser armazenado no objeto de cache chamado Usuários. Também podemos defini -lo diretamente através do próprio nome do cache do @Cacheable sem usar esta anotação.

@Cacheable: o valor de retorno da função findbyname configurado será adicionado ao cache. Ao mesmo tempo, ao consultar, ele receberá o cache primeiro e, se não existir, o acesso ao banco de dados será iniciado. Esta anotação tem os seguintes parâmetros:

1. Valor e Cachenames: Dois parâmetros equivalentes (Cachenames é adicionado à primavera 4 como um alias para valor), que é usado para especificar o nome da coleção do armazenamento do cache. Como @cacheconfig é adicionado na primavera 4, o atributo de valor que foi originalmente exigido na primavera 3 também se tornou um não essencial
2. Chave: o valor da chave armazenado na coleta de mapas de objetos de cache não é necessário. Por padrão, todos os parâmetros da função são combinados como o valor da chave. Se você configurar você mesmo, precisará usar expressões de spel, como: @cacheable (key = "#p0"): use o primeiro parâmetro da função como o valor da chave em cache. Para mais detalhes sobre expressões de SPEL, consulte o documento oficial.
3. Condição: As condições para objetos de cache não são necessárias e também são necessárias expressões de spel. Somente conteúdo que atenda às condições de expressão será armazenado em cache. Por exemplo: @cacheable (key = "#p0", condiciona = "#p0.length () <3"), o que significa que ele será armazenado em cache apenas quando o comprimento do primeiro parâmetro for menor que 3. Se o usuário da AAA nessa configuração não for intermediário, os leitores podem experimentar e experimentá -lo por conta própria.
4. A menos que: outro parâmetro condicional do cache, que não é necessário, requer o uso da expressão do SPEL. O que o torna diferente do parâmetro de condição está em seu tempo de julgamento. Essa condição é julgada somente após a chamada função, para que possa ser julgada pelo resultado.
5. KeyGenerator: usado para especificar o gerador de chaves, não é necessário. Se você precisar especificar um gerador de chave personalizado, precisamos implementar a interface org.springframework.cache.intercept.keygenerator e usar esse parâmetro para especificá -lo. Deve -se notar que este parâmetro e chave são mutuamente exclusivos
6. Cachemanager: usado para especificar qual gerenciador de cache usar, não é necessário. Use apenas se houver múltiplos
7. CacheResolver: é usado para especificar qual analisador de cache usar, não é necessário. Você precisa implementar seu próprio analisador de cache através da interface org.springframework.cache.intercept.cacheresolver e especifique -o com este parâmetro.

Além das duas anotações usadas aqui, há também as seguintes anotações principais:

@Cacheput: configurado em uma função, ele pode ser armazenado em cache de acordo com os parâmetros e define condições. Ao contrário do @cacheable, ele realmente chama a função sempre, por isso é usada principalmente para operações de adição de dados e modificação. Seus parâmetros são semelhantes a @cacheable. Para funções específicas, consulte a análise acima dos parâmetros @cacheable.

@Cacheevict: configurado em funções, geralmente usado em métodos de exclusão, para remover dados correspondentes do cache. Além dos mesmos parâmetros que @cacheable, ele possui os dois parâmetros a seguir:

1. Allentries: não essencial, padrão para false. Quando verdadeiro, todos os dados são removidos
2. Antes da vocação: não essencial, o padrão é falso e os dados serão removidos após a chamada do método. Quando verdadeiro, os dados são removidos antes de chamar o método.

O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.