Prefácio
Como todos sabemos, o Encache é a estrutura de cache de código aberto Java mais popular agora, com configuração simples, estrutura clara e funções poderosas. Ao anotar @cacheable, você pode adicionar rapidamente os resultados do método ao cache. O cache especificado pode ser eliminado rapidamente através do @Cacheevict.
No entanto, como a anotação @cacheevict usa o valor-chave e não suporta a exclusão nebulosa, você encontrará problemas. Quando uso @cacheable para cooperar com as expressões da primavera, adiciono vários caches do mesmo método, como:
@GetMapping ("/listOftsk/{Page}/")@cacheable (value = "BusinessCache", key = "'listOftsk _'+ #Page") public Responsemessage <Pagetaskvo> gettasklist (@pathvariable ("Page") string) {faça algo ...}}O código acima é obter informações de tarefas pagando. Use uma expressão de EL para colocar a página no parâmetro e use a tecla de cache para adicioná -la ao cache do ehcache usando @cacheable. Neste momento, as chaves do tipo listOftask_1, listOftask_2, listOftsk_3 aparecerão no cache.
Ao adicionar ou excluir tarefas, a lista mudará. Neste momento, você precisa remover todos os caches relacionados ao listOftsk_*. No momento, não sei quanto conteúdo está relacionado ao listOftsk_* está em cache no cache, por isso é impossível chamar @cacheevict para excluí -lo um por um.
Como o próprio ehcache não pode apoiá -lo, só podemos implementá -lo.
concluir
Considerando o cache adicionado usando anotações, a remoção de caches também usa processamento de anotação para manter a consistência do desenvolvimento. As anotações também são muito amigáveis para os desenvolvedores. Em seguida, consideramos o uso de anotações personalizadas para desfocar a remoção de caches em lote.
Primeiro, defina o Cacheremove de anotação:
@Target ({java.lang.annotation.ElementType.method}) @retention (retentionpolicy.runtime) public @interface Cacheremove {string value (); String [] key ();}Onde, o valor é como o ehcache, usado para definir o nome do cache para operar. Uma chave é uma matriz que armazena expressões regulares para várias teclas em cache. A nomeação de CacheRemove é clara e fácil de entender e não entra em conflito com a anotação do próprio ehcache. A definição da anotação termina aqui. Em seguida, você precisa lidar com anotações. Como a estrutura da primavera é usada, é natural que você pense em usar a AOP para fazer anotações.
O objetivo da anotação é remover em lote. As duas questões a seguir precisam ser consideradas:
A maneira como eu dei e a maneira mais simples que eu acho é:
Primeiro, defina o nome da classe Cacheremoveaspeape:
@Aspecto @componentpublic class CacheRemoveaspect {@PointCut (value = "(Execution (**.Defina uma tangente em uma área de corte, use a execução (**.*(..) && @annotation (com.example.cacheRemove)) para indicar que todos os CacheReremove de Classes Anotadas são executadas e os valores em @annotation são os nomes totalmente qualificados das anotações.
Após o ponto de incisão, o destaque a seguir é a implementação específica da seção. De um modo geral, o cache não será removido após o método de adição, exclusão e modificação é executada. Portanto, use @afterReturning () para implementá -lo. As seguintes coisas precisam ser feitas na implementação específica:
A implementação específica é a seguinte:
@AfterReturning (Value = "PointCut ()") Processo de void privado (junção junção) {MethodSignature Signature = (MethodSignature) junçãoPoint.getSignature (); Método método = assinatura.getMethod (); CacheRemove CacheRemove = Method.getAnnotation (Cacheremove.class); if (cacheRemove! = null) {string value = cacheRemove.value (); String [] keys = CacheRemove.Key (); // chaves regulares que precisam ser removidas list cachekeys = cacheutils.cachekeys (valor); para (chave de string: chaves) {padrony padrony = padring.compile (chave); for (objeto cachekey: cachekeys) {string cachekeystr = string.valueof (cachekey); if (Pattern.Matcher (CacheKeystr) .find ()) {cacheutils.remove (valor, cachekeystr); }}}}}}}O exposto acima é a implementação específica do cache de remoção de lote difuso ehcache. Entre eles, o BusinessCacheutils encapsula a classe Ehcache Tool para si mesma. Ele implementa principalmente funções normais, como a obtenção de pools de cache, a obtenção de caches, a remoção de caches, a adição de caches e a visualização de todos os caches. O código é o seguinte:
classe pública Cacheutils {private estático cachemanager cachemanager = springcontextholder.getbean ("ehcachemanagerfactory"); objeto estático público get (string cachename, string key) {elemento elemento = getCache (cacheName) .get (key); elemento de retorno == null? null: element.getObjectValue (); } public static void put (string cachename, string chave, valor do objeto) {elemento elemento = new element (chave, valor); getCache (Cachename) .put (elemento); } public static void remover (string cacheName, string key) {getCache (Cachename) .remove (key); } Lista estática pública CacheKeys (String Cachename) {return getCache (Cachename) .getKeys (); } /*** Obtenha um cache, se ninguém for criado. * @param Cachename * @return */ cache estático privado getcache (string cachename) {cache cache = cachemanager.getcache (cachename); if (cache == null) {Cachemanager.addcache (Cachename); cache = Cachemanager.getCache (Cachename); cache.getCacheConfiguration (). Seteternal (true); } retornar cache; } public static cachemanager getCachemanager () {return cachemanager; }}Neste ponto, toda a função de remoção do lote difuso do ehcache é implementada.
Resumir
Todo o processo tem uma idéia simples e, depois de usar algum conhecimento da AOP, as funções necessárias são concluídas. No entanto, a remoção específica de alguns códigos pode ser considerada para otimização. Através de todos os loops de cache, todos os caches que precisam ser removidos são removidos, em vez de pensar que existem várias chaves como essa, o cache completo é atravessado várias vezes. A implementação específica é deixada aos leitores para concluir. Espero que seja útil para você. Eu também espero que todos apoiem mais wulin.com.