Em nome da equipe de engenharia do SDK, tenho o prazer de anunciar que trabalhamos em uma implementação da especificação JCache (JSR107) e, portanto, uma visualização para desenvolvedores está pronta!
A especificação JCache permite que os desenvolvedores criem seus aplicativos em torno de uma API padrão para armazenamento em cache, trocando implementações com o mínimo de esforço. Essa implementação contará com o Couchbase Server e o Java SDK 2.0 para executar o armazenamento em cache de maneira eficiente e eficaz.
Queremos que os desenvolvedores tenham uma amostra do que está por vir e permitir que eles dar feedback e sugestões no início do processo. Observe que esta não é, de forma alguma, uma implementação concluída, pois muitos aspectos ainda estão sendo trabalhados, mas as operações e configurações básicas são funcionais.
Vamos descobrir como usar essa implementação!
Obtenção da implementação
O plano é, obviamente, disponibilizá-lo no Maven Central, mas, por enquanto, a implementação do Couchbase JCache está hospedada em nosso próprio repositório Maven. Você pode obter a visualização do desenvolvedor de lá, adicionando o seguinte ao seu repositório pom.xml:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
com.couchbase.client java-cache 1.0.0-dp couchbase couchbase repo https://files.couchbase.com/maven2 false |
Como alternativa, você pode pegar os potes diretamente (você precisará do java-cache, do java-client e do java-core) ou, se você se sentir aventureiro, poderá ver o código mais recente em github.
Uma breve visão geral
No JCache, um Provedor de cache é resolvido e usado para obter um Gerenciador de cacheque, por sua vez, é usado para criar Caches. Cada cache pode ser configurado usando um CacheConfiguration.
Essa implementação se baseia no Aglomerado e Balde Introduzido no Java SDK 2.0.0. Para configurar corretamente o bucket subjacente, um CouchbaseConfiguration deve ser usado nessa implementação (mas observe que CouchbaseConfiguration.builder().build() deve fornecer padrões sãos, veja abaixo).
Cada CouchbaseCacheManager tem um CouchbaseCluster instance. Elas são inicializadas usando uma lista de cadeias de conexão que têm como padrão o localhost, mas podem ser alteradas chamando setBootstrap no provedor de cache antes de criar o gerenciador de cache.
O CouchbaseCacheManager pode então ser usado para criar e obter um novo CouchbaseCacheque é apoiado por um Balde do SDK.
Vamos ver um breve exemplo completo. Esse exemplo requer o seguinte contexto do couchbase:
- Um cluster acessível em
localhost:8091 - Um bucket chamado "jcache" (senha: "jcache") nesse cluster
Quando esse for o caso, o seguinte snippet poderá ser executado:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
CouchbaseCachingProvider cachingProvider = new CouchbaseCachingProvider(); //if your cluster has no localhost node, customize the bootstrap list //cachingProvider.setBootstrap("192.168.1.2", "node3.mydomain.org"); //if you already use the Java SDK somewhere else in your application, you should reuse Environment //cachingProvider.setEnvironment(myCouchbaseEnvironmentUsedSomewhereElse); //create a cache manager identified by the default URI and ClassLoader CouchbaseCacheManager cacheManager = cachingProvider.getCacheManager(); //create a cache named myFirstCache CouchbaseCache<String, String> cache = cacheManager.createCache("myFirstCache", CouchbaseConfiguration.builder("myFirstCache").build()); //cache a String cache.put("myKey", "myValue"); //get it back from the cache String inCache = cache.get("myKey"); |
Observe que os gerenciadores de cache são identificados por um URI e um ClassLoadere só são criados se não houver nenhum Gerenciador de cache foi registrado para os mesmos identificadores (caso contrário, o método retorna o gerenciador existente).
Personalização da forma como o cache é feito
Vimos que, por padrão, a implementação de cache tenta se conectar a um cluster acessível no localhost, e que podemos usar CouchbaseConfiguration.builder("cacheName").build() como padrão para a configuração de um cache. Mas como podemos personalizar por meio de CouchbaseConfiguration?
Configurações comuns na API do JCache
A CouchbaseConfiguration é baseada em uma configuração padrão MutableConfiguration (que define configurações comuns da API). É possível alterar essas configurações alterando a configuração depois que ela for criada ou passando uma CompleteConfiguration para ser copiada para o arquivo useBase(CompleteConfiguration base) método.
Qual balde usar?
Você tem duas opções: compartilhar um único bucket para vários caches, prefixando as chaves de cada cache no bucket compartilhado, ou usar um bucket dedicado para um determinado cache.
Por padrão, um bucket compartilhado chamado jcache é usado (senha esperada: "jcache"). O prefixo padrão é o nome do cache seguido de um sublinhado.
- O cache compartilhado pode ser alterado por meio de
useSharedBucket(String name, String password). - O prefixo da chave em um contexto de cache compartilhado pode ser alterado usando
withPrefix(String prefix). - O método alternativo de usar o cache dedicado pode ser ativado usando
useDedicatedBucket(String name, String password)(isso redefinirá o prefixo).
Dependendo de exibições para listar todos os itens em um cache
Parte da API do JCache permite obter todos os itens em um cache ou iterar sobre eles. A melhor maneira de conseguir isso no Couchbase é usar exibições. Portanto, essa implementação espera que uma visualização esteja disponível para listar todos os itens em um cache.
- Por padrão, o documento de design e a visualização esperados são
jcachee o cacheName. - O documento de design pode ser alterado chamando
viewAllDesignDoc(String designDocName). - O nome da visualização pode ser alterado chamando
viewAllViewName(String viewName). - Como alternativa, use
viewAll(String designDocName, String viewName)para alterar ambos.
Espera-se que o usuário crie a exibição correta no bucket correto para cada cache. Não se esqueça de que as chaves provavelmente são prefixadas no bucket (a menos que você tenha usado explicitamente um bucket dedicado).
O que vem a seguir?
Essa visualização do desenvolvedor mostra a direção geral que seguimos com essa implementação e tem a maioria das operações do JCache funcionando em uma capacidade mínima (ainda não há bloqueio adequado, portanto, as operações descritas como atômico na especificação, como getAndPutnão deve ser considerado como tal).
Os itens restantes a serem implementados para que haja uma cobertura completa da especificação são - melhorar e concluir a coleta de estatísticas - bloqueio, atomicidade de um subconjunto de operações - adicionar suporte a ouvintes - adicionar suporte a EntryProcessors - implementar leitura e gravação - adicionar suporte a anotações
Conclusão
Espero que isso seja de seu interesse. Se você quiser saber mais sobre o JCache ou o Java SDK (e talvez volte aqui mais tarde), aqui estão alguns recursos:
Se você tiver alguma sugestão ou feedback para dar, por favor, dê! O melhor lugar para fazer isso é nos comentários abaixo ou na seção oficial fóruns.
Você também pode registrar problemas em nosso rastreador de bugs (use a opção "Cliente Java do Couchbase", também conhecido como JCBCe usar JCache componente).
Contribuições também são bem-vindas! Você teria que assine nosso CLA (consulte documento de código aberto) e nos permita validar que você o fez antes de enviar um pull-request em GitHub.
Espero que você tenha gostado dessa prévia. Boa codificação!
