Pular para o conteúdo

Curso SOA na Prática: Integração com Web Services e Mensageria

FD9E034F-C706-472D-ABA4-310433A703E5 Created with sketchtool. 40 horas/curso
Veja as próximas turmas

O que você vai fazer

Para quem é esse curso?

Este curso é focado para todos aqueles que necessitam trabalhar com integrações entre sistemas. Não importa o estilo de integração, ela sempre vem recheada de detalhes e você vai estudar vários deles neste curso. Será discutido integração via Web Service Rest, Soap, Mensageria etc. Também será trabalhado ferramentas que facilitam a orquestração desses serviços como o Apache Camel e o Mule.

Para aproveitar melhor o curso recomendamos que você tenha conhecimento em

Curso Java e Orientação a Objetos - Curso Java para Desenvolvimento Web - Curso Persistência com JPA, Hibernate e EJB lite

Próximas turmas

Selecione a cidade e os períodos de sua preferência

Qual cidade você pode ir?
Quais períodos você prefere?
Ver turmas encontradas

Nós encontramos essas turmas:

Não achou a turma ideal pra você? Consulte outras turmas e horários.

Entre em contato

O que os alunos falam

Sidney Amaral

O instrutor procurou puxar dos alunos uma visão pragmática, e sempre propôs um caminho prático e seguro. Muito bom o curso, recomendo.

Mateus Gobo

Sensacional, atendeu plenamente minhas necessidades.

Thiago Franceschini

Excelente. O professor cobriu a ementa da apostila e foi muito além com práticas mais atuais surpreendendo a expectativa quanto ao curso

Conteúdo detalhado do curso FJ-36

    Como aprender SOA e Integração

  1. Falando em Java
  2. O curso
  3. Sobre os exercícios
  4. Sobre os cursos
  5. Indicação de bibliografia extra
  6. Tirando dúvidas

    Arquitetura de sistemas distribuídos

  1. A livraria
  2. Exercícios: Preparando o Ambiente
  3. Serializando e Persistindo Objetos
  4. Implementando uma classe Serializable
  5. Compatibilidade (serialVersionUID)
  6. Serialização em Cascata
  7. Atributos Transientes
  8. Exercícios: Serialização Java
  9. Invocação remota de método
  10. Java RMI - Remote Method Invocation
  11. Colocando o objeto no Servidor
  12. Quem são os servidores?
  13. O Cliente
  14. E os stubs?
  15. Rodando a aplicação
  16. Exercícios: Sistema de Estoque com RMI
  17. Erros comuns no desenvolvimento
  18. Exercícios: Integração da livraria com o estoque

    Web Services SOAP com JAX-WS

  1. Integração hetereogênea
  2. Estilos de integração
  3. SOA vs Integração
  4. Web Services
  5. Exercícios: Instalação do JBoss AS 8 - Wildfly
  6. Exercício - Configuração do usuário administrador do Wildfly
  7. Configurando o JBoss Wildfly no Eclipse em casa
  8. SOAP - Simple Object Access Protocol
  9. Exercício Opcional: SAAJ
  10. WSDL: o contrato do seu Web Service
  11. Web Services com JAX-WS
  12. Exercícios: Disponibilizando Web Service com JAX-WS
  13. Testando o Web Service com SoapUI
  14. Exercícios: Consumindo o Web Service
  15. Granularidade do Serviço
  16. SOA Fallacies
  17. Exercícios - Granularidade do serviço
  18. Mais recursos do JAX-WS
  19. Exercícios: Personalizando o Web Service
  20. A importância do versionamento
  21. Segurança no Web Service
  22. Entendendo e habilitando HTTPS
  23. Gerando o certificado
  24. Habilitando HTTPS no servidor
  25. Introdução aos padrões WS-
  26. Conhecendo o WS-Security
  27. Exercícios: Autorização e Versionamento
  28. Criação do cliente com JAX-WS
  29. Exercícios: Usando o Web Service na livraria
  30. Abordagem: Contract first - Web Service Java a partir de um WSDL
  31. Contract first vs Contract last
  32. Um pouco do modelo canônico
  33. Exercícios: Consumindo o Web Service dos Correios

    Web Services Restful com JAX-RS

  1. Uma alternativa - o estilo Arquitetural REST
  2. Orientado ao recurso
  3. Diferentes representações
  4. Métodos HTTP
  5. Hipermídia
  6. Vantagens Restful
  7. Web-Services REST com JAX-RS
  8. Botando pra rodar
  9. Usando Resources com JAX-RS
  10. Outros tipos de retorno
  11. Buscando um recurso específico
  12. Usando o JAX-RS com EJB3
  13. Exercícios: JAX-RS com Resteasy
  14. Inserindo dados
  15. Exercícios: Criação de resources de maneira Restful
  16. Coreografia de serviços utilizando HATEOAS
  17. Exercícios: Aplicando HATEOAS
  18. Hypermidia com Spring Hateoas
  19. Controlando o XML gerado pelo JAX-RS
  20. Exercício Anotações do JAX-B
  21. JAX-RS 2.0 Client API
  22. Versionamento de serviços REST
  23. Exercícios: Cliente Restful com JAX-RS 2.0
  24. Cliente JAX-RS com XML
  25. Exercício Opcional - Cliente JAX-RS com XML
  26. Um pouco sobre Microservices

    Mensageria com Java Message Service e HornetQ

  1. Assíncrono vs Síncrono
  2. Middleware Orientado à Mensagens (MOM)
  3. Modelos de entregas: Email ou Lista de Discussão?
  4. Criação de Queues e Topics no JMS
  5. Exercícios: Configuração do HornetQ e a primeira fila
  6. JMS 2.0
  7. ConnectionFactory
  8. JMSContext
  9. Enviando uma mensagem
  10. Consumindo mensagens enviadas para a fila
  11. Exercícios: Consumindo mensagens da fila
  12. Para saber mais - JMS 1.0
  13. Para saber mais - Componentes do JMS 1.0
  14. Assinaturas duráveis
  15. Exercícios: Durable Subscriber
  16. Roteamento baseado no conteúdo
  17. Exercícios: Roteamento com Selectores
  18. Persistindo mensagens
  19. Recebendo mensagens no Servidor de Aplicação
  20. Exercícios opcionais: Message Driven Bean
  21. Integrando o Spring com o JMS
  22. Exercícios: Envio de mensagens na livraria
  23. Para saber mais Shared Consumer do JMS 2
  24. ActiveMQ, RabbitMQ, Apache Apollo e outros
  25. Mensageria na Cloud
  26. Mensagens independentes de plataforma: AMQP, Stomp e REST

    Criação do modelo canonical

  1. Mensagens - XML
  2. Modelo Canonical e o seu Contexto
  3. Introdução ao JAXB
  4. Serializando dados compostos
  5. Usando ObjectFactory
  6. Exercícios: Serialização para XML com JAX-B
  7. Definição de Tipos - XML Schema Definition (XSD)
  8. Identificação pelo Namespace
  9. Exercícios: Schema e Namespace
  10. Exercícios opcionais: Validação com XSD
  11. Serializando JSON: MOXy, Jackson e Jettison
  12. Exercícios opcionais: Serializando JSON com Jackson
  13. Validando JSON com JSON Schema
  14. Exercícios: Enviando mensagens XML pela loja

    Aplicando Enterprise Integration Pattern

  1. Frameworks de Integração
  2. Apache Camel
  3. Os primeiros Components e Endpoints
  4. Camel DSL
  5. Exercícios: Roteamento com Apache Camel
  6. Aplicando os primeiros padrões de integração
  7. Tratamento de exceções
  8. Validação de XSD com Camel
  9. Exercícios: Validação de Mensagens, Redelivery e Dead Letter Channel
  10. Marshall e Unmarshal de dados
  11. Polling em serviços HTTP
  12. Message Splitter
  13. Exercício: Realizando Polling em um serviço
  14. Polling no banco de dados
  15. Camel JDBC
  16. Exercício: Inserindo os livros no banco de dados
  17. Integração do Camel com Spring
  18. Enviando e consumindo mensagens JMS
  19. Exercícios: Consumindo mensagens JMS com Apache Camel
  20. Pipes e Filters
  21. Exercícios opcionais: Filtro e divisão de conteúdo
  22. Integrar serviços SOAP e REST
  23. Orquestração de tarefas e serviços
  24. Agregação de mensagens
  25. Exercícios opcionais: Orquestração e Template
  26. Framework de integração ou Enterprise Service Bus?

    Enterprise Service Bus

  1. O que é um ESB?
  2. Quando usar um ESB?
  3. Exercícios: Instalação do AnypointStudio
  4. Fluxo com Mule ESB
  5. Exercícios: Criação do primeiro fluxo
  6. Roteamento pelo Namespace
  7. Exercícios: Roteando entre versões do serviço
  8. Transformação da mensagem pelo XSLT
  9. Exercícios opcional: Aplicando XSLT para adicionar novos headers SOAP
  10. Orquestração de serviços
  11. Exercícios: Desenhando o fluxo de pedidos
  12. Exercícios: Filter, Split e Transformação de dados
  13. Exercícios: Multicast com Scatter-Gather Pattern
  14. Exercícios opcionais: Chamando serviços
  15. Tratamento de Erro
  16. Exercícios opcionais: Exception Strategy

    *Apêndice: OAuth 2.0

  1. Participantes do fluxo do OAuth
  2. Access Token
  3. Exercício
  4. Obtenção do Access Token
  5. Resource Owner Password Credential Grant
  6. Exercícios
  7. Obtendo um access token na aplicação cliente
  8. Implementando e consumindo um serviço protegido
  9. Exercícios: Consumindo um servidor protegido
  10. Authorization Code Grant
  11. Implementando o Authorization Code Grant com o Apache Oltu
  12. Exercício Authorization Code Grant
  13. Considerações sobre a implementação
  14. Credencias do usuário e do client application
  15. Authorization Code
  16. Access Token
  17. Cross Site Request Forgery
  18. Filtros do JAX-RS
  19. Exercícios
  20. Para saber mais: Provedores OAuth 2.0
  21. Para saber mais: Outros clientes OAuth 2.0
  22. Exercício opcional: OAuth2 com Github

    *Apêndice: Swagger

  1. Ferramentas para modelagem e documentação de APIs REST
  2. Mas o que exatamente é o Swagger?
  3. Modelando a API da Payfast
  4. Defininindo o modelo de dados
  5. Defininindo os recursos da API
  6. Definindo os parâmetros de request
  7. Definindo os tipos de response
  8. Exercício: Modelando uma API com Swagger
  9. Documentando uma API já existente
  10. Obtendo a documentação gerada pelo Swagger
  11. Corrigindo alguns detalhes
  12. Documentação para humanos
  13. Exercício: Documentando a API do Payfast com Swagger

* Apêndices são conteúdos adicionais que não fazem parte da carga horária regular do curso. São conteúdos extras para direcionar seus estudos após o curso.

Não encontrou o curso que procura? Conheça a Alura, a plataforma online da Caelum

Conheça a Alura