Usando o Couchbase Java SDK para escrever um Vert.x Verticle

Nesta postagem, vamos abordar o tema reativo até o fim!

Alguns clientes do Couchbase usam Vert.xuma estrutura para escrever aplicativos totalmente assíncronos, sabendo que o SDK Java do Couchbase se encaixa bem nesse quadro, sendo assíncrono desde o início e expondo um RxJava-API assíncrona com base em dados.

Portanto, veremos como começar a trabalhar rapidamente com um Couchbase Vertical que inicia uma conexão com um Couchbase Aglomerado e Balde e, em seguida, serve documentos JSON do banco de dados, usando o Java 8.

Esta postagem do blog pressupõe que você esteja familiarizado com a noções básicas do Vert.x. Aqui está uma breve tabela de conteúdo:

• Início de um novo projeto Vert.x
  • Esqueleto da partícula
• Obtenção assíncrona de um bucket
• Desmontando o SDK de forma graciosa
• Vendo-o em ação
• Indo além
  • Criação de dados de amostra no Couchbase na inicialização
  • Fornecimento de dados JSON do Couchbase
  • Interromper o Verticle por meio de um ponto de extremidade HTTP
• Conclusão
  

Início de um novo projeto Vert.x

Vamos começar criando um novo projeto baseado em Maven: crie uma pasta raiz para o seu projeto e inicialize uma estrutura de diretório maven (ou use seu arquétipo Maven favorito). Por exemplo, você pode usar o seguinte comando: "mkdir -p cbvertx/src/main/java/com/couchbase/demo/vertx/“.

Agora vamos iniciar o pom.xml na raiz do projeto:

Como você pode ver, usaremos Vert.x versão 3.1.0 e sua extensão para associações no RxJava, SDK Java do Couchbase versão 2.2.2 e RxJava versão 1.0.15…

Esqueleto da partícula

Basearemos nossa CouchbaseVerticle no AbstractVerticle em io.vertx.rxjava.core (da extensão vertx-rx-java). Vamos criar seu esqueleto no projeto:

A fase de inicialização que escreveremos logo após isso mostrará como usar a configuração do Vert.x para determinar, no tempo de execução, de quais nós do cluster do Couchbase faremos o bootstrap. A instanciação do CouchbaseCluster ainda é leve o suficiente para que possa ser feito dessa forma durante o init.

Adicione o seguinte método init ao CouchbaseVerticle:

Obtenção assíncrona de um bucket

O principal ponto de entrada para a API do Couchbase é o Balde para a API de sincronização, ou AsyncBucket para a API assíncrona. Estabelecer a conexão com o bucket ("abri-lo") é muito mais pesado, portanto, deve ser feito de forma assíncrona.

Vamos ver como podemos iniciar nossa partícula abrindo primeiro o bucket que usaremos durante toda a vida útil da partícula. Queremos manter uma referência a ele e usar a função start(Future startFuture) para notificar de forma assíncrona o Vert.x de que o Verticle está pronto:

Observe que primeiro obtemos o nome do bucket (e a senha associada, se relevante) dinamicamente, a partir da configuração do Vert.x. Abrimos o bucket de forma assíncrona, estabelecendo as conexões e os recursos internos do SDK.

O doOnNext é usado para registrar a abertura do balde.

Em seguida, assinamos nosso Observável e descrever como queremos "consumir" os dados finais:

• Ao receber a referência do bucket, nós a armazenamos em um campo para uso posterior
• Se houver um erro no caminho, falharemos na inicialização do Verticle usando o Future#fail método.
• Caso contrário, notificamos o Vert.x de que o Verticle foi iniciado com sucesso usando o comando Future#complete método.

Esse é um bom começo!

Desmontando o SDK de forma graciosa

Quando o Verticle parar, os recursos criados pelo SDK deverão ser descartados adequadamente. O Aglomerado tem um objeto desconectar que faz isso, chamando recursivamente o método próximo em cada Balde que ele abriu (close pode ser usado para descartar um único Bucket).

Além disso, desde 1.0.15 O RxJava tem um método para encerrar seus Threads internos: Agendadores.shutdown. No entanto, isso deve ser invocado somente quando não houver uso subsequente do RxJava no aplicativo, portanto, pode ser uma ideia melhor fazer isso no desligamento do Vert.x...

Mais uma vez, interromperemos o Verticle de forma assíncrona, usando um Futuro para notificar a estrutura sobre a conclusão da parada:

(optamos por encerrar o RxJava após a conclusão da desconexão do SDK)

Observação Você pode ajustar o SDK passando um CouchbaseEnvironment após a criação do Aglomerado. Nesse caso, cabe a você também ligar para desligamento no ambiente ao desativar todo o SDK (ou seja, quando todos os clusters em que você usou o ambiente, geralmente apenas um, forem desativados).

Se você não tiver criado um ambiente específico, o SDK criará internamente um ambiente e o encerrará adequadamente, cujo resultado é visto acima no isDisconnectedCleanly variável.

Vendo-o em ação

Vamos criar um principal que incorpora o Vert.x, implementa o Verticle e depois para. Observe que essa é uma implementação bastante ingênua com CountDownLatches, em que você normalmente prefere usar a linha de comando ou o Lançador como uma classe principal.

Se você executar isso, verá o seguinte (notou a diferença no formato do registro de data e hora? 2015-12-11 são do SDK, enquanto os 11 de dezembro de 2015 são do Vert.x):

Como verificar o comportamento do erro? Poderíamos simplesmente alterar a senha para uma que esteja errada, apenas para verificar os registros, que seriam semelhantes:

Assim, implantamos (e paramos) com sucesso nosso primeiro Couchbase Verticle!
Parabéns!

/! Não se esqueça de alterar a senha de volta para a correta

Indo além

Vamos tentar fazer um pouco mais com esse Verticle. Que tal tentarmos preparar dados de amostra no Couchbase e servi-los em um endpoint REST gerenciado pelo Vert.x?

Criação de dados de amostra no Couchbase na inicialização

Criaremos dois documentos de amostra no Couchbase durante a inicialização do Verticle, com os usuários Alice e Bob.

É possível armazenar JSON no Couchbase usando dois Documento implementações:

• JsonDocument é o padrão. Ele se baseia em uma representação JSON simples fornecida pelo SDK, o JsonObject.
• RawJsonDocument é útil quando você já tem JSON marshalling/unmarshalling em seu aplicativo (ou outra forma de representar JSON, como o próprio JsonObject). Nessa implementação, o que você passa é a representação bruta da cadeia de caracteres JSON.

Aqui estão Alice e Bob, criados usando ambas as alternativas:

e

Agora, o método start precisa de um pequeno ajuste. Em vez de salvar a referência ao bucket na assinatura, moveremos isso anteriormente em um doOnNext. Depois disso, criaremos os documentos e faremos um Observable com eles usando Observável.just. Isso pode ser encaminhado ao SDK para inserção usando flatMap:

O uso de upsert aqui garante que os documentos serão criados, quer a chave já exista no banco de dados ou não.

Fornecimento de dados JSON do Couchbase

Vamos modificar nossa partícula para que ela não pare imediatamente e, em vez disso, gire um servidor HTTP que tentará recuperar um documento json do banco de dados e enviá-lo a um cliente quando a rota usuário/{id} é usado:

Aqui está uma maneira rápida e simples de usar o Vert.x Lançador para iniciar o programa (que não interromperá o núcleo do Vert.x imediatamente). Substitua o conteúdo de nosso principal com o seguinte:

Observação: Em um aplicativo real, Lançador normalmente se tornaria a classe principal do jar e você passaria os argumentos da linha de comando diretamente.

Agora vamos ativar um servidor HTTP na inicialização do Verticle. Insira o seguinte código na seção iniciar logo após o método flatMap(doc -> bucket.upsert(doc)) ligar:

Precisamos criar o manuseio para configurar essa rota:

Vamos testá-lo: execute o aplicativo e acesse este URL: http://localhost:8080/users/user1. Você verá o JSON da Alice, servido diretamente do Couchbase!

Para outra chavevocê deverá ver a exceção no formato JSON:

Interromper o Verticle por meio de um ponto de extremidade HTTP

Vamos adicionar rapidamente uma rota que pare a Vert.x, para diversão e lucro :)

Fechamento do Couchbase e do Vertx

Observe que, ao executar a partir de uma vertx Starter, isso não eliminará a thread principal

"); vertx.close(); }

Abertura http://localhost:8080/stop acionará a parada de todo o aplicativo Vert.x, destruindo os Verticles implantados.

Observação: Conforme indicado na mensagem, isso não elimina o processo quando executado a partir do IDE.

Conclusão

Nesta postagem do blog, descobrimos como Vert.x e o SDK Java do Couchbase podem trabalhar juntos para criar um aplicativo totalmente assíncrono.

Feliz codificação assíncrona!