Use o código e tenha 10% de desconto!

Microsserviços e EJB Escale sua aplicação, não a complexidade

Gilliard Cordeiro

*Você terá acesso às futuras atualizações do livro.

Sobre o livro

Para quem é o livro?

Este livro foi escrito para você que busca saber como desenvolver o back-end da sua aplicação com Java, seja no modelo tradicional ou de microsserviço.

Provavelmente você já passou por situações em que sua aplicação tinha comportamentos que você não entendia e teve que buscar alguma solução na internet, que até funcionou, mas você também não sabe muito bem por quê. O pior é que, às vezes, nem mesmo quem passou a solução sabe explicar, pois também pegou de outra pessoa; e nesse cenário vem o "faz assim que funciona".

Aqui vamos fazer o oposto disso: no lugar de jogar a solução de qualquer jeito, vamos construí-la juntos e entender cada parte. Porém, como sei que em algumas situações precisamos de uma solução mais rápida, seja pela urgência do projeto, ou mesmo porque já sabemos o conceito, mas esquecemos a sintaxe, temos o livro dividido em duas pates: a primeira é mais direta ao ponto, e a segunda detalha mais a solução.

Como este livro está organizado

Parte 1: Início rápido

Pensando em situações em que temos pouco tempo para nos aprofundar em um aprendizado mais denso, foi criada uma parte inicial, com dois capítulos, nos quais é apresentado como criar rapidamente uma aplicação com microsserviços usando EJBs, JAX-RS e JPA. Essa primeira parte poderia ser considerada um "mini-book" sobre microsserviços com back-end em Java.

Principais temas:

* Criação de serviços REST com JAX-RS e JPA

* Utilização do Thorntail (Java EE MicroProfile)

* Gestão automática de transações do Java EE

Parte 2: Conhecendo de forma mais profunda

Na segunda parte, passamos para um aprendizado mais tradicional. A cada novo capítulo, veremos novos conteúdos e consolidaremos o conhecimento anterior. Aqui temos um ritmo mais cadenciado, onde o conteúdo é um pouco mais extenso e mais completo.

Principais temas:

* Session Beans: Staless, Stateful, Singleton, Remotos, Locais, Sem interface

* Com usar JPA com gerenciamento automático de transações

* Como fazer um ajuste fino nas transações

* Como lidar com várias transações na mesma requisição

* Implementando testes de integração com Arquillian

* Aprendendo mais a fundo a construção de WebServices REST

* Server-Sent Events (SSE) e Reactive Client API (JAX-RS 2.1, Java EE 8)

* Trabalhando com serviços assíncronos e paralelismo

* Utilizando a Concurrency Utilities for Java EE

Em resumo, o livro visa ser uma referência das principais ferramentas com que lidamos no dia a dia, mas nem tudo precisa ser visto antes de iniciar nossos projetos. Inicie pela primeira parte, e vá pinçando os conteúdos que precisa aprender nos demais capítulos do livro. Desejo a você uma boa leitura.

Pré-requisitos

Para aproveitar bem este livro é importante que você já tenha o conhecimento da linguagem Java e também entenda como funciona uma aplicação web; basicamente requisição e resposta.

Versões das principais ferramentas utilizadas

* Este livro se baseia no Java EE 8 mas serve também para o Java EE 7 já que ambas usam EJB 3.2.

* O código geral está usando o Java 8.

* O servidor de aplicação utilizado foi o Wildfly 19.

* Na primeira parte do livro usamos o Thorntail 2.6.0.Final.

* A IDE sugerida é o Netbenas 12, mas qualquer IDE Java servirá, pois os projetos usam o Maven.

* Como dito anteriormente, os projetos usam Maven 3.6.3.

* E para os testes de integração usamos o Arquillian 1.6.0.

Sumário

  • Parte 1: Início rápido
  • 1 Microsserviços e Java EE
    • 1.1 Por que microsserviços?
    • 1.2 Thorntail ou Spring Boot?
    • 1.3 Criando primeiro serviço com JAX-RS
    • 1.4 Adicionando persistência de dados
    • 1.5 EJBs e Java EE no geral não são muito complexos para microsserviços?
  • 2 Serviços REST com JAX-RS
    • 2.1 Escalando serviços REST através do uso de Cache
    • 2.2 Revalidando o cache com GETs condicionais
    • 2.3 Cliente usando GET condicional
    • 2.4 Server-Sent Events (SSE) como alternativa ao cache
    • 2.5 Enviando dados (POST) através do cliente REST
    • 2.6 Criando uma interface Java do lado cliente para servir de proxy
    • 2.7 Enviando dados através de um POST condicional
    • 2.8 Como o desenvolvimento de microsserviços se relaciona com o restante do livro
  • Parte 2: Conhecendo de forma mais profunda
  • 3 Sendo reapresentados aos EJBs
    • 3.1 Por que usar EJB hoje em dia?
    • 3.2 O que vamos usar para criar nossa aplicação?
    • 3.3 Fazer o código na mão, utilizar Wizards, ou o JBoss Forge?
    • 3.4 Baixando o servidor e criando o projeto
    • 3.5 Criando um EJB simples
  • 4 Os Sessions Beans por estado
    • 4.1 EJB Stateless
    • 4.2 EJB Stateful
    • 4.3 Removendo um EJB Stateful
    • 4.4 Removendo um bean Stateful via timeout
    • 4.5 Lidando com Stateful Session Beans removidos e NoSuchEJBException
    • 4.6 Remoção automática de beans Stateful associados a um contexto CDI
    • 4.7 EJB Singleton
  • 5 Os Sessions Beans por interface
    • 5.1 EJBs Remotos
    • 5.2 Desenvolvendo um EJB remoto
    • 5.3 Criando um cliente de EJB remoto
    • 5.4 EJBs Locais
    • 5.5 EJBs sem interface
    • 5.6 Revisão geral sobre exposição de interfaces dos EJBs
  • 6 Integrando EJB e JPA
    • 6.1 Iniciando com a JPA
    • 6.2 Primeiras diferenças entre JPA puro e seu uso com EJBs
    • 6.3 Usar o padrão DAO, Service Bean + Controller, ou tudo junto?
    • 6.4 Usando JSF para construir as telas
    • 6.5 Lidando com LazyInitializationException ou equivalente
    • 6.6 Evitando LazyInitializationException com EJB Stateful
  • 7 Gerenciando transações com EJBs
    • 7.1 Executando commit em uma transação
    • 7.2 Executando rollback em uma transação
    • 7.3 Exceções de sistema e exceções de aplicação
    • 7.4 EJB Stateful e o rollback de transações
  • 8 Lidando com mais de uma transação
    • 8.1 As opções de transações com @TransactionAttribute
  • 9 Testando nossos serviços
    • 9.1 Criando testes de integração com Mockito
    • 9.2 Criando testes de integração com o contêiner
    • 9.3 Utilizando o Arquillian para testes de integração
    • 9.4 Configurando o Arquillian na nossa aplicação
    • 9.5 Criando um teste "hello world"
    • 9.6 Criando um teste real
    • 9.7 Usando mocks nos testes com Arquillian
  • 10 Criando WebServices com JAX-RS
    • 10.1 JAX-RS: Transformando um EJB em um serviço REST que devolve JSON
    • 10.2 Retornando um XML através do serviço REST
    • 10.3 Retornando diferentes formatos com o mesmo serviço REST
    • 10.4 Criando um cliente de serviço REST
    • 10.5 Criando um cliente JS para um serviço REST
    • 10.6 Acessar diretamente a camada de negócios a partir da visualização é uma boa?
  • 11 Server-Sent Events ou SSE (JAX-RS 2.1, Java EE 8)
    • 11.1 Reactive Client API (JAX-RS 2.1, Java EE 8)
    • 11.2 A diferença entre Future e CompletionStage
    • 11.3 Como usar o CompletionStage?
  • 12 Métodos assíncronos e paralelismo para aumento de performance
    • 12.1 O uso de @Asynchronous para não bloquear o usuário
    • 12.2 Recuperando o retorno de uma execução em segundo plano
    • 12.3 Executando código em paralelo com @Asynchronous
    • 12.4 Paralelizando a persistência no banco de dados
    • 12.5 Pós-créditos
  • 13 Utilizando a Concurrency Utilities for Java EE
    • 13.1 Criando um novo Managed Executor Service
    • 13.2 Criando um Executor Service programaticamente
  • 14 Conclusão

Dados do produto

Número de páginas:
378
ISBN:
978-65-86110-38-8
Data publicação:
09/2020

Compartilhe!

Compartilhe no Facebook Compartilhe no Twitter

*Você terá acesso às futuras atualizações do livro.