A principal pesquisa deste artigo é sobre o conteúdo relacionado ao cache da primavera, como segue.
Este artigo foi modificado aproximadamente com base na tradução do Google. Como não sei qual é o texto original, isso pode levar a erros e imprecisões na tradução, mas a direção geral é muito boa, então eu o resolvi aqui, esperando que seja útil.
O cache sempre foi uma grande necessidade de melhorar o desempenho do aplicativo e reduzir sua carga de trabalho. Além disso, sua utilidade é particularmente evidente hoje, que pode ser usada para lidar com milhares de visitantes na arquitetura concorrente. A partir da versão 3.1, a Spring fornece uma API de gerenciamento de cache, semelhante ao gerenciamento de transações declarativas. A interface abstrata do cache, usando diferentes soluções de cache de maneira unificada, tem o menor impacto no código.
A Spring usa métodos Java para solicitar um método pela primeira vez para uma combinação com parâmetros e armazena o valor de retorno no cache. Portanto, a próxima solicitação será usar o valor diretamente do cache sem precisar chamar um possível método caro. Tudo é aplicado de forma transparente sem afetar o método chamado.
Nesta postagem, veremos implementações de dois estoragens diferentes de cache da primavera.
A integração da primavera e do cache é simples e transparente. O método que precisa de cache é anotado por anotação @cacheable
@Cacheable (value = "datacache") public Reponse GetDatas (long param1, string param2) {} DataCache é o nome do cache associado. Quando esse método é chamado pela primeira vez, o método executa e armazena o resultado da execução no conjunto de resultados com a chave secreta hashed fora do <parâmetro 1 e parâmetro 2> como resultado. Quando o mesmo parâmetro é chamado novamente, esse método não precisa ser executado novamente.
É possível que mais de um cache esteja associado ao nosso método
@Cacheable ({"datacache", "default"}) public Reponse GetDatas (long param1, string param2) {} Nesse caso, cada cache é verificado antes da execução do método e, se houver um acerto, o valor relevante será retornado.
A proporção de algoritmos básicos de um gerente de cache é relativamente pequena. O cache pode ser considerado uma área de memória na qual os objetos armazenados são mapeados por uma chave única. O processo de pesquisa de objetos é o seguinte:
1. Calcule a chave (use o método hash para obter hashcode)
2. Encontre objetos com base no valor da chave
3. Se o objeto for encontrado, retorne o resultado
4. Se não puder ser encontrado, a chave que está realmente associada ao objeto será calculada e o objeto será armazenado no local correspondente.
A Spring usa um hash simples, que gera teclas com base nos parâmetros de método passados.
O método de destino não pode simplesmente gerar teclas desnecessárias com base em parâmetros, mas apenas alguns casos simples são gerados com base em parâmetros.
@Cacheable (value = "datacache") public Reponse GetDatas (long param1, string param2, boolean param3) {}O @cacheable permite que os desenvolvedores especifiquem a maneira como a geração de chaves é gerada por si mesma. Você pode usar expressões de SPEL para fazer isso.
@Cacheable (value = "datacache", key = "#param2") public Reponse GetDatas (Long Param1, String param2, boolean param3) {} Nesse caso acima, o parâmetro da chave em cache é apenas parma2
A primavera também permite propriedades aninhadas
@Cacheable (value = "datacache", key =#param2.name ") public Reponse GetDatas (Long Param1, Data Param2, Boolean Param3) {} Esta situação é a chave calculada com base no atributo Nome de Parma2
Há um cache que pode não ser adequado para o cache no caso usado, mas em alguns casos é necessário o cache. Quando armazenado em cache, o cache é processado com base no verdadeiro ou falso calculado pela expressão do SPEL e, se a condição for verdadeira, o cache será realizado.
@Cacheable (value = "datacache", key = "#param2", condiciona = "#param2.length <64") public Reponse getDatas (long param1, string param2, boolean param3) {} Nesse caso, o cache será realizado apenas se o comprimento do segundo parâmetro for menor que 64
O cache da Spring pode não apenas cache, mas também limpar um armazenamento de cache. Esse processo é usado para remover dados desatualizados ou dados em cache não utilizados. Anotação @cacheevict define métodos para executar o esvaziamento de cache, esses são gatilhos para excluir dados no cache.
@Cacheevict (value = "datacache") public void relloaddata () {}Esta opção é muito necessária e esse método será usado quando um dados em cache precisar ser liberado.
Para ativar o suporte ao cache para um projeto de primavera, precisamos adicionar comentários de cache ao espaço para nome.
<Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: cache = "http://www.springframework.org/schema/cache" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: context = "http://www.springframework.org/schema/Context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/cache O
Excluir anotação pode desativar o cache ou ativar o uso do cache em nossa classe de configuração
@Configuration @enablecaching classe pública AppConfig {} Limitações técnicas
Os parâmetros do método de passagem do objeto devem ter seu próprio método de hashcode para calcular a chave secreta.
Como um objeto passou e devolvido como um parâmetro, deve ser serializável
Implementar seleção
A primavera fornece duas implementações básicas:
Ao usá -los, você só precisa declarar o cachemanger apropriado e a entidade do gerente
Concurrenthashmap usando Java
<bean id = "cacheManager"> <span style = "space branco: pré"> </span> <propriedade name = "cache"> <span style = "space branco: pre"> </span> <Set> <span style = "white-space: pré"> </span> <bEan = "default"/> style = "white space: white:"> </span> <bEan = "default"/> style = "space: space:
Cada manjedoura precisa de um nome, que é reconhecido pelos comentários. Pode -se gerenciar vários SimpleCachemangers por uma manjedoura, e essa implementação é basicamente desnecessária.
Implementar Ehcache
Declaração de Cachemanger
bean id = "cachemanager"> <propriedade name = "cachemanager" ref = "ehcache"/> </bean> <bean id = "ehcache"> <propriedade name = "configLocation" value = "classpath: ehcache.xml"/> <names = "compartilhado" = "true"/> </ * </ *
No arquivo ehcache.xml é o arquivo de parâmetro de cache do aplicativo:
<ehcache xsi: nonamespaceschemalocation = "ehcache.xsd" updateCheck = "true" monitoring = "autodOtect" dynamicconfig = "true" maxbyteslocAlheap = "150m"> <DiskStore Path = "java.io.tmpdur"/>> <Fafult "> <flainChe" e eTernEmatin) overflowTodisk = "false"/> <cache name = "datacache" eTernal = "false" timeToidleSeconds = "300" maxbyteslocAlheap = "30m" timeToliveSeConds = "300" flowTodisk = "True" DiskPerSistent = "false" "DiskexpireSTIVELSECONDSECONDS =" True "" "False" </ehcache>
Usando o ehcache, podemos definir vários parâmetros de cache de uma maneira muito simples
Nome: Identificador em cache
Maxbyteslocalhheap: define o número de bytes que o cache pode usar para a máquina virtual. Se um Cachemanager Maxbyteslocalheap tiver sido definido, o tamanho determinado do cache será subtraído pelo Cachemanager. Outras quebras compartilhadas de cache. O valor desta propriedade é dados <número> k | K | M | M | G | G significa Kilobytes (K | K), Megabytes (M | M) ou Gigabytes (G | G).
Eternidade: define se um elemento é eterno. Se for esse o caso, o tempo limite será ignorado e o projeto nunca expirou.
TimeToidleSeconds: este é o número de segundos, o item foi deixado na última utilização.
TimetoliveSeconds: este é o número de segundos que o projeto viveu no cache.LA A criação de valor padrão é 0 e o projeto estará vivo para sempre.
MemoryStoreEvictionPolicy Política: LRU - Menos usada recentemente, frequentemente usada FIFO - elemento mais antigo e mais antigo por data da criação.
DiskexpirythReadIntervalSeconds: O processo de encerramento controla o número de segundos entre duas execuções.
DiskPersistent: permite que os objetos sejam restaurados entre duas correspondências de máquinas virtuais armazenadas no disco.
OverflowTodisk: determina se um objeto pode ser armazenado no disco para obter o elemento de armazenamento máximo.
Para resumir, use uma fórmula matemática simples: expirationTime = Math.min((creationTime + timeToLive),(mostRecentTime + timeToIdle))
O exposto acima é toda a explicação detalhada do código do cache da primavera neste artigo, espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!