Início > Programação > Como Integrar o Ehcache ao Spring

Como Integrar o Ehcache ao Spring

O Princípio de Pareto (regra 80-20), quando aplicado à análise da frequência com a qual nossa aplicação faz uso dos recursos, nos ajuda a estabelecer um critério para selecionar que eventos ou que entidades serão cacheadas. Esse princípio serve apenas para chamar nossa atenção para o fato de que há poucos eventos onerando uma boa parte da memória e do processamento, mas você deve utilizar ferramentas para investigar o que está acontecendo com seu aplicativo, como o VisualVM ou o JProfiler.

Conhecendo o que está onerando a memória, você pode decidir cachear ou bufferizar. Cache e buffer são conceitos diferentes, mas muitas vezes nós os utilizamos como sinônimos. Um buffer é estrutura temporária que media o relacionamento entre uma entidade rápida e outra lenta: o buffer diminui o tempo que a entidade rápida deve esperar pela disponibilidade da lenta oferecendo acesso direto a blocos inteiros ao invés de pedaços, o que melhora a performance.

Enquanto o buffer é uma estrutura conhecida por pelo menos uma das entidade comunicantes, o cache é feito sem que as entidades tomem conhecimento. Permitindo que uma entidade possa ser acessada muitas vezes, há ganho de performance, pois os recursos (persistência, storage, serviços) não precisarão ser acessados desnecessariamente e a entidade não precisará ser recriada.

O Ehcache é um dos mais famosos frameworks de cache. Ele oferece flexibilidade para escolhermos a estratégia de cache da nossa aplicação, como onde ele será armazenado (memória, disco), qual a quantidade máxima de entradas e quanto tempo uma entidade permanecerá em cache. Nesse artigo, vou mostrar como integrar o Ehcache ao framework Spring. Comecemos as configurações adicionando as dependências do Ehcache e do Spring.

<dependency>
   <groupId>net.sf.ehcache</groupId>
   <artifactId>ehcache</artifactId>
   <version>2.9.0</version>
</dependency>
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-context</artifactId>
   <version>4.1.4.RELEASE</version>
</dependency>
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-context-support</artifactId>
   <version>4.1.4.RELEASE</version>
</dependency>

Adicione o arquivo ehcache.xml ao seu classpath. Esse arquivo contém as estratégias de cache que você está utilizando – você pode definir quantas quiser. No exemplo abaixo, criei uma estratégia chamada “cacheUsuarios” que armazena até 10000 itens em memória durante 300 segundos.

<?xml version="1.0"?>
<ehcache
   xsi:noNamespaceSchemaLocation="ehcache.xsd"
   updateCheck="true"
   monitoring="autodetect"
   dynamicConfig="true">
   <cache name="cacheUsuarios"
      maxEntriesLocalHeap="10000"
      timeToLiveSeconds="300" 
      eternal="false"
      memoryStoreEvictionPolicy="LRU">
      <pinning store="localMemory"/>
   </cache>
</ehcache>

Você deve dizer ao Spring via @Configuration para ele ativar as anotações de cache definidas por @EnableCaching.

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.cache.ehcache.EhCacheManagerFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;

@Configuration
@EnableCaching
public class CacheConfig {
   @Bean
   public CacheManager cacheManager() {
      return new EhCacheCacheManager(ehCacheCacheManager().getObject());
   }
   @Bean
   public EhCacheManagerFactoryBean ehCacheCacheManager() {
      EhCacheManagerFactoryBean cmfb = new EhCacheManagerFactoryBean();
      cmfb.setConfigLocation(new ClassPathResource("ehcache.xml"));
      cmfb.setShared(true);
      return cmfb;
   }
}

Crie a classe Usuario. Instâncias dessa classe serão cacheadas:

public class Usuario{
   private Integer id;
   private String nome;
}

Por último, basta anotar o método que devolve a entidade que será cacheada.

@Service
public class UsuarioServiceImpl implements UsuarioService {
   @Autowired
   private UsuarioDao dao;

   @Override
   @Transactional(readOnly = true)
   @Cacheable(value = "cacheUsuarios", key = "#nome")
   public Usuario find(String nome) throws Exception {
      return dao.find(nome);
   }
}

Note que definimos que a entrada onde a entidade será armazenada no cache tem como chave o “nome” do usuário, que foi informado via parâmetro. Poderíamos definir uma chave mais complexa à partir das propriedades de uma outra entidade. Se for esse o caso, você poderia definir algo assim:

#entidade.propriedade1.propriedade3.propriedade3.propriedade4

Referências

1. [https://www.mkyong.com/spring/spring-caching-and-ehcache-example/]
2. [http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html]
3. [http://www.codingpedia.org/ama/spring-caching-with-ehcache/]
4. [http://www.baeldung.com/spring-cache-tutorial]
5. [http://stackoverflow.com/questions/26140702/spring-cacheable-how-to-configure-a-complex-key]

Anúncios
Categorias:Programação
  1. Nenhum comentário ainda.
  1. 12/06/2017 às 10:01 AM

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s

%d blogueiros gostam disto: