🚔 🚐 👨‍🚒 Tutorial: Inicialização reativa por mola 👨‍🚀 😁 😚

No mês passado, Trisha Gee (JetBrains) apresentou na SpringOne uma demonstração da criação de um aplicativo de preço das ações em tempo real usando o Spring Boot, Kotlin e JavaFX. A demonstração ao vivo foi gravada e está disponível em um vídeo de 70 minutos .

Em 18 de dezembro, Trisha concluiu a publicação no dzone.com do tutorial reativo do Spring Boot com base no vídeo, como uma série de vídeos mais curtos com uma postagem no blog explicando cada etapa mais lentamente e com mais detalhes.

Tive a ideia de traduzir este tutorial para o russo. No entanto, Trisha respondeu educadamente com minha pergunta sobre isso:

"Deixe-me verificar com minha organização. Eu adoraria traduzi-lo, mas podemos ter uma maneira preferida de traduzir as coisas. ”

Então, decidi me limitar a uma visão geral deste tutorial, que inclui as seguintes séries de lições:

O tutorial é uma série de lições nas quais um aplicativo Spring Boot completo será criado com a interface interna do Kotlin, cliente Java e interface de usuário JavaFX.

Parte 1. Criando um serviço REST no Kotlin

A primeira parte do tutorial descreve como criar um aplicativo Spring Boot no Kotlin, que serve como o lado do servidor do aplicativo. Um serviço REST reativo será criado, ao qual você pode se conectar nas seguintes partes do manual.

Esta entrada de blog contém um vídeo mostrando o processo passo a passo e um guia de texto (adaptado da transcrição do vídeo) para aqueles que preferem um formato escrito.

Esta parte do tutorial inclui as seguintes etapas:

Criando um projeto de serviço de inicialização Spring
Estrutura do projeto Spring Boot
Criando um controlador REST
Criando uma classe de dados para preços de ações
Geração e devolução de preço
Lançamento do aplicativo

Após concluir estas etapas na parte 1 do tutorial, será criado um aplicativo simples Kotlin Spring Boot que usa o Reactive Streams para emitir um preço das ações gerado aleatoriamente uma vez por segundo.

O código completo da parte 1 do tutorial está disponível no GitHub .

Parte 2. Cliente REST para Fluxos Reativos

A parte 2 do tutorial mostra como criar um cliente Java reativo no Spring que se conecta a um serviço REST que transmite os preços das ações uma vez por segundo. Este cliente será usado nas seções subseqüentes do manual. Durante o desenvolvimento, um processo baseado em TDD será usado para criar o cliente e testá-lo.

Esta entrada de blog contém um vídeo mostrando o processo passo a passo e um guia de texto (adaptado da transcrição do vídeo) para aqueles que preferem um formato escrito.

Esta parte do tutorial inclui as seguintes etapas:

Criando um projeto para um cliente
Criando uma classe de cliente
Criando um teste do cliente
Criando um método de preço base do cliente
Crie uma classe para manter os preços das ações
Adicionando asserções ao teste
Conecte o cliente ao serviço REST
Executar teste de integração
Asserções mais completas no teste de integração

Testar aplicativos reativos não é uma habilidade fácil, e certamente existem maneiras muito melhores de fazer isso do que neste exemplo simples. No entanto, um teste de integração foi usado com sucesso para determinar a API e a funcionalidade do cliente para os preços das ações.

Esse cliente se conecta ao terminal, que gera eventos enviados pelo servidor e retorna um fluxo de objetos StockPrice que podem ser usados por outro serviço. Como fazer isso será mostrado nos próximos vídeos desta série.

O código completo de 2 partes está disponível no GitHub .

Parte 3. Aplicativo JavaFX Spring Boot

A terceira demonstração mostra como criar um aplicativo JavaFX que é iniciado e gerenciado através do Spring Boot para usar os recursos do Spring, como Inversão de Controle e Injeção de Dependência, em nosso aplicativo JavaFX.

Esta entrada de blog também contém um vídeo mostrando o processo passo a passo e um guia de texto (adaptado da transcrição do vídeo) para aqueles que preferem um formato escrito.

Esta parte do tutorial inclui as seguintes etapas:

Configuração do módulo
Alterando a classe do aplicativo Spring Boot
Editando as configurações de inicialização do Spring
Criando uma classe de aplicativo JavaFX
Configurando a classe Aplicativo de Inicialização Spring
Publicando Eventos através do Contexto do Aplicativo
Criar contexto de aplicativo
Fechando o contexto do aplicativo
Ouvindo eventos de aplicativos

Após concluir as etapas 3 do tutorial, será criada a janela principal do aplicativo JavaFX (Etapa - consulte a parte 2 do Tutorial JavaFX ), que permite configurar a interface do usuário. Em seguida, você pode executar nosso aplicativo StockUIA e ver se ele é iniciado com êxito como um aplicativo Spring Boot. Ele também inicia um processo Java que exibia a interface do usuário se a criassemos. No momento, um aplicativo JavaFX foi criado com sucesso, que é iniciado e gerenciado usando o Spring e permite que você use as funções convenientes de qualquer aplicativo Spring.

O código completo do tutorial em 3 partes está disponível no GitHub.

Parte 4. Gráfico de linhas JavaFX

Nesta etapa do tutorial, veremos como criar um aplicativo JavaFX que mostra um diagrama de linhas. Este aplicativo usa o Spring para funções importantes, como inversão de controle.

Esta entrada de blog contém um vídeo mostrando o processo passo a passo e um guia de texto (adaptado da transcrição do vídeo) para aqueles que preferem um formato escrito.

Esta parte do tutorial inclui as seguintes etapas:

Criando uma cena (Cena - consulte a parte 2 do Tutorial JavaFX )
Usando FXML
Criando um arquivo FXML
Definir cabeçalho do aplicativo
Configurando o cabeçalho do aplicativo a partir de application.properties
Obtendo os controladores JavaFX da Spring
Criar um gráfico de linhas

Após concluir as etapas acima, a parte 4 do tutorial criará um aplicativo JavaFX. Após o lançamento do aplicativo, devemos ver o esboço do gráfico de linhas mostrado em nossa janela, com números para o preço ao longo do eixo Y e o tempo ao longo do eixo X.

Foi criado um aplicativo JavaFX integrado ao Spring Boot que usa FXML para declarar o que deve ser exibido na exibição.

O código completo para esta parte do tutorial está disponível no GitHub.

Parte 5. Configuração automática para beans compartilhados

A lição 5 mostra como usar o Spring beans de um módulo em outro módulo usando a configuração automática.

Esta entrada de blog também contém um vídeo mostrando o processo passo a passo e um guia de texto (adaptado da transcrição do vídeo) para aqueles que preferem um formato escrito.

Na última lição, foi criado um aplicativo JavaFX Spring Boot que mostrava um diagrama de linhas vazio. Neste vídeo, veremos como configurar a autoconfiguração para o Spring Beans para que possamos usar os componentes do bean definidos no módulo stock-client no módulo stock-ui.

Esta parte do tutorial inclui as seguintes etapas:

Adicionando uma dependência em outro módulo
Criando um Bean WebClientStockClient
Ativar configuração automática

Essa é uma parte muito pequena do tutorial, mas nos permite criar módulos que podem ser reutilizados por vários aplicativos Spring Boot. Agora podemos usar o cliente no ChartController para conectar-se ao serviço de preços e começar a exibir os preços em tempo real em um gráfico de linhas.

O código completo desta parte está disponível no GitHub.

Parte 6. Exibição de dados reativos

Esta lição discute a conexão dos diagramas JavaFX ao nosso serviço Kotlin Spring Boot para exibir preços em tempo real. Esta entrada de blog contém um vídeo mostrando o processo passo a passo e um guia de texto (adaptado da transcrição do vídeo) para aqueles que preferem um formato escrito.

Na quarta parte , foi criado o aplicativo JavaFX Spring Boot, que mostra um diagrama de linhas vazio. A última versão ( quinta parte ) usou o WebClientStockClient para conectar-se ao serviço de preços. Nesta parte, foi obtido um gráfico de linhas mostrando os preços provenientes do nosso serviço Kotlin Spring Boot em tempo real.

Esta parte do tutorial inclui as seguintes etapas:

Configurando dados do gráfico
Inscrever-se nos dados de preços
Exibição de dados de preços
Lançamento do aplicativo
Exibição do nome do personagem
Limpeza de código

Algumas linhas de código nesta parte do tutorial criaram um aplicativo JavaFX que usa o SpringClient para conectar-se ao serviço Spring Boot, assina um fluxo de preço reativo e desenha os preços em um gráfico de linhas em tempo real.

O código completo desta parte está disponível no GitHub.

Parte 7. Inscrevendo-se em Vários Assinantes

Na parte anterior , assinamos um gráfico de linhas JavaFX para obter preços do serviço Reactive Spring Boot e os exibimos em tempo real.

Nesta lição, um cronograma de atualização em tempo real será finalizado para mostrar os preços de mais de um estoque, o que exige que mais de um consumidor assine nosso fluxo de preços reativo.

No blog, você encontrará um vídeo mostrando o processo passo a passo e uma descrição de texto (adaptada da transcrição do vídeo) para aqueles que preferem um formato escrito.

Esta parte do tutorial inclui as seguintes etapas:

Percebemos os preços dos assinantes
Transferência de taxas para um assinante de preços
Adicionando um segundo assinante
Limpeza de código
Refatoração de bônus (não no vídeo!)

No final desta parte do tutorial, você criará um aplicativo JavaFX que assina mais de um preço do nosso serviço Spring Boot e exibe cada conjunto de dados de preços em tempo real em várias séries em um gráfico de linhas.

O código completo desta parte está disponível no GitHub.

Parte 8. Servidor Kotlin RSocket

Nesta lição , um novo serviço interno será adicionado ao Kotlin, que envia preços via RSocket, um protocolo para fluxos reativos. Esta entrada de blog contém um vídeo mostrando o processo passo a passo e um guia de texto (adaptado da transcrição do vídeo) para aqueles que preferem um formato escrito.

Nesta etapa da série de tutoriais, foi criada com sucesso um aplicativo abrangente que publica preços do serviço Kotlin Spring Boot e os exibe em um gráfico de linhas JavaFX. Ele usa o protocolo HTTP para enviar eventos para o servidor. No entanto, como esse é um aplicativo reativo, podemos escolher o protocolo mais adequado para o fluxo de dados.

Nesta parte do tutorial, será criado um serviço que produz dados de preços usando o protocolo RSocket.

Esta parte do tutorial inclui as seguintes etapas:

Criando um Controlador RSocket
Percebemos o serviço de preços
Portando código comum para PriceService
Reduzir a duplicação de código
Refatoração para reduzir o Boilerplate
Configurações de exibição de mensagens
Configuração do servidor RSocket

No final desta parte do tutorial, a porta 7000 lançará um serviço de preços, pronto para conectar um cliente para receber os preços das ações por meio do RSocket.

O código fonte completo desta parte está disponível no GitHub.

Parte 9. Cliente Java RSocket

Nesta lição, adicionaremos um cliente RSocket que pode se comunicar com o servidor RSocket que criamos na última lição .

Esta entrada de blog contém um vídeo mostrando o processo passo a passo e um guia de texto (adaptado da transcrição do vídeo) para aqueles que preferem um formato escrito.

Atualmente, temos um aplicativo que funciona do início ao fim usando o WebClient da Spring. Na última lição, apresentamos o novo servidor RSocket, que está funcionando atualmente, e nesta lição veremos como criar um cliente para conectar-se a ele.

Esta parte do tutorial inclui as seguintes etapas:

Crie um teste de integração
Criando o RSocket Stock Client
Apresentando a Interface StockClient
Implementação de conexão RSocket
Criando RSocketRequester
Teste de Integração
Testando com StepVerifier
Adicionando estratégias de recuperação e manipulação de erros

No final desta parte do tutorial, teremos um servidor RSocket que gera preços das ações e um cliente RSocket que pode se conectar a ele e ver esses preços. Na próxima lição, veremos como passar do WebClientStockClient para o nosso novo RSocketStockClient.

O código fonte completo desta parte está disponível no GitHub.

Parte 10. Perfis de mola para alternar clientes

A parte final do tutorial usa a configuração Spring Profiles para que o aplicativo possa determinar qual dos nossos dois clientes (eventos enviados pelo servidor via WebClient ou RSocket) usar para se conectar ao nosso serviço de preços do Kotlin Spring Boot.

Como sempre, esta postagem do blog contém um vídeo mostrando o processo passo a passo e um guia de texto (adaptado da transcrição do vídeo) para aqueles que preferem um formato escrito.

Nesta fase da série de tutoriais, temos um cliente RSocket que nos permite conectar-se ao nosso servidor RSocket. Queremos usar esses recursos em nosso aplicativo JavaFX.

Esta parte do tutorial inclui as seguintes etapas:

Criando um Bean RSocketStockClient
Escolhendo um Bean para Usar
Seleção de perfil ativo
Registrando para Depuração
Obter preços através do RSocket

No final desta parte do tutorial, teremos um aplicativo de gráfico de linhas JavaFX completo e abrangente que assina o fluxo de preço reativo do aplicativo Kotlin Spring Boot. Além disso, o aplicativo pode ser configurado para receber esses preços por meio de eventos enviados pelo servidor ou pelo novo protocolo RSocket.

O código completo está disponível no GitHub:

Projeto do cliente (stock-client e stock-ui-modules).
Projeto de servidor (aplicativo Kotlin Spring Boot)

Leitura adicional

Totalmente reativo: Spring, Kotlin e JavaFX tocando juntos [Links]
Kotlin Microservice Com Spring Boot Tutorial
Programação reativa por mola em Java

Tutorial: Inicialização reativa por mola