Casa do Código - Livros e Tecnologia

  • Programação
  • Lógica
  • Java
  • .NET
  • PHP
  • Games
  • OO
  • Funcional
  • Python
  • Outros
  • Todos
  • Mobile
  • iOS
  • Android
  • Multiplataforma
  • Outros
  • Todos
  • Front-end
  • HTML e CSS
  • JavaScript
  • Outros
  • Todos
  • Infraestrutura
  • Web
  • Dados
  • Outros
  • Todos
  • Business
  • Startups
  • Marketing Digital
  • Gestão
  • Agile
  • Outros
  • Todos
  • Design & UX
  • Você tem 0 itens na sacola 0 Abrir navegação por categorias e busca Ir para ao topo da página

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

    *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:
    Data publicação:
    Fórum de discussões

    Compartilhe!

    Compartilhe no Facebook Compartilhe no Twitter

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

    altLogoFooter

    Links da
    Casa do Código

    • Meus ebooks
    • Sobre a Casa do Código
    • Todos os livros
    • Nossas coleções
    • Quero escrever um livro ou fazer parceria
    • Perguntas Frequentes
    • Política de Privacidade

    Nas redes sociais

    • /CasaDoCodigo
    • @casadocodigo
    • @casadocodigo

    Receba novidades e lançamentos

    Este site aceita

    • pag seguro
    • paypal

    Grupo Alura

    • Educação em Tecnologia

      • FIAP
      • Casa do Código
      • PM3 - Cursos de Produto
    • Mais Alura

      • Alura Start
      • Alura Língua
      • Alura Para Empresas
      • Alura LATAM
    • Comunidade

      • Tech Guide
      • 7 days of code
      • Hipsters ponto Jobs
    • Podcasts

      • Hipsters ponto Tech
      • Dev sem Fronteiras
      • Layers ponto Tech
      • Like a Boss
      • Scuba Dev