O mecanismo de cache da primavera é muito flexível e pode armazenar em cache qualquer métodos de feijão ou feijão no contêiner. Portanto, esse mecanismo de cache pode ser armazenado em cache em qualquer nível de aplicação Javaee.
A camada subjacente do cache da mola também precisa ser implementada com a ajuda de outras ferramentas de cache, como o ehcache (Hibernate Cache Tool), e a camada superior usa uma programação de API unificada.
Para usar o cache da primavera, as três etapas seguintes são necessárias
Por exemplo
<? xml versão = "1.0" coding = "utf-8"?> <ehcache> <DiskStore path = "java.io.tmpdir" /> <!-Configure o cache padrão-> <defaultCache maxElementsinMemory = "10000" eTernal = "false" TimeToDleSondSondsSSSSSSSSSSSONGRESSIMENTO = "10000" "ETERAL =" false "TimeRoDleSondSondSondSSSONDSSSSE maxElementsOndisk = "10000000" DiskexpiryTreadInterValsEconds = "120" MemoryStoreEvictionPolicy = "lru"/> <!-Configure o cache chamado de usuários-> <cache name = "usuários" timetInMetInMorysyMory = "10000" ETERNAL = "false" "OverflowTodisk = Timet" "3xELEMELOIDOLTIDOLTISTIMENTESTIMENTESTIMORESTIMENTES (10000" = "False") TimetoliveSeconds = "600" /> </hcache>
O ehcache.xml acima configura duas áreas de cache. O feijão na primavera será armazenado em cache nessas áreas de cache. Geralmente, quantos feijões existem no recipiente de primavera serão definidos no ehcache.
Em seguida, configure o Cache Manager no arquivo de configuração da primavera da seguinte maneira, onde o primeiro feijão é um feijão de fábrica usado para configurar o Cachemanager do Ehcache, e o segundo feijão é o gerente de cache configurado para o cache da mola, para que o primeiro feijão seja injetado no segundo feijão.
<cache: anotação acionada por cache-manager = "cachemanager" /> <!-Configure o ehcache cachemanager para especificar a localização do arquivo ehcache.xml por meio de configlocation-> <bean id = "ehcachemanager" p: configlocation = "ClassPath: ehcache.xml" p: configlocation = "ClassPath: ehcache.xml" e injetar ehcache cachemanager no gerente de cache bean-> <bean id = "cachemanager" p: cachemanager-ref = "ehcachemanager"> </i bean>
Aqui está uma configuração completa da primavera.
<? 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: cache = "http://www.springframework.org/schema/cache" xmlns: context = "htsc://wwwwwwwwwwwwwwwork" xmlns: context = "htsc://wwwwwwwwwwwwwwork" xmlns: context = "htschwwwwwwwwwwwwwwwwork" xmlns: context = "htsc://wwwwwwwwwwwwork" xmlns: context = "htschwwwwwwwwwwwwwwwork" xmlns: " xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd"> <Contexto: Componente-Scan-Base-Package = "com.service" /> <cache: Cache-manager acionado por anotação = "Cachemanager" /> <!-Configure Ehcache Cachemanager Especifique a localização do ehcache.xml através do configlocation-> <Bean id = "ehcachangersLaGer" P: ConfigLocation-> <BEAN ID = "ehcachanger" P: Shared = "false"/> <!-Configure o gerente de cache baseado em Ehcache e injete o Cachemanager de Ehcache no gerente de cache Bean-> <bean id = "Cachemanager" P: Cachemanager-ref = "Ehcachemanager"> </sien> </s Beans>
O seguinte usará @Cacheable como exemplo para demonstrar o uso da primavera com base no cache Ehcache. Cacheable é usado para modificar classes ou métodos. Se a classe for modificada, todos os métodos da classe serão armazenados em cache.
Cache no nível da classe
Por exemplo, existem as seguintes aulas de feijão,
@Service ("UserService") @cache (value = "usuários") classe pública UserServiceImpl implementa UserService {@Override Public User GetUsersByNameanDage (Nome da String, Int Age) {System.out.println ("Execução getUsersByNaNeDage () .."); retornar novo usuário (nome, idade); } @Override Public User GetanotherUser (Nome da String, Int Age) {System.out.println ("Execução de GetanotherUser () .."); retornar novo usuário (nome, idade); }}O cache baseado em classe cache todos os métodos da classe. Após o cache, o programa chama qualquer método da instância desta classe. Enquanto os parâmetros passados forem os mesmos, a primavera não executará o método, mas procurará diretamente os dados em cache com base nos parâmetros passados!
Por exemplo, use dados em cache como abaixo.
public static void test2 () {ApplicationContext ctx = new ClassPathXMLApplicationContext ("bean.xml"); UserService US = ctx.getBean ("UserService", UserService.class); Usuário u1 = nós.getUsersByNameArDage ("Zhang San", 50); // Como o mesmo parâmetro é usado quando o método do servidor de usuários é chamado na segunda vez, o método real não será executado, // Spring procurará diretamente dados por parâmetros do usuário do cache u2 = US.GetanotherUser ("Zhang San", 50); System.out.println (u1 == u2); }Resultado da saída,
GetUsersBynamAnDage () está sendo executado ..
verdadeiro
Como você pode ver, o getanotherUser () acima não é realmente executado porque os parâmetros passados são os mesmos que os parâmetros transmitidos pelo método anterior; portanto, a mola vem diretamente dos dados da área de cache.
Além do valor de atributo necessário, a anotação @Cacheable na classe Bean acima também possui chave, condição e, a menos que atributos. Os três últimos são usados para definir políticas de armazenamento de mola. Para caches baseados em classe, o Spring usa os parâmetros passados no método como chave para procurar resultados no cache por padrão.
Obviamente, também podemos modificar a estratégia da chave e deixar a primavera seguir outros padrões, como se o primeiro parâmetro é o mesmo que a chave e procurar os resultados no cache.
Modifique a classe de feijão acima, a seguir,
@Service ("UserService") @cache (value = "usuários", key = "#name") public class UserServiceImpl implementa UserService {@Override User Public GetUsersByNameArDage (Nome da String, Int Age) {Significando que passamos com o mesmo nome, a primavera não executará realmente o método. Somente quando o nome for diferente, o método será executado, por exemplo,
public static void test2 () {ApplicationContext ctx = new ClassPathXMLApplicationContext ("bean.xml"); UserService US = ctx.getBean ("UserService", UserService.class); Usuário u1 = nós.getUsersByNameArDage ("Zhang San", 50); // Depois de alterar o parâmetro de chave de @cacheable para key = "#name", o método a seguir poderá ser executado. Usuário u2 = nós.getanotheruser ("li si", 50); System.out.println (u1 == u2); } Você pode ver que desta vez getAnotherUser() foi executado.
1 getUsersBynameAdage () está sendo executado ..
2 getanotheruser () está sendo executado ..
3 Falso
Também podemos definir a propriedade da condição, por exemplo,
@Service ("UserService") @cache (value = "usuários", condiciona = "#idade <100") public classe UserServiceImpl implementa UserService {@Override User Public User GetUsersByNameArDage (Nome da String, Int Age) {Portanto, para o código a seguir, nenhum método será armazenado em cache. A Spring executa o método real para obter o resultado sempre.
public static void test2 () {ApplicationContext ctx = new ClassPathXMLApplicationContext ("bean.xml"); UserService US = ctx.getBean ("UserService", UserService.class); Usuário u1 = nós.getUsersByNameArDage ("Zhang San", 500); Usuário u2 = nós.getanotheruser ("li si", 500); System.out.println (u1 == u2); }Resultados de execução,
GetUsersBynamAnDage () está sendo executado ..
GetanotherUser () está sendo executado ..
falso
O cache no nível do método funcionará apenas para o método. Diferentes métodos podem definir áreas de cache desnecessárias, como as seguintes,
@Service ("UserService") Classe pública UserServiceImpl implementa UserService {@cacheable ("usuários1") @Override User Public GetUsersByNameanDage (Nome da String, Int Age) {System.out.println ("Execution getUsersByNaNeDage () .."); retornar novo usuário (nome, idade); } @Cacheable ("usuários2") @Override User Public GetanotherUser (nome da string, int Age) {System.out.println ("getanotheruser () .."); retornar novo usuário (nome, idade); }}Use o seguinte código de teste,
public static void test2 () {ApplicationContext ctx = new ClassPathXMLApplicationContext ("bean.xml"); UserService US = ctx.getBean ("UserService", UserService.class); // Na primeira vez em que o método é executado, o método será executado e o usuário em cache u1 = us.getUsersByNameanDage ("Zhang San", 500); // Embora o método a seguir passe os mesmos parâmetros, porque esses dois métodos estão em diferentes áreas de cache, os dados do cache não podem ser usados. Usuário u2 = nós.getanotheruser ("Zhang San", 500); System.out.println (u1 == u2); // O acima foi cache e não será executado aqui. Use cache diretamente. Usuário U3 = US.GetanotherUser ("Zhang San", 500); System.out.println (u3 == u2); }Resultados de execução,
GetUsersBynamAnDage () está sendo executado ..
GetanotherUser () está sendo executado ..
falso
verdadeiro
O método modificado por @cacheevict pode ser usado para limpar o cache, e as seguintes propriedades podem ser especificadas usando @CacheEvict .
Allentries, seja para limpar toda a área de cache
Antes da vocação: se deve limpar o cache antes de executar o método. O padrão é limpá -lo somente depois que o método é executado com sucesso.
condição e chave, o mesmo significado que em @Cacheable .
A demonstração a seguir é simples.
@Service ("UserService")@cache ("usuários") classe pública UserServiceImpl implementa UserService {@Override User public getUsersByNameanDage (Nome da String, Int Age) {System.out.println ("executando getUsersByNamEanDage () usen; {System.out.println ("Executando getanotheruser () .."); retorna novo usuário (nome, idade);} // especifique o cache claro de acordo com o nome e os parâmetros da idade @cacheevict (value = "usuários") public void despetuser (nome de string, int) {System.out.println ("-Clearing) Limpando todos os dados em cache na área de cache do usuário @cacheevict (value = "usuários", allEntries = true) public void evictall () {System.out.println ("-limpando o cache inteiro--");}}Abaixo está a classe de teste,
public static void test2 () {ApplicationContext ctx = new ClassPathXMLApplicationContext ("bean.xml"); UserService US = ctx.getBean ("UserService", UserService.class); // O sistema cache dois métodos Usuário U1 = US.GetUsersByNameAnDage ("Zhang San", 500); Usuário u2 = nós.getanotheruser ("li si", 400); // Ligue para o método EvictUser () para limpar os dados especificados no buffer US.evictuser ("li si", 400); // LIM LI SI, 400 Antes que os dados retornados pelo método a seguir sejam armazenados em cache novamente U3 = US.GetanotherUser ("Li Si", 400); System.out.println (US == U3); // FALSO // Os dados de Zhang San e 500 já foram armazenados em cache antes, e o método a seguir não será reexecionado, e os dados no cache serão recuperados diretamente o usuário u4 = US.GetanotherUser ("Zhang San", 500); System.out.println (u1 == u4); // saída true // limpe todo o cache US.evictall (); // Como todo o cache foi limpo, o código a seguir será reexecute o usuário u5 = us.getanotherUser ("Zhang San", 500); Usuário u6 = nós.getanotheruser ("li si", 400); System.out.println (u1 == u5); // output false System.out.println (u3 == u6); // saída falsa}Resultados de execução,
GetUsersBynamAnDage () está sendo executado ..
GetanotherUser () está sendo executado ..
-limpar o cache correspondente a li si, 400-
GetanotherUser () está sendo executado ..
falso
verdadeiro
-esclarecer todo o cache-
GetanotherUser () está sendo executado ..
GetanotherUser () está sendo executado ..
falso
falso
O exposto acima é tudo sobre o código de exemplo do mecanismo de cache de cache de 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!