1. O que é cache de cache
A palavra cache veio pela primeira vez do design da CPU
Quando a CPU deseja ler os dados, ele primeiro olha para o cache da CPU e o lê imediatamente e o envia para a CPU para processamento, se for encontrado; Se não for encontrado, é lido da memória relativamente lenta e enviada à CPU para processamento. Ao mesmo tempo, o bloco de dados em que esses dados está localizado é chamado para o cache, para que todo o bloco de dados possa ser lido no cache no futuro sem chamar a memória. É esse mecanismo de leitura que torna a taxa de acertos de cache de leitura da CPU muito alta (a maioria das CPUs pode atingir cerca de 90%), o que significa que 90% dos dados que a CPU lerá na próxima vez está no cache da CPU e apenas cerca de 10% precisam ser lidos da memória. Isso salva muito o tempo da CPU para ler diretamente a memória e também torna impossível para a CPU ler dados sem esperar. Em geral, a ordem em que a CPU lê os dados é cache primeiro e depois a memória.
Mais tarde, fomos para o cache de disco rígido, depois para o cache do aplicativo, cache do navegador, cache da web, etc.!
Cache é rei! !
Cache da primavera
O Spring Cache é um conjunto completo de soluções de cache de aplicativos fornecidas pelas aplicações de mola.
O próprio cache da primavera não fornece implementação de cache, mas usa interfaces unificadas e especificações de código, configurações, anotações etc. para permitir que você use vários caches em aplicativos de primavera sem precisar prestar muita atenção aos detalhes do cache. Com o cache da primavera, você pode usá -lo facilmente
Várias implementações de cache, incluindo ConcurrentMap, Ehcache 2.x, jcache, redis, etc.
A definição de cache na primavera
A definição de cache na primavera, incluindo na interface org.springframework.cache.cache.
Ele fornece principalmente os seguintes métodos
// Obtenha o valor de acordo com a chave especificada <t> t get (chave do objeto, classe <t> tipo) // salve o valor especificado no cache de acordo com a chave do vazio correspondente (chave do objeto, valor do objeto); // Recicle o valor especificado vazio de despejo (chave do objeto)
Não é difícil ver pela definição de que o cache é realmente uma estrutura de valor-chave. Operamos o valor correspondente através de uma chave especificada.
Cache Manager
O cache é uma coleção de valores-chave, mas em nosso projeto, pode haver diferentes caches de vários tópicos de negócios, como caches de usuário, caches de departamento, etc. Esses caches são logicamente separados. Para distinguir esses caches, o org.springframework.cache.cachemanager é fornecido para gerenciar vários caches. Esta interface contém apenas dois métodos
// Obtenha o cache do tópico correspondente de acordo com o nome Cache getCache (nome da string); // Obtenha o cache de todos os tópicos coleção <String> getCachenames ();
Nesta interface, não podem ser executados operações de adição e exclusão de operações no cache. Essas operações devem ser concluídas internamente por várias implementações do Cachemanager e não devem ser divulgadas.
Cache baseado em anotação
Em teoria, a operação de cache dos dados não é muito relevante para o próprio negócio. Devemos separar as operações de leitura e gravação do cache da lógica principal do código. A maneira como a primavera é separada é baseada na anotação (é claro, como o JSR-107, etc. também é baseada na anotação).
A Spring fornece uma série de anotações, incluindo @cacheable, @cacheput, @cacheevict e outras anotações para simplificar nossa operação de caches. Essas anotações estão localizadas no pacote org.springframework.cache.annotation.
2. Exemplos
Um exemplo simples de usar a bota de primavera usando o cache da primavera
Vamos criar um exemplo baseado no cache de inicialização da primavera passo a passo
Crie um novo projeto de inicialização da primavera e apresente as seguintes dependências
<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> <GrupidId> org.springframework.boot </frugiD> <ArtifactId> Spring-boot-Starter-test </ArtifactId> <SCOPE> Test </conto> </dependency> </ipendencies>
Entre eles, o cache da Spring-Boot-Starter está a principal dependência do cache.
Modifique a classe de aplicativo e adicione a anotação que permite o cache @enableCaching
@SpringboOtapplication@EnableCachingPublic Class CachesimpleAplication {public static void main (String [] args) {springapplication.run (CachesimpleApplication.class, args); }}A anotação @enableCache inicia o mecanismo de cache da Spring, que permitirá que o aplicativo detecte todas as anotações relacionadas ao cache e comece a trabalhar. Ele também criará um feijão Cachemanager que pode ser injetado e usado por nosso aplicativo.
Crie uma nova classe RestController
@RestController @requestmapping ("/") classe pública CacheController {@aUTowired Private CacheTestService CacheTestService; / ** * Obtenha informações com base no id * * @param id * @return */ @getMapping ("{id}") public string test (@pathvariable ("id") string id) {return cacheTestService.get (id); } / ** * Exclua informações sobre um id * * @param id * @return * / @deletemapping ("{id}") public String Delete (@PathVariable ("id") string id) {return cacheTestservice.delete (id); } / ** * Salve informações sobre um id * * @param id * @return * / @PostMapping public String Salvamento (@RequestParam ("id") String ID, @RequestParam ("value") String Value) {Return CachEtestService.Save (id, valor); } / ** * Informações sobre um novo ID * * @param id * @return * / @putMapping ("{id}") public string update (@pathvariable ("id") string id, @requestparam ("value") string valor) {return cacheTerService.Update (id, value); }}Esta classe chama um serviço para implementar a operação real de adicionar, excluir, modificar e verificar.
Implementação de serviço
Em seguida, queremos implementar nosso serviço
@ServicePublic Class SimpleCacheTestServiceImpl implementa CacheTestService {private Static Final Logger Logger = LoggerFactory.getLogger (SimpleCacheTestServiceImpl.class); mapa final privado <string, string> entities = new hashmap <> (); public SimpleCacheTestServiceImpl () {entities.put ("1", "este n ° 1"); } @AUTOWIRED PRIVADO CACHEMANAGER CACHEMANAGER; @Override @cacheable (Cachenames = "test") public string get (string id) {// grava o horário da geração de dados, usado para testar e comparar longos tempo = new date (). Gettime (); // imprima o Cachemanager usado.info ("O Cachemanager é" + Cachemanager); // imprima o loggger.info ("Get Value por id =" + id + ", o tempo é" + tempo); retornar "Get Value by id =" + id + ", o valor é" + entidades.get (id); } @Override public String Delete (string id) {return entities.remove (id); } @Override public String Salvar (string ID, String Value) {Logger.info ("Salvar valor" + valor + "com chave" + id); entidades.put (id, valor); valor de retorno; } @Override public string update (string id, value string) {return entities.put (id, value); }}cache
Primeiro, adicione a anotação @cacheable ao método get e execute o teste de código.
Usamos Postman para teste, o endereço de teste é http: // localhost: 8080/1, o navegador responde para obter valor por id = 1, o valor é nº 1, o console do servidor imprime duas linhas de toras
Get Value by Id = 1, o valor ISTE nº 1 Get Value por Id = 1, o tempo é 1516004770216
Mas quando atualizamos o endereço do navegador novamente, o navegador retorna normalmente, mas o console não é mais imprime. O motivo é que, quando chamamos de segunda vez, a primavera não executa mais o método, mas obtém diretamente o valor em cache. Spring Cache cache o valor de retorno da função como a chave no teste de cache nomeado.
Aqui, usamos a anotação @cacheable e os Cachenames na anotação especifica qual cache é lido aqui. Aqui, procuraremos o objeto de cache cuja chave é ID no cachename = "teste".
Excluir dados em cache
No programa acima, se excluirmos o valor especificado por meio da solicitação de exclusão e enviará a solicitação de exclusão para http: // localhost: 8080/1, neste momento, o valor foi excluído do mapa, mas quando obtemos o pedido ao http: // localhost: 8080/1, ainda podemos obter o valor. Isso ocorre porque quando excluímos os dados, não excluímos os dados no cache. No método GET anterior, o resultado da operação do método ainda é salvo. A primavera não relerá, mas lerá diretamente o cache. Neste momento, adicionamos anotações antes do método
@Substituir@cacheevict (Cachenames = "test") public string Delete (string id) {return entities.remove (id);}Após o teste, primeiro chame a solicitação de get, o valor de retorno será exibido corretamente como valor GET por id = 1, o valor é 1
Em seguida, ligue para a solicitação de exclusão. Exclua os dados do cache e mapa e chame a solicitação GET novamente. No momento, o valor get by id = 1, o valor é nulo, o que significa que o valor foi realmente excluído do cache.
Aqui usamos a anotação @cacheevict. Cachenames especifica quais dados de cache para excluir. Por padrão, os parâmetros do método serão usados como chave excluída.
Atualize o cache
Quando o programa atingir esse ponto, se executarmos a solicitação de postagem, o corpo da solicitação é ID = 1 & Value = new1. Nesse momento, as impressões do console salvam valor de novo valor1 com a chave 1 e o código salvará o valor no mapa, mas quando executarmos a solicitação GET, descobriremos que o valor de retorno ainda está no estado anterior. Isso é o que podemos usar
@Substituir@cacheput (Cachenames = "test", key = "#id") public string salvar (string id, trimestre string) {logger.info ("salvar valor" + value + "com chave" + id); Entidades de retorno.put (id, valor);}Reexecionar o código, enviamos uma solicitação de exclusão para excluir os dados do mapa e do cache. Em seguida, envie uma solicitação de postagem e escreva os dados para o mapa. Por fim, se você enviar uma solicitação GET, descobrirá que o valor pode ser recuperado corretamente agora e o console não imprimirá o log dos dados obtidos no mapa.
A anotação @cacheput é usada aqui. A função desta anotação é escrever o valor de retorno do método no cache especificado pelos Cachenames de acordo com a chave fornecida.
Da mesma forma, precisamos adicionar a anotação @cacheput ao método PUT para que a modificação também possa atualizar os dados em cache.
Neste ponto, é concluído um aplicativo simples de cache, incluindo adição, exclusão, modificação e consulta.
3. Pontos -chave
Algumas notas
Perceber
@Cacheable e @cacheput colocarão o resultado da execução do método no cache de acordo com a chave especificada. Quando o @cacheable for executado, ele primeiro detectará se há dados no cache. Nesse caso, será lido diretamente do cache. Caso contrário, execute o método e coloque o valor de retorno no cache, @cacheput executará o método primeiro e depois escreverá o resultado da execução no cache. O método usando @cacheput será definitivamente executado
O código de amostra completo está em https://github.com/ldwqh0/cache-test
Resumir
O exposto acima é o método de usar o cache do cache na bota de primavera introduzida pelo editor. Espero que seja útil para você. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a você a tempo. Muito obrigado pelo seu apoio ao site wulin.com!