Pode -se dizer que o cache é uma maneira muito eficaz e simples de acelerar a resposta do serviço. No campo de cache, existem muitas estruturas bem conhecidas, como ehcache, goiaba, avelquet, etc. Como um banco de dados de valor-chave, o Redis também se tornou uma ferramenta popular de cache de dados devido ao seu recurso.
Da maneira tradicional, o código de processamento de cache é muito inchado.
Por exemplo: precisamos adicionar uma função de consulta à função de cache, que requer aproximadamente três etapas.
1. Antes da execução da função, precisamos verificar se há dados no cache. Se existir, retorne os dados em cache.
2. Se não existir, precisará ser consultado nos dados do banco de dados.
3. Finalmente, armazene os dados no cache. Quando essa função é chamada da próxima vez, você pode usar os dados em cache diretamente para reduzir a pressão no banco de dados.
Então, quanto código é necessário para implementar as três etapas acima? Aqui está um exemplo:
A parte vermelha na imagem acima é todo o código do modelo, mas o código que está realmente relacionado a essa função é responsável apenas por 1/5. Para todas as funções que precisam implementar funções de cache, é necessário o código de modelo inchado. É uma solução extremamente deselegante.
Então, como podemos recuperar o código inchado ao tempo mais fresco?
AOP não é a melhor solução para este código de estilo de modelo? Felizmente, não precisamos mais implementar as seções por nós mesmos. O Springcache nos forneceu uma boa seção. Só precisamos fazer configurações simples para retornar ao original, como o seguinte:
Você só precisa adicionar anotação. Você nem precisa alterar o código original. Você está ansioso para experimentar?
Existem apenas três etapas para configurar o Springcache:
Etapa 1: Adicione dependências relevantes:
<Depencency> <PuerpId> Redis.clients </frupiD> <TRAFACTID> JEDIS </STIFACTID> <Versão> 2.9.0 </sipers> </dependency> <pendency> <puperid> org.springframework.data </groupid> <tifactId> spring-data-redis </artefactId> <Depencency> <GrupidId> org.apache.commons </frugiD> <ArtifactId> Commons-Lang3 </stifactId> <Version> 3.3.2 </versão> </dependency>
Etapa 2: Configurar Springcache, Redis Connection e outras informações
ApplicationContext-redis.xml
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/schema/mvc" xmlns: cache = "htttp://schema/mvc" xmlns: cache = "htttp://schema" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-bans-4.xsd http://wwww.springfringwanswanswans-.2.xsd http://wwww.springfringwanswans.1.xsd http://wwwwem.springfringwanswans-42.xsd http://wwww.springfringwanswansweans-42.xsd http://wwwwem http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd http://wwwwwwww.springframework.org/4.2.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-4.2.xsd "> <!-Configuration Carreging-> <Contexto: Property-Tolder Location =" ClasspathPathpath:*. cache-manager = "cachemanager" /> <!-Redis Connection pool-> <bean id = "poolconfig"> <propriedade name = "maxidle" value = "$ {redis.maxidle}" /> <names name = "maxwaitmillis" value "$ {redis.maxwait}" value = "$ {Redis.testonborrow}"/> </bean> <!-Connection Factory-> <bean id = "JedisconnectionFactory" P: host-name = "$ {Redis.host}" P: Port = "$ {Redis.port}" P: senha = "$ {Redis.} modelo-> <bean id = "redistemplate"> <propriedade name = "ConnectionFactory" ref = "jedisconnectionFactory" /> </i bean> <bean id = "cachemanager"> <nome do nome = "cache"> <Set> <!-você pode configurar múltiplos redis aqui-> <Bean> <er property ">" Redist> <! value = "Content"/> <!-O nome correspondente ao nome deve ser usado na anotação da classe ou método-> </i bean> </set> </propriedade> </i bean> </sicheans>Arquivo Redis.Properties:
# Redis Configurações # servidor ip redis.host = 192.168.100.55 # Porta do servidor Redis.port = 6379 # servidor passa redis.pass = # use dbindex redis.database = 0 #Max IDEL Instância de jedisredis.maxidle = 300 # se espera muito, throwSConnectEngEngomShred. Instância, o que você recebe é tudo útil.testonborrow = true
O terceiro passo é escrever a classe de implementação da interface do cache
A primavera fornece apenas uma interface abstrata para o cache e chama funções através de interfaces. Não existe uma classe de implementação específica; portanto, precisamos implementar operações específicas.
Na configuração acima, podemos ver que cada classe de implementação injetará uma instância do Redistemplate e podemos operar o Redis através do Redistemplate
package com.cky.rest.utils;import java.io.Serializable;import org.apache.commons.lang3.SerializationUtils;import org.springframework.cache.Cache;import org.springframework.cache.support.SimpleValueWrapper;import org.springframework.dao.DataAccessException;import org.springframework.data.redis.connection.redisconnection; importação org.springframework.data.redis.core.rediscallback; importar org.springframework.data.redis.core.redistemplate; public classe rediscache implements {private redistemplate <stratemply, object. nome de string privado; @Override public void clear () {System.out.println ("-------------"); redistemplate.execute (novo Rediscallback <String> () {@Override public String doinredis (conexão de redisconnection) lança dataAccessException {Connection.flushdb (); retornar "OK";}}); } @Override public void despet (chave do objeto) {System.out.println ("-----------------"); Final String keyf = key.toString (); redistemplate.execute (novo rediscallback <long> () {@Override public Long Doinredis (conexão de redisconnection) lança dataAccessException {return Connection.del (keyf.getBytes ());}}); } @Override public ValueWrapper get (chave do objeto) {System.out.println ("---------------------"+key.toString ()); Final String keyf = key.toString (); Objeto objeto = nulo; Object = Redistemplate.execute (novo Rediscallback <Becut> () {@Override public Object doinredis (conexão de redisconnection) lança dataAccessException {byte [] key = keyf.getBytes (); byte [] value = Connection.get (key); if (value ==---1- {); Serialização ValueWrapper obj = (objeto! = Null? New SimpleValueWrapper (objeto): null); System.out.println ("-----------------------------------"+Obj); retornar obj; } @Override public void put (chave do objeto, valor do objeto) {System.out.println ("---------------------"); System.out.println ("key ----:"+key); System.out.println ("key ----:"+valor); Final String KeyString = key.toString (); Valor final do objeto = valor; LiveTime final = 86400; redistemplate.execute (novo Rediscallback <long> () {@Override public doinredis (conexão de redisconnection) lança dataAccessException {byte [] keyb = keystring.getBytes (); byte [] valueb = serialization.Serialize ((serializable); Connection.Expire (KeyB, LiveTime); } @Override Public <T> t Get (Object arg0, classe <t> arg1) {// TODO Método Gerado de Auto-Goletal Retorno Null; } @Override public string getName () {return this.name; } @Override public Object getNativeCache () {return this.redistemplate; } @Override public valueWrapper putifabsent (objeto arg0, object arg1) {// TODO Method Auto-Gerated Stub Return NULL; } public redistemplate <string, object> getredistemplate () {return redistemplate; } public void setRedSplate (redistemplate <string, object> redistemplate) {this.redistemplate = redistemplate; } public void setName (nome da string) {this.name = name; }}Houve dois erros durante o processo de configuração:
1.xxxx.classnotfoundException Finalmente, descobri que o download do jar está incompleto. Basta excluir a pasta de pacote JAR correspondente do repositório local Maven e baixá -lo novamente.
2.xxxx.methodnotfoundException Esta situação é a versão errada, basta alterar para a versão na primeira etapa.
Uso de anotações comuns no Springcache:
@Cacheable anotação
A anotação mais usada em cache o valor de retorno do método anotado. Como funciona: Primeiro procure no cache, se nenhum método for executado e o resultado for armazenado em cache, e os dados serão retornados. O nome do cache desta anotação deve ser especificado e corresponde ao valor do nome de um cache em caches no Cachemanager. Pode ser especificado usando valor ou cachenames.
Se nenhum atributo de chave for especificado, o Spring usará o gerador de chave primária padrão para gerar chaves primárias. Você também pode personalizar a chave primária e as expressões de spel podem ser usadas na chave. do seguinte modo:
@Cacheable (Cachenames = "content", key = "#user.userId") Usuário público getUser (usuário do usuário) {xxxxx}Você pode usar o atributo de condição para adicionar condições ao cache, como segue:
@Cacheable (Cachenames = "content", key = "#user.userId", condicional = "#user.age <40") user getUser (usuário do usuário) {xxxxx}Anotação @cacheput
Execute o método primeiro e, em seguida, coloque o valor de retorno de volta no cache. Pode ser usado como atualizações em cache.
@Cacheevict anotação
Esta anotação é responsável por remover explicitamente os dados do cache. Geralmente, os dados em cache têm uma data de validade e os dados também serão removidos quando expirar.
Esta anotação tem dois atributos adicionais:
Se o Allentries remove todas as entradas de cache.
Antes da vocação: preencha a operação de remoção antes ou depois que o método for chamado. verdadeiro/falso
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.