Prepare-se para o treinamento imersivo e online sobre desenvolvimento de REST APIs com Spring mais completo do mundo, sem nenhum exagero!
Leia abaixo as principais coisas que você vai aprender nas aulas, do zero, passo a passo e com aulas teóricas e práticas.
Você vai conhecer os principais projetos do ecossistema Spring para desenvolvimento de REST APIs, como Spring Framework, Spring MVC, Spring Boot, Spring Data JPA, Spring Security, Spring Security OAuth e Spring HATEOAS.
Vai também entender definitivamente como funciona a injeção de dependências com Spring, o IoC Container, definição de beans com @Component, @Configuration e @Bean, pontos de injeção, desambiguação com @Primary, @Qualifier e anotação customizada.
Além disso, você vai aprender a trabalhar com Spring Profiles, publicação e consumo de eventos customizados, configuração de projetos com application.properties e diferenciação por profile, criação e acesso de propriedades customizadas com @Value e @ConfigurationProperties, etc.
Você vai aprender o que é ORM, como fazer mapeamento de entidades e relacionamentos com JPA (OneToMany, ManyToOne, ManyToMany, OneToOne e Embedded).
Vai também entender e trabalhar com transações no Spring, usar JPQL e Criteria do JPA, fazer joins e fetch em relacionamentos, entender e configurar um pool de conexões (Hikari), etc.
Além disso, você ainda vai ver como criar e evoluir o schema do banco de dados com Flyway, criar migrações com remanejamento de dados, reparar migrações com erros, adicionar dados de testes com callback do Flyway, etc.
E ainda, vamos instalar e usar Lombok nas nossas classes para reduzir código boilerplate.
Você vai conhecer os super poderes do Spring Data JPA, como criação de repositórios super inteligentes com a abstração do SDJ, criação de query methods com filtros, paginação e ordenação e parâmetros nomeados.
Vai também aprender a implementar repositórios customizados, externalização de consultas JPQL em arquivo XML, implementar consultas com o padrão Specifications (DDD), etc.
Durante o desenvolvimento do projeto o curso, usaremos alguns conceitos e padrões do DDD, como Repository, Aggregate, Aggregate Root, Domain Event, Domain Service, Infrastructure Service, Specification e Linguagem Ubíqua.
Você vai dominar os fundamentos de REST definitivamente, entender o que é e o que não é esse estilo arquitetural e as constraints do REST.
Vai entender o que é de fato e a diferença conceitual e prática de uma API, Resource, Resource Model, Resource Representation, Resource Identifier, Resource Methods, Collection Resources, Singleton Resource e Sub-collection Resources.
Você também vai conhecer todos os níveis do Modelo de Maturidade de Richardson e conhecer a abordagem pragmática e purista de desenvolvedores de REST APIs.
E ainda, você vai entender com mais detalhes o protocolo HTTP, quais são os principais códigos de status do HTTP e quando usar e não usar cada um deles, identificar e entender os métodos seguros e idempotentes do HTTP, conhecer e entender quais métodos HTTP você deve usar, etc.
Você vai aprender a criar, configurar e desenvolver uma API do zero e passo a passo, usando vários projetos do ecossistema Spring.
Vai desenvolver serviços com diversos métodos HTTP, inclusive vai aprender a fazer atualização parcial com PATCH e fazer content negotiation, e tudo seguindo as boas práticas que serão discutidas e ensinadas nas aulas.
Que tal aprender a fazer validações de entradas da sua API de forma profissional e avançada?
Você vai aprender a adicionar validações no seu modelo com as anotações do Bean Validation.
Vai aprender também a customizar mensagens de validação, criar validações compostas, criar validações customizadas com ConstraintValidator, criar validações customizadas em nível de classe, criar grupos de validações, validar associações em cascata, executar checagem de validações programaticamente, entender a diferença do Resource Bundle do Spring e do Bean Validation, etc.
Tratar exceptions é muito importante, mas tão importante quanto isso, é devolver como resposta o código de status HTTP adequado e uma representação padrão do problema. Infelizmente, pouca gente faz isso direito.
Mas nesse treinamento você vai aprender a tratar as exceptions e devolver uma resposta adequada e consistente (padronizada) para o consumidor da API.
Você vai aprender a usar a anotação @ResponseStatus, tratar exceções em nível do controlador com @ExceptionHandler, usar a exceção padrão ResponseStatusException e tratar exceções globalmente com @ExceptionHandler, @ControllerAdvice e ResponseEntityExceptionHandler.
Vamos tratar erros de validação e atributos inexistentes, capturar a exception NoHandlerFoundException e várias outras.
Ainda, vamos discutir, implementar e estender a modelagem de erros seguindo a RFC 7807 (Problem Details for HTTP APIs).
Ninguém tem dúvidas que testes de software são muito importantes, mas ainda mais se esses testes forem automatizados. Por isso, no treinamento você vai aprender a implementar testes de integração automatizados para a API.
Para implementar os testes de integração, vamos usar Spring Boot Test, REST Assured, JUnit, AssertJ e Maven Failsafe Plugin.
Vamos também implementar a limpeza e população de dados de testes para cada teste (é importante que o banco esteja em um estado consistente para não influenciar o resultado).
Muitos desenvolvedores de APIs não se preocupam ou até desconhecem algumas boas práticas de mercado, por isso um dos objetivos deste treinamento é discutir e disseminar esse tipo de conhecimento entre os alunos.
Você vai aprender as 5 leis fundamentais para trabalhar com data/hora em APIs, como por exemplo, uso e tratamento de timezone na requisição, resposta e armazenamento de datas e o padrão ISO 8601 para troca de dados.
Vamos ver também como fazer customizações de configurações do Jackson usando classes de mixin, para deixar o código das entidades (model) mais limpo.
Vai aprender também as boas práticas para nomeação de URIs de recursos, escolha e configuração de estratégia de nomes de propriedades, diferença e quando usar recursos de granulação fina ou recursos de granulação grossa e como modelar conceitos abstratos e ações não-CRUD na sua API.
Vamos estudar também sobre como modelar fluxos de transições de estados de recursos, implementar Sub-collection Resources, modelar e implementar endpoints que executam ações em massa.
Discutiremos sobre as diferenças entre usar as entidades como modelo de representação dos recursos ou DTOs, para desacoplar mais os controllers, além de implementar das duas formas. Usaremos o ModelMapper para fazer Object Mapping e converter DTOs em entidades e vice-versa.
Analisaremos sobre quando usar ID sequencial ou UUID para identificar recursos, além de implementar também das duas formas, de acordo com a necessidade. Veremos sobre a granularidade do payload, quando usamos respostas massivas (chunkiness) ou mais conversacional (chattiness).
Vamos implementar e organizar as nossas classes usando alguns conceitos e padrões do DDD (Domain-Driven Design), além de discutir sobre as vantagens e desvantagens de criar exceptions de negócio de granularidade fina ou grossa.
No mundo real, surgem várias necessidades que às vezes só estudando por conta própria nem vai passar por sua cabeça, como por exemplo projeções e pesquisas complexas.
Como a ideia do treinamento é preparar os alunos para o mundo real, você vai aprender como implementar projeções do modelo de representação de nossos recursos usando DTO e @JsonView.
Além disso, vamos estudar sobre como limitar as propriedades retornadas usando property filter do Jackson e também usando a biblioteca Squiggly.
Vamos modelar pesquisas complexas com filtros dinâmicos, paginação e ordenação e criar um endpoint que pode ser usado para consumidores que precisam de dados agregados para plotar gráficos ou exibir relatórios.
Implementaremos também um serializador customizado do Jackson para customizar propriedades de paginação na representação.
O foco do treinamento é desenvolvimento de REST APIs com Spring, mas como será que podemos modelar um recurso para disponibilizar um relatório em PDF?
Por isso mesmo, nós vamos desenvolver um relatório JasperReports com Jaspersoft Studio e disponibilizar para download em PDF em um serviço, tudo seguindo as boas práticas.
Muitas vezes, precisamos implementar upload de imagens e documentos para a API. Por exemplo, o upload da foto de um produto ou foto do usuário é algo bem comum.
No treinamento, você vai aprender a modelar recursos para isso também, e ainda vai aprender a armazenar o arquivo no próprio servidor ou ainda no storage da Amazon S3 (ideal para aplicações cloud-native). Além de implementar, vamos discutir quando é melhor usar cada uma.
E claro, se você vai aprender a fazer upload de arquivos, vai também aprender a fazer o download deles, com o cuidado de não degradar a performance da API e também seguindo as boas práticas para as implementações serem independentes e intercambiáveis.
Algo muito comum que quase todos os sistemas precisam é o envio de e-mails transacionais, como por exemplo, e-mails para avisar que um pedido foi confirmado, que a entrega está a caminho, etc.
Nós vamos desenvolver isso e você ainda vai aprender a montar templates de e-mails com Apache FreeMarker, para dados dinâmicos.
Ainda, vamos implementar componentes alternativos para envio de e-mails fake e sandbox, ideal para ambientes de desenvolvimento e staging, para evitar disparo de mensagens de teste para e-mails reais.
Um assunto pouco dominado por vários programadores e que ficará na ponta da sua língua (e dos seus dedos, porque vamos implementar isso) é caching de HTTP.
Por que fazer cache? Como funciona o cache de HTTP? Quando não fazer cache? Quais são as precauções que devemos ter? Tudo isso será discutido no treinamento.
Você vai conhecer e implementar HTTP Caching com Cache-Control, entender o que são ETags (Entity Tags), implementar requisições condicionais com Deep ETags e Shallow ETags e entender como funciona a expiração e invalidação de cache.
APIs bem documentadas simplificam a vida dos consumidores, por isso você vai aprender como fazer isso no treinamento usando a especificação OpenAPI (antigamente conhecida como Swagger).
E para automatizar a geração do arquivo de definição baseado na especificação, usaremos a biblioteca SpringFox, que consegue escanear o nosso código e fazer isso "automagicamente".
Usaremos também o Swagger UI dentro do nosso projeto, para disponibilizar a documentação em uma página bonitinha, de fácil navegação pelos consumidores.
Mas nem tudo são flores. Documentar uma API parece simples, ainda mais quando se usa OpenAPI/Swagger e SpringFox, mas não se engane. Em projetos reais, vários problemas aparecem e a documentação começa a ficar inconsistente.
Mas precisamos garantir que a documentação esteja refletindo exatamente o funcionamento da API, ou seja, que esteja consistente. Por isso você vai aprender vários hacks e configurações para ajustar a documentação e deixá-la limpa e correta.
Discoverability é a capacidade que a API dá aos consumidores de "navegar" em seus recursos sem conhecer previamente as suas URIs, e HATEOAS é um componente do REST que torna isso possível através da inclusão de hypermedia nas respostas.
Uma API que usa HATEOAS é classificada no nível máximo do modelo de maturidade de Richardson, o que também chamamos de "A glória do REST".
Vamos estudar as formas de adicionar hypermedia nas representações dos recursos, usar o Spring HATEOAS e a especificação HAL (Hypertext Application Language) para deixar a API "descobrível" e atrativa aos consumidores.
Estudaremos como criar novos links que referenciam os métodos dos controllers, incluindo links com templates e como implementar Representation Model Assemblers, para instanciar classes de modelo de representação de recursos que suportam HATEOAS.
Vamos ter muita implementação própria para deixar as coisas consistentes, mas no final, vai valer à pena. A API ficará linda! 😍
O foco do treinamento é desenvolver REST APIs, mas todo programador precisa saber como consumir sua própria API também, para se colocar no lugar do consumidor e fazer alguns testes.
Além disso, pode ser que você precise consumir APIs de terceiros, então é sempre bom saber como fazer isso.
Você vai aprender a consumir a API usando a linguagem Java e JavaScript.
E vai também entender a Política de Mesma Origem (Same Origin Policy), que os navegadores implementam, como funciona o CORS (incluindo os cabeçalhos), como habilitar CORS na API por método, controlador ou globalmente.
Uma coisa muito importante em qualquer API é a segurança, por isso nós vamos aprofundar bastante nesse assunto.
Para começar, vamos implementar uma autenticação básica HTTP usando Spring Security. Esse tipo de autenticação é útil em alguns casos, por isso não poderia faltar.
Mas em cenários mais complexos, precisamos de uma solução melhor para autorizar clientes a usarem a API, e por isso você vai aprender sobre OAuth2.
Vamos implementar o Resource Server e Authorization Server em projetos separados e também no mesmo projeto.
Ou seja, você aprenderá a implementar para pequenos projetos, onde geralmente eles ficam juntos e também para grandes projetos, onde geralmente eles ficam separados.
Você vai aprender a implementar e usar os seguintes fluxos de autorização do OAuth2: Resource Owner Password Credentials Flow, Client Credentials Flow, Implicit Flow e Authorization Code Flow.
Você vai aprender sobre a diferença entre access token e refresh token e como gerar um novo access token através de um refresh token, além de discutirmos sobre o cuidado que você deve ter com cada tipo de token.
E além disso, vai também aprender a implementar PKCE (Proof Key for Code Exchange), que é uma extensão para Authorization Code Flow recomendada para clientes públicos, como Single-Page Applications e aplicações nativas (desktop ou mobile).
O Authorization Server será implementado com Spring Security OAuth2, também conhecida como "stack antiga". Atualmente, é a única solução que temos no ecossistema para fazer isso.
O Resource Server será implementado usando a nova stack do Spring Security para OAuth2.
Vamos estudar sobre a diferença entre Opaque Tokens e Transparent Tokens, e vamos implementar das duas formas.
Com Opaque Tokens, temos que armazenar esses tokens em algum lugar, por isso vamos configurar o Redis, um banco NoSQL do tipo chave-valor, e configurar a aplicação Spring para usá-lo. Fica bem melhor que guardar os tokens na memória da aplicação.
Vamos configurar o Authorization Server para carregar o cadastro de clients OAuth (aplicações consumidoras) do banco de dados, para evitar que isso fique hard-coded.
E ainda, vamos implementar Transparent Tokens com JWT (JSON Web Tokens).
Aprenderemos o que é e como funciona o JWT e como assinar os tokens com algoritmo simétrico (HMAC SHA-256) e assimétrico (RSA SHA-256) e qual é a diferença entre eles.
Vamos também customizar o código de login, para validar o usuário e senha no banco de dados da aplicação e adicionar claims públicas no payload do JWT.
A segurança da aplicação será planejada para ter as entidades de usuário, grupo e permissão, por isso será bem granular.
Para garantir que os endpoints só possam ser acessados pelos usuários autorizados, vamos implementar a segurança usando Method Security, as anotações @PreAuthorize e @PostAuthorize e Spring Expression Language (SpEL).
Usaremos as authorities e roles para restringir os acessos dos usuários, além de conhecer e usar também os escopos (scopes) do OAuth2.
Criaremos também meta-anotações de segurança, para simplificar o código dos controllers e nos beneficiar de reaproveitamento de código.
Faremos ainda um controle de segurança contextual, ainda mais granular, como por exemplo quando um usuário só pode acessar um registro que é seu, ou seja, mesmo que tenha acesso ao endpoint, não é permitido que ele acesse o registro de um outro usuário.
E por fim, vamos implementar a inclusão de links (hypermedia) de acordo com as permissões do usuário (evitando a inclusão de links que não são acessíveis por falta de permissão).
A aplicação que vamos desenvolver no treinamento será cloud-native, ou seja, planejaremos desde o início pensando que ela será implantada na nuvem.
E isso faz uma grande diferença, porque desenvolver para a nuvem tem algumas peculiaridades. Temos que tomar alguns cuidados. Mas claro, a mesma aplicação poderá ser implantada fora da nuvem também, em um servidor de intranet.
Se a nossa API é cloud-native, nós faremos o deploy dela na nuvem.
Usaremos Spring Profiles para alternar algumas configurações de desenvolvimento e produção sem precisar recompilar e reempacotar o projeto.
Não manteremos configurações sensíveis de produção (como por exemplo o host, usuário e senha do banco de dados) dentro do projeto. Essas configurações serão adicionadas em variáveis de ambiente, seguindo a recomendação do The Twelve-Factor App.
O curso foi lançado usando a plataforma da Pivotal Web Services (PWS) para o deploy da aplicação, mas infelizmente, após a compra da Pivotal pela VMware, este serviço será descontinuado em breve.
Por isso as aulas de deployment em produção (último módulo do curso) estão sendo regravadas com o uso de um novo provedor cloud e serão disponibilizadas em breve.
Ninguém duvida que fazer logging das mensagens importantes e erros é essencial para qualquer aplicação, mas para aplicações cloud-native, onde implantamos em containers descartáveis, temos que tomar cuidado.
Não podemos fazer logging para um appender de filesystem, ou seja, armazenar os logs na própria máquina, porque podemos descartar e instanciar uma nova a qualquer momento e os logs poderiam ser perdidos.
Por isso, vamos usar um serviço de gerenciamento de logs na nuvem, para onde vamos configurar a transmissão das mensagens de maneira assíncrona.
O legal é que essas ferramentas agregam os logs de todas as instâncias (containers) e fica muito mais fácil e seguro analisar os logs.
Uma hora ficará tão difícil manter a mesma API, que você vai sentir necessidade de criar ou alterar funcionalidades que quebram a compatibilidade com os consumidores.
O problema é que você já pode ter vários consumidores usando a API e pode ficar difícil ou até impossível migrar todos eles em uma pequena janela de tempo.
Nesse caso, você precisará implementar uma nova versão, e aí surgem várias dúvidas.
No treinamento, nós vamos estudar melhor sobre quando versionar uma API, quais as estratégias para separar o código-fonte da API antiga e da API nova e vamos implementar a seleção de versão por Media Types e por URIs.
Você vai aprender como evoluir a sua API sem quebrar os clientes (que é o ideal, já que criar uma nova versão é uma dor de cabeça que você deve evitar).
Vamos estudar também quando e como implementar depreciação e remoção de suporte de uma API, para que você faça uma transição de versões de forma mais suave.
Seu acesso ao curso online será vitalício, ou seja, nunca vai expirar.
Estude a qualquer hora e assista as videoaulas quantas vezes precisar.
Ao concluir o curso, você vai receber um certificado de conclusão com validação digital. O certificado possui o selo da ABED (Associação Brasileira de Educação a Distância).
Você vai ter acesso ao suporte de nossos especialistas por 9 meses para o curso Especialista Spring REST e Java e Orientação a Objetos. Para os demais cursos bônus, o Suporte VIP é de 2 meses.
Esse curso vai gerar uma transformação tão grande na sua vida e na sua carreira, que talvez só vendo o que aconteceu com outras pessoas para você acreditar.
Dá uma olhada no que aconteceu com os alunos Ronaldo e o Leonardo:
E o mais interessante é que esses não são casos isolados. Se você procurar no YouTube, vai encontrar vários vídeos de nossos alunos com histórias emocionantes, como essas aí.
Se você está enferrujado ou não sabe nada sobre Java e Orientação a Objetos, esse curso vai te ajudar a dominar isso e vai te preparar para fazer o ESR com maestria.
Liberação das aulas imediata após a compra.
Mais um material para você estudar ou reforçar seu conhecimento em Java e Orientação a Objetos. Um livro digital com quase 300 páginas.
Envio imediato após a compra.
Você vai ganhar o Suporte VIP de nossos especialistas por 9 meses para o Curso Especialista Spring REST. Vai ser possível tirar todas as suas dúvidas durante os seus estudos.
O curso online Ignição React vai te levar do zero ao nível intermediário em desenvolvimento web com React.js. O tempo de Suporte VIP para este curso é de 2 meses.
Liberação das aulas imediata após a compra.
Você vai aprender a criar páginas responsivas com HTML5 e CSS3 usando a metodologia BEM. Se você ainda não sabe ou não é muito bom nisso, esse curso vai te preparar para fazer o curso de Ignição React. O tempo de Suporte VIP para este curso é de 2 meses.
Aprenda a criar os seus próprios códigos JavaScript do jeito certo. Chega de copiar e colar!
O tempo de Suporte VIP para este curso é de 2 meses.
Aprenda a programar em uma linguagem para desenvolvimento JavaScript fortemente tipada. Você vai aprender os fundamentos, uso de orientação a objetos e um pouco de ES6. O tempo de Suporte VIP para este curso é de 2 meses.
Vários de nossos alunos já relataram o prestígio que tiveram durante entrevistas de emprego por parte das empresas, quando souberam que são alunos da AlgaWorks.
E já recebemos mensagens de líderes técnicos indicando que dá preferência para candidatos que estudam com a gente também.
Sem dúvidas, ter um certificado da AlgaWorks não é um documento qualquer. É um indicador que você investe na sua carreira com treinamentos que realmente capacitam os alunos para resolver problemas reais.
Quando você concluir 100% das aulas do treinamento, vai receber um certificado do Especialista Spring REST em seu nome, com validação digital de autenticidade.
A carga horária do certificado é de 240 horas.
TUDO ISSO VALE R$6.697,00
Mas mesmo valendo isso, sabemos que esse valor seria inviável para muitas pessoas. Por isso...
...o investimento para o treinamento Especialista Spring REST é de apenas R$2.080.
Mas esquece esse valor! Como você está no grupo VIP da Black Friday no WhatsApp...
VOCÊ INVESTIRÁ APENAS R$2.080 R$1.580
Se você adquirir o treinamento e mudar de ideia em até 30 dias após a data da compra, é só enviar um e-mail para contato@algaworks.com e pedir o seu dinheiro de volta!
Nós vamos estornar seu pagamento integralmente, sem cobrança de taxas, multas... absolutamente nada! Não vamos fazer nenhuma pergunta antes de devolver seu dinheiro, e o mais importante, não ficaremos magoados com você.
1. Introdução
1.1. Introdução ao treinamento
1.2. Como usar o suporte da AlgaWorks
1.3. Por que desenvolver REST APIs?
1.4. Conhecendo o modelo de domínio do projeto do curso
1.5. Preparando o ambiente de desenvolvimento: JDK e STS for Eclipse
2. Spring e Injeção de Dependências
2.1. Por que aprender e usar Spring?
2.2. Conhecendo o ecossistema Spring
2.3. Spring vs Jakarta EE (Java EE)
2.4. Conhecendo o Spring Boot
2.5. Criando um projeto Spring Boot com Spring Initializr
2.6. Conhecendo o Maven e o pom.xml de um projeto Spring Boot
2.7. Criando um controller com Spring MVC
2.8. Restart mais rápido da aplicação com DevTools
2.9. O que é injeção de dependências?
2.10. Conhecendo o IoC Container do Spring
2.11. Definindo beans com @Component
2.12. Injetando dependências (beans Spring)
2.13. Usando @Configuration e @Bean para definir beans
2.14. Conhecendo os pontos de injeção e a anotação @Autowired
2.15. Dependência opcional com @Autowired
2.16. Ambiguidade de beans e injeção de lista de beans
2.17. Desambiguação de beans com @Primary
2.18. Desambiguação de beans com @Qualifier
2.19. Desambiguação de beans com anotação customizada
2.20. Mudando o comportamento da aplicação com Spring Profiles
2.21. Criando métodos de callback do ciclo de vida dos beans
2.22. Publicando e consumindo eventos customizados
2.23. Configurando projetos Spring Boot com o application.properties
2.24. Substituindo propriedades via linha de comando e variáveis de ambiente
2.25. Criando e acessando propriedades customizadas com @Value
2.26. Acessando propriedades com @ConfigurationProperties
2.27. Alterando a configuração do projeto dependendo do ambiente (com Spring Profiles)
2.28. Ativando o Spring Profile por linha de comando e variável de ambiente
3. Introdução ao JPA e Hibernate
3.1. Instalando o MySQL Server e MySQL Workbench
3.2. O que é JPA e Hibernate?
3.3. Adicionando JPA e configurando o Data Source
3.4. Mapeando entidades com JPA
3.5. Criando as tabelas do banco a partir das entidades
3.6. Mapeando o id da entidade para autoincremento
3.7. Importando dados de teste com import.sql
3.8. Consultando objetos do banco de dados
3.9. Adicionando um objeto no banco de dados
3.10. Buscando um objeto pelo id no banco de dados
3.11. Atualizando um objeto no banco de dados
3.12. Excluindo um objeto do banco de dados
3.13. Conhecendo o padrão Aggregate do DDD
3.14. Conhecendo e implementando o padrão Repository
3.15. Conhecendo e usando o Lombok
3.16. Desafio: Lombok e repositório de restaurantes
3.17. Mapeando relacionamento com @ManyToOne
3.18. A anotação @JoinColumn
3.19. Propriedade nullable de @Column e @JoinColumn
3.20. Desafio: mapeando entidades
4. REST com Spring
4.1. O que é REST?
4.2. Conhecendo as constraints do REST
4.3. Diferença entre REST e RESTful
4.4. Desenvolvedores de REST APIs puristas e pragmáticos
4.5. Conhecendo o protocolo HTTP
4.6. Usando o protocolo HTTP
4.7. Instalando e testando o Postman
4.8. Entendendo o que são Recursos REST
4.9. Identificando recursos REST
4.10. Modelando e requisitando um Collection Resource com GET
4.11. Desafio: collection resource de estados
4.12. Representações de recursos e content negotiation
4.13. Implementando content negotiation para retornar JSON ou XML
4.14. Consultando Singleton Resource com GET e @PathVariable
4.15. Customizando as representações XML e JSON com @JsonIgnore, @JsonProperty e @JsonRootName
4.16. Customizando a representação em XML com Wrapper e anotações do Jackson
4.17. Conhecendo os métodos HTTP
4.18. Conhecendo os códigos de status HTTP
4.19. Definindo o status da resposta HTTP com @ResponseStatus
4.20. Manipulando a resposta HTTP com ResponseEntity
4.21. Corrigindo o Status HTTP para resource inexistente
4.22. Status HTTP para collection resource vazia: qual usar?
4.23. Modelando e implementando a inclusão de recursos com POST
4.24. Negociando o media type do payload do POST com Content-Type
4.25. Modelando e implementando a atualização de recursos com PUT
4.26. Modelando e implementando a exclusão de recursos com DELETE
4.27. Implementando a camada de domain services (e a importância da linguagem ubíqua)
4.28. Refatorando a exclusão de cozinhas para usar domain services
4.29. Desafio: modelando e implementando a consulta de recursos de restaurantes
4.30. Modelando e implementando a inclusão de recursos de restaurantes
4.31. Desafio: Modelando e implementando a atualização de recursos de restaurantes
4.32. Desafio: implementando serviços REST de cidades e estados
4.33. Analisando solução para atualização parcial de recursos com PATCH
4.34. Finalizando a atualização parcial com a API de Reflections do Spring
4.35. Introdução ao Modelo de Maturidade de Richardson (RMM)
4.36. Conhecendo o nível 0 do RMM
4.37. Conhecendo o nível 1 do RMM
4.38. Conhecendo o nível 2 do RMM
4.39. Conhecendo o nível 3 do RMM
5. Super poderes do Spring Data JPA
5.1. Implementando consultas JPQL em repositórios
5.2. Conhecendo o projeto Spring Data JPA (SDJ)
5.3. Criando um repositório com Spring Data JPA (SDJ)
5.4. Refatorando o código do projeto para usar o repositório do SDJ
5.5. Desafio: refatorando todos os repositórios para usar SDJ
5.6. Criando consultas com query methods
5.7. Usando as keywords para definir critérios de query methods
5.8. Conhecendo os prefixos de query methods
5.9. Usando queries JPQL customizadas com @Query
5.10. Externalizando consultas JPQL para um arquivo XML
5.11. Implementando um repositório SDJ customizado
5.12. Implementando uma consulta dinâmica com JPQL
5.13. Implementando uma consulta simples com Criteria API
5.14. Adicionando restrições na cláusula where com Criteria API
5.15. Tornando a consulta com Criteria API com filtros dinâmicos
5.16. Conhecendo o uso do padrão Specifications (DDD) com SDJ
5.17. Implementando Specifications com SDJ
5.18. Criando uma fábrica de Specifications
5.19. Injetando o próprio repositório na implementação customizada e a anotação @Lazy
5.20. Estendendo o JpaRepository para customizar o repositório base
6. Explorando mais do JPA e Hibernate
6.1. Mapeando relacionamento bidirecional com @OneToMany
6.2. Mapeando relacionamento muitos-para-muitos com @ManyToMany
6.3. Analisando o impacto do relacionamento muitos-para-muitos na REST API
6.4. Mapeando classes incorporáveis com @Embedded e @Embeddable
6.5. Testando e analisando o impacto da incorporação de classe na REST API
6.6. Mapeando propriedades com @CreationTimestamp e @UpdateTimestamp
6.7. Desafio: mapeando relacionamento muitos-para-um
6.8. Desafio: mapeando relacionamento um-para-muitos
6.9. Desafio: mapeando relacionamentos muitos-para-muitos
6.10. Entendendo o Eager Loading
6.11. Entendendo o Lazy Loading
6.12. Alterando a estratégia de fetching para Lazy Loading
6.13. Alterando a estratégia de fetching para Eager Loading
6.14. Resolvendo o Problema do N+1 com fetch join na JPQL
7. Pool de conexões e Flyway
7.1. Entendendo o funcionamento de um pool de conexões
7.2. Conhecendo o Hikari: a solução padrão de pool de conexões no Spring Boot
7.3. Configurando o pool de conexões do Hikari
7.4. Schema generation em produção não é uma boa prática
7.5. Flyway: ferramenta de versionamento de schemas de banco de dados
7.6. Adicionando o Flyway no projeto e criando a primeira migração
7.7. Evoluindo o banco de dados com novas migrações
7.8. Criando migrações complexas com remanejamento de dados
7.9. Criando migração a partir de DDL gerado por schema generation
7.10. Adicionando dados de testes com callback do Flyway
7.11. Reparando migrações com erros
7.12. Desafio: Criando migrações e mapeando as entidades Pedido e ItemPedido
8. Tratamento e modelagem de erros da API
8.1. Introdução ao tratamento e modelagem de erros
8.2. Lançando exceções customizadas anotadas com @ResponseStatus
8.3. Lançando exceções do tipo ResponseStatusException
8.4. Estendendo ResponseStatusException
8.5. Simplificando o código com o uso de @ResponseStatus em exceptions
8.6. Desafio: refatorando os serviços REST
8.7. Analisando os impactos da refatoração
8.8. Criando a exception NegocioException
8.9. Desafio: usando a exception NegocioException
8.10. Afinando a granularidade e definindo a hierarquia das exceptions de negócios
8.11. Desafio: lançando exceptions de granularidade fina
8.12. Tratando exceções em nível de controlador com @ExceptionHandler
8.13. Tratando exceções globais com @ExceptionHandler e @ControllerAdvice
8.14. Desafio: implementando exception handler
8.15. Criando um exception handler global com ResponseEntityExceptionHandler
8.16. Customizando o corpo da resposta padrão de ResponseEntityExceptionHandler
8.17. Conhecendo a RFC 7807 (Problem Details for HTTP APIs)
8.18. Padronizando o formato de problemas no corpo de respostas com a RFC 7807
8.19. Desafio: usando o formato de problemas no corpo de respostas
8.20. Customizando exception handlers de ResponseEntityExceptionHandler
8.21. Tratando a exception InvalidFormatException na desserialização
8.22. Habilitando erros na desserialização de propriedades inexistentes ou ignoradas
8.23. Desafio - tratando PropertyBindingException na desserialização
8.24. Lançando exception de desserialização na atualização parcial (PATCH)
8.25. Desafio: tratando exception de parâmetro de URL inválido
8.26. Desafio: tratando a exceção NoHandlerFoundException
8.27. Desafio: tratando outras exceções não capturadas
8.28. Estendendo o formato do problema para adicionar novas propriedades
8.29. Desafio: estendendo o formato do problema
9. Validações com Bean Validation
9.1. Validação do modelo com Bean Validation
9.2. Adicionando constraints e validando no controller com @Valid
9.3. Desafio: tratando exception de violação de constraints de validação
9.4. Estendendo o Problem Details para adicionar as propriedades com constraints violadas
9.5. Conhecendo e adicionando mais constraints de validação no modelo
9.6. Validando as associações de uma entidade em cascata
9.7. Agrupando e restringindo constraints que devem ser usadas na validação
9.8. Convertendo grupos de constraints para validação em cascata com @ConvertGroup
9.9. Desafio: adicionando constraints de validação no modelo
9.10. Customizando mensagens de validação na anotação da constraint
9.11. Customizando e resolvendo mensagens de validação globais em Resource Bundle
9.12. Desafio: customizando mensagens de validação
9.13. Resolvendo mensagens de validação com Resource Bundle do Bean Validation
9.14. Usando o Resource Bundle do Spring como Resource Bundle do Bean Validation
9.15. Criando constraints de validação customizadas usando composição
9.16. Criando constraints de validação customizadas com implementação de ConstraintValidator
9.17. Criando constraints de validação customizadas em nível de classe
9.18. Ajustando Exception Handler para adicionar mensagens de validação em nível de classe
9.19. Executando processo de validação programaticamente
9.20. Desafio: tratando a exception customizada de validações programáticas
10. Testes de integração
10.1. Introdução aos Testes de Integração e Testes de APIs
10.2. Preparando o projeto para testes de integração
10.3. Criando e rodando um teste de integração com Spring Boot, JUnit e AssertJ
10.4. Escrevendo bons nomes de testes
10.5. Desafio: escrevendo testes de integração
10.6. Rodando os testes pelo Maven
10.7. Configurando Maven Failsafe Plugin no projeto
10.8. Implementando Testes de API com REST Assured e validando o código de status HTTP
10.9. Validando o corpo da resposta HTTP
10.10. Criando um método para fazer setup dos testes
10.11. Entendendo o problema da ordem de execução dos testes
10.12. Voltando o estado inicial do banco de dados para cada execução de teste com callback do Flyway
10.13. Configurando um banco de testes e usando @TestPropertySource
10.14. Limpando e populando o banco de dados de teste
10.15. Testando endpoint passando parâmetro de URL
10.16. Desafio: refatorando o código de testes
10.17. Desafio: escrevendo testes de API
11. Boas práticas e técnicas para APIs
11.1. Analisando e definindo melhor o escopo das transações
11.2. Refinando o payload de cadastro com @JsonIgnoreProperties
11.3. Criando classes de mixin para usar as anotações do Jackson
11.4. Desafio: usando @JsonIgnoreProperties e Jackson Mixin
11.5. Antes de estudar sobre data/hora: relembrando as aulas de geografia e entendendo os fusos horários
11.6. Boas práticas para trabalhar com data e hora em REST APIs
11.7. Configurando e refatorando o projeto para usar UTC
11.8. Desafio - refatorando o código para usar OffsetDateTime
11.9. Isolando o Domain Model do Representation Model com o padrão DTO
11.10. Implementando a conversão de entidade para DTO
11.11. Criando DTOs para entrada de dados na API
11.12. Refatorando e criando um assembler de DTO
11.13. Desafio: Refatorando e criando um disassembler do DTO
11.14. Adicionando e usando o ModelMapper
11.15. Entendendo a estratégia padrão do ModelMapper para correspondência de propriedades
11.16. Customizando o mapeamento de propriedades com ModelMapper
11.17. Mapeando para uma instância destino (e não um tipo) com ModelMapper
11.18. Revisando e ajustando as mensagens de validação com o uso de DTOs
11.19. Estratégias de nomes de propriedades - snake case vs lower camel case
11.20. Desafio: usando DTOs como representation model
11.21. Corrigindo bug de tratamento de exception de integridade de dados com flush do JPA
12. Modelagem avançada e implementação da API
12.1. Modelando sub-recursos para relacionamentos
12.2. Granularidade de recursos: Chatty vs Chunky APIs
12.3. Modelando conceitos abstratos de negócio e ações não-CRUD como recursos
12.4. Implementando os endpoints de ativação e inativação de restaurantes
12.5. Desafio: implementando os endpoints de formas de pagamento
12.6. Adicionando endereço no modelo da representação do recurso de restaurante
12.7. Refatorando serviço de cadastro de restaurante para incluir endereço
12.8. Desafio: implementando os endpoints de grupos
12.9. Desafio: implementando os endpoints de usuarios
12.10. Um pouco mais sobre JPA: objeto alterado fora da transação é sincronizado com o banco de dados
12.11. Implementando regra de negócio para evitar usuários com e-mails duplicados
12.12. Implementando os endpoints de associação de formas de pagamento em restaurantes
12.13. Desafio: implementando os endpoints de produtos
12.14. Desafio: Implementando os endpoints de abertura e fechamento de restaurantes
12.15. Desafio: implementando os endpoints de associação de grupos com permissões
12.16. Desafio: implementando os endpoints de associação de usuários com grupos
12.17. Desafio: implementando endpoints de associação de usuários responsáveis com restaurantes
12.18. Implementando ativação e inativação em massa de restaurantes
12.19. Desafio: Implementando os endpoints de consulta de pedidos
12.20. Otimizando a query de pedidos e retornando model resumido na listagem
12.21. Desafio: Implementando o endpoint de emissão de pedidos
12.22. Implementando endpoint de transição de status de pedidos
12.23. Desafio: implementando endpoints de transição de status de pedidos
12.24. Refatorando o código de regras para transição de status de pedidos
12.25. Usando IDs vs UUIDs nas URIs de recursos
13. Modelagem de projeções, pesquisas e relatórios
13.1. Fazendo projeção de recursos com @JsonView do Jackson
13.2. Limitando os campos retornados pela API com @JsonFilter do Jackson
13.3. Limitando os campos retornados pela API com Squiggly
13.4. Implementando pesquisas simples na API
13.5. Modelando pesquisas complexas na API
13.6. Implementando pesquisas complexas na API
13.7. Tratando BindException ao enviar parâmetros de URL inválidos
13.8. Implementando paginação e ordenação em recursos de coleção da API
13.9. Desafio: implementando paginação e ordenação de pedidos
13.10. Implementando JsonSerializer para customizar representação de paginação
13.11. Implementando um conversor de propriedades de ordenação
13.12. Modelando endpoints de consultas com dados agregados (ideal para gráficos e dashboards)
13.13. Discutindo sobre onde implementar as consultas com dados agregados
13.14. Implementando consulta com dados agregados de vendas diárias
13.15. Desafio: adicionando os filtros na consulta de vendas diárias
13.16. Tratando time offset na agregação de vendas diárias por data
13.17. Conhecendo o JasperSoft Studio
13.18. Criando um layout do relatório JasperReports de vendas diárias
13.19. Estruturando endpoint e serviço de emissão de relatório em PDF
13.20. Preenchendo um relatório JasperReports com JavaBeans e gerando bytes do PDF
14. Upload e download de arquivos
14.1. Conhecendo soluções para upload de arquivos em REST APIs
14.2. Implementando upload de arquivo com multipart/form-data
14.3. Validando o tamanho máximo do arquivo
14.4. Desafio: Validando o content type do arquivo
14.5. Mapeando entidade FotoProduto e relacionamento um-para-um
14.6. Implementando serviço de cadastro de foto de produto
14.7. Excluindo e substituindo cadastro de foto de produto
14.8. Implementando o serviço de armazenagem de fotos no disco local
14.9. Integrando o serviço de catálogo de fotos com o serviço de armazenagem
14.10. Implementando a remoção e substituição de arquivos de fotos no serviço de armazenagem
14.11. Desafio: Implementando recuperação de foto no serviço de armazenagem
14.12. Desafio: Implementando endpoint de consulta de foto de produto
14.13. Servindo arquivos de fotos pela API
14.14. Checando media type ao servir arquivos de fotos
14.13. Servindo arquivos de fotos pela API
14.14. Checando media type ao servir arquivos de fotos
14.15. Desafio: implementando endpoint de exclusão de foto de produto
14.16. Corrigindo exception handler de media type não aceita
14.17. Amazon S3: conhecendo o serviço de storage da AWS
14.18. Criando usuário com permissões para adicionar objetos na Amazon S3
14.19. Criando chaves de acesso para a API da AWS
14.20. Criando bean de propriedades de configuração dos serviços de storage
14.21. Adicionando o SDK Java da Amazon S3 no projeto e criando a classe da implementação do serviço de storage
14.22. Definindo bean do client da Amazon S3 e configurando credenciais
14.23. Implementando a inclusão de objetos no bucket da Amazon S3
14.24. Desafio: Implementando a exclusão de objetos do bucket da Amazon S3
14.25. Implementando a recuperação de foto no serviço de storage do S3
14.26. Selecionando a implementação do serviço de storage de fotos
15. E-mails transacionais e Domain Events
15.1. Conhecendo soluções para envio de e-mails transacionais
15.2. Configurando o projeto para envio de e-mails usando servidor SMTP
15.3. Implementando o serviço de infraestrutura de envio de e-mails com Spring
15.4. Usando o serviço de envio de e-mails na confirmação de pedidos
15.5. Processando template do corpo de e-mails com Apache FreeMarker
15.6. Melhorando o texto do e-mail com FTL (FreeMarker Template Language)
15.7. Formatando valores monetários com FTL
15.8. Desafio: implementando serviço de envio de e-mail fake
15.9. Desafio: Implementando serviço de envio de e-mail sandbox
15.10. Conhecendo o padrão Domain Events do DDD
15.11. Publicando Domain Events a partir do Aggregate Root
15.12. Observando e reagindo a Domain Events
15.13. Reagindo a Domain Events em fases específicas da transação
15.14. Desafio: enviando e-mails no cancelamento de pedidos
16. CORS e consumo da API com JavaScript e Java
16.1. Implementando uma chamada na REST API com JavaScript
16.2. Testando a requisição na API com JavaScript e entendendo a Same Origin Policy
16.3. Entendendo o funcionamento básico de CORS e habilitando na API
16.4. Habilitando CORS em controladores e métodos com @CrossOrigin
16.5. Entendendo o funcionamento de preflight do CORS
16.6. Habilitando CORS globalmente no projeto da API
16.7. Desafio: implementando uma requisição GET com JavaScript
16.8. Implementando um formulário de cadastro e fazendo requisição POST com JavaScript
16.9. Desafio: implementando uma requisição DELETE com JavaScript
16.10. Implementando um client da REST API com Java e Spring
16.11. Tratando respostas com código de erro no client Java
16.12. Desafio: Implementando uma requisição POST no client Java
17. Cache de HTTP
17.1. Introdução ao Cache de HTTP
17.2. Habilitando o cache com o cabeçalho Cache-Control e a diretiva max-age
17.3. Desafio: adicionando o cabeçalho Cache-Control na resposta
17.4. Entendendo a validação de representações em cache com ETags
17.5. Implementando requisições condicionais com Shallow ETags
17.6. Adicionando outras diretivas de Cache-Control na resposta HTTP
17.7. Usando a diretiva no-cache no cabeçalho Cache-Control da requisição
17.8. Entendendo e preparando a implementação de Deep ETags
17.9. Implementando requisições condicionais com Deep ETags
17.10. Desafio: implementando requisições condicionais com Deep ETags
18. Documentação da API com OpenAPI, Swagger UI e SpringFox
18.1. Introdução à documentação de REST APIs
18.2. Conhecendo a OpenAPI (antes conhecida como Swagger)
18.3. Gerando a definição OpenAPI em JSON com SpringFox
18.4. Gerando a documentação da API em HTML com Swagger UI e SpringFox
18.5. Selecionando os endpoints da API para gerar a documentação
18.6. Descrevendo informações da API na documentação
18.7. Descrevendo tags na documentação e associando com controllers
18.8. Descrevendo as operações de endpoints na documentação
18.9. Descrevendo parâmetros de entrada na documentação
18.10. Descrevendo modelos de representações e suas propriedades
18.11. Descrevendo restrições de validação de propriedades do modelo
18.12. Descrevendo códigos de status de respostas de forma global
18.13. Desafio: descrevendo códigos de status de respostas de forma global
18.14. Descrevendo o modelo de representação de problema
18.15. Referenciando modelo de representação de problema com códigos de status de erro
18.16. Descrevendo códigos de status de respostas em endpoints específicos
18.17. Desacoplando anotações do Swagger dos controladores
18.18. Desafio: descrevendo documentação de endpoints de grupos
18.19. Descrevendo media type da resposta nos endpoints
18.20. Corrigindo documentação com substituição de Pageable
18.21. Corrigindo documentação com substituição Page
18.22. Desafio: descrevendo documentação de endpoints de cozinhas
18.23. Ignorando tipos de parâmetros de operações na documentação
18.24. Desafio: descrevendo documentação de endpoints de formas de pagamento
18.25. Descrevendo parâmetros globais em operações
18.26. Descrevendo parâmetros implícitos em operações
18.27. Desafio: descrevendo documentação de endpoints de pedidos
18.28. Descrevendo parâmetros de projeções em endpoints de consultas
18.29. Desafio: descrevendo documentação de endpoints de restaurantes
18.30. Desafio: descrevendo documentação de endpoints de estados
18.31. Desafio: descrevendo documentação de endpoints de fluxo de pedidos
18.32. Desafio: descrevendo documentação de endpoints de associação de restaurantes com formas de pagamento
18.33. Desafio: descrevendo documentação de endpoints de associação de restaurantes com usuários
18.34. Desafio: descrevendo documentação de endpoints de produtos
18.35. Desafio: descrevendo documentação de endpoints de fotos de produtos
18.36. Corrigindo documentação no Swagger UI para upload de arquivos
18.37. Desafio: descrevendo documentação de endpoints de associação de permissões com grupos
18.38. Desafio: descrevendo documentação de endpoints de usuários
18.39. Desafio: descrevendo documentação de endpoints de associação de grupos com usuários
18.40. Desafio: descrevendo documentação de endpoint de estatísticas
19. HATEOAS e Discoverability: A Glória do REST
19.1. Introdução à Discoverability e HATEOAS
19.2. Adicionando a URI do recurso criado no header da resposta
19.3. Adicionando o Spring HATEOAS no projeto
19.4. Atualizando o projeto para Spring Boot 2.2 (Spring HATEOAS 1.0)
19.5. Resolvendo conflito de dependências com Spring HATEOAS e SpringFox
19.6. Conhecendo especificações para formatos Hypermedia
19.7. Adicionando hypermedia na representação de recurso único com HAL
19.8. Construindo links dinâmicos com WebMvcLinkBuilder
19.9. Construindo links que apontam para métodos
19.10. Adicionando hypermedia na representação de recursos de coleção
19.11. Montando modelo de representação com RepresentationModelAssembler
19.12. Desafio: adicionando hypermedia nos recursos de usuários
19.13. Corrigindo link de coleção de recurso de responsáveis por restaurante
19.14. Desafio: adicionando hypermedia nos recursos de estados
19.15. Adicionando hypermedia em recursos com paginação
19.16. Desafio: adicionando hypermedia em recursos de pedidos (paginação)
19.17. Corrigindo links de paginação com ordenação
19.18. Adicionando links com template variables
19.19. Desafio: adicionando template variables do filtro de pedidos
19.20. Refatorando construção e inclusão de links em representation model
19.21. Desafio: refatorando construção e inclusão de links
19.22. Adicionando links de transições de status de pedidos
19.23. Adicionando links condicionalmente
19.24. Desafio: adicionando hypermedia nos recursos de restaurantes
19.25. Desafio: adicionando links condicionais no recurso de restaurante
19.26. Desafio: adicionando template variable de projeção de restaurantes
19.27. Desafio: adicionando hypermedia nos recursos de formas de pagamento
19.28. Adicionando links para desassociação de formas de pagamento com restaurante
19.29. Adicionando links com template variable de caminho para associação de formas de pagamento com restaurante
19.30. Desafio: adicionando links de associação de restaurantes com responsáveis
19.31. Desafio: adicionando hypermedia nos recursos de produtos
19.32. Desafio: adicionando links para recurso de foto de produto
19.33. Desafio: adicionando hypermedia nos recursos de grupos
19.34. Desafio: adicionando links de associação de grupos com permissões
19.35. Desafio: adicionando links de associação de usuários com grupos
19.36. Implementando o Root Entry Point da API
19.37. Desafio: implementando endpoint com links de recursos de estatísticas
19.38. Comprimindo as respostas HTTP com Gzip
19.39. Corrigindo as propriedades de links na documentação
19.40. Corrigindo a documentação dos endpoints de cidades
19.41. Corrigindo a paginação na documentação
19.42. Desafio: corrigindo a documentação dos endpoints de estados
19.43. Desafio: corrigindo a documentação dos endpoints de formas de pagamento
19.44. Desafio: corrigindo a documentação dos endpoints de grupos
19.45. Desafio: corrigindo a documentação dos endpoint de pedidos (paginação)
19.46. Desafio: corrigindo a documentação dos endpoints de produtos
19.47. Desafio: corrigindo a documentação dos endpoints de restaurantes e usuários
19.48. Removendo modelo de representação inutilizado da documentação
20. Evoluindo e Versionando a API
20.1. Evoluindo a API com gestão de mudanças
20.2. Evitando quebrar os clientes: nova propriedade no modelo
20.3. Evitando quebrar os clientes: exclusão de propriedade do modelo
20.4. Evitando quebrar os clientes: alteração de tipo de propriedade do modelo
20.5. Evitando quebrar os clientes: alteração na estrutura de dados do modelo
20.6. Evitando quebrar os clientes: alteração de URL de recurso
20.7. O que é e quando versionar uma API?
20.8. As principais técnicas de versionamento de APIs
20.9. As principais abordagens para manter a base de código de APIs versionadas
20.10. Preparando o projeto para versionamento da API por Media Type
20.11. Implementando o versionamento da API por Media Type
20.12. Definindo a versão padrão da API quando o Media Type não é informado
20.13. Implementando o versionamento da API por URI
20.14. Desafio: Refatorando controladores para adicionar /v1 nas URIs
20.15. Desafio: adicionando os recursos de cozinhas na v2 da API
20.16. Gerando documentação das versões da API com SpringFox e Swagger UI
20.17. Desafio: revisando documentação da v2 da API
20.18. Depreciando uma versão da API
20.19. Desligando uma versão da API
21. Logging
21.1. Introdução ao Logback e SLF4J
21.2. Desafio: registrando logs de exceptions não tratadas
21.3. Criando uma conta no Loggly: serviço de gerenciamento de logs na nuvem
21.4. Configurando o appender do Loggly no Logback
21.5. Configurando o Logback para alternar as configurações por Spring Profiles
22. Segurança com Spring Security, OAuth2 e JWT
22.1. Introdução à segurança de APIs
22.2. Autenticação básica do HTTP com Spring Security
22.3. Conhecendo o OAuth2
22.4. Como funcionam os fluxos (grant types) do OAuth2
22.5. Implementando o Authorization Server com o fluxo Password Credentials Flow
22.6. Configurando o Resource Server
22.7. Entendendo e configurando o Refresh Token
22.8. Autorizando acesso apenas para Resource Servers específicos com resourceId
22.9. Conheça o Redis: um banco de dados NoSQL
22.10. Adicionando os tokens no Redis
22.11. Cadastrando e configurando os clientes OAuth2 em um banco SQL
22.12. Tratando melhor as exceptions da camada do Spring Security
22.13. Transparent Tokens: Conhecendo o JSON Web Tokens (JWT)
22.14. Authorization Server: Gerando tokens JWT com algoritmo simétrico (HMAC SHA-256)
22.15. Resource Server: recebendo e verificando a assinatura do token JWT
22.16. Assinando o JWT com um algoritmo assimétrico (RSA SHA-256)
22.17. Buscando a chave pública automaticamente do Authorization Server
22.18. Configurando e testando o Client Credentials Flow
22.19. Configurando e testando o Implicit Flow
22.20. Configurando e testando o Authorization Code Flow
22.21. Juntando o Resource Server com o Authorization Server no mesmo projeto
22.22. Autenticando usuário com dados do banco de dados
22.23. Adicionando Claims públicas no Payload do JWT (nome do usuário)
22.24. Planejando a topologia dos grupos e permissões do sistema
22.25. Method Security: Restringindo acesso com @PreAuthorize e SpEL
22.26. Simplificando o código com meta-anotações de segurança
22.27. Checando acesso dos endpoints de cozinhas
22.28. Carregando e convertendo o payload do JWT no Resource Server
22.29. Controle de acesso ainda mais granular e contextual: endpoints de pedidos
22.30. Escopos do OAuth: entendendo e restringindo o acesso
22.31. Gerando links do HAL dinamicamente de acordo com permissões do usuário
22.32. Capturando AccessDeniedException e ajustando o modelo de representação
23. OAuth2 avançado com JWT e controle de acesso
23.1. Armazenando tokens no Redis: um banco de dados NoSQL
23.2. Configurando o RedisTokenStore
23.3. Entendendo a diferença entre Stateful e Stateless Authentication
23.4. Transparent Tokens: conhecendo o JSON Web Tokens (JWT)
23.5. Gerando JWT com chave simétrica (HMAC SHA-256) no Authorization Server
23.6. Configurando o Resource Server para JWT assinado com chave simétrica
23.7. Entendendo a diferença entre assinatura com chave simétrica e assimétrica
23.8. Gerando um par de chaves com keytool
23.9. Assinando o JWT com RSA SHA-256 (chave assimétrica)
23.10. Desafio: criando bean de propriedades de configuração do KeyStore
23.11. Extraindo a chave pública no formato PEM
23.12. Configurando a validação de JWT no Resource Server com a chave pública
23.13. Revisando o fluxo de aprovação do Authorization Code com JWT
23.14. Autenticando usuário com dados do banco de dados
23.15. Desafio: refatorando serviços de usuários para usar BCrypt
23.16. Adicionando claims customizadas no payload do JWT
23.17. Obtendo usuário autenticado no Resource Server
23.18. Definindo e criando as permissões de acesso
23.19. Carregando as permissões concedidas na autenticação
23.20. Carregando as Granted Authorities e restringindo acesso a endpoints na API
23.21. Method Security: Restringindo acesso com @PreAuthorize e SpEL
23.22. Desafio: tratando AccessDeniedException no ExceptionHandler
23.23. Simplificando o controle de acesso em métodos com meta-anotações
23.24. Entendendo os escopos do OAuth2
23.25. Carregando Granted Authorities dos escopos do OAuth2 no Resource Server
23.26. Restringindo acesso a endpoints por escopos do OAuth2
23.27. Desafio: restringindo acesso dos endpoints de restaurantes
23.28. Restringindo acessos de forma contextual (sensível à informação)
23.29. Restringindo acessos com @PostAuthorize
23.30. Desafio: restringindo acessos ao endpoint de pesquisa de pedidos
23.31. Desafio: restringindo acessos aos endpoints de transição de status de pedidos
23.32. Desafio: restringindo acessos aos endpoints de formas de pagamentos
23.33. Desafio: restringindo acessos aos endpoints de cidades e estados
23.34. Desafio: restringindo acessos aos endpoints de usuários, grupos e permissões
23.35. Desafio: restringindo acessos aos endpoints de estatísticas
23.36. Configurando os clientes OAuth2 em um banco de dados SQL
23.37. Cadastrando clientes OAuth2 no banco de dados e testando a emissão de tokens
23.38. Corrigindo lógica de restrição de acessos para Client Credentials Flow
23.39. Gerando links do HAL dinamicamente de acordo com permissões do usuário
23.40. Desafio: gerando links do HAL dinamicamente de acordo com permissões
23.41. Juntando o Resource Server com o Authorization Server no mesmo projeto
23.42. Ajustando a documentação da API para suporte a OAuth2
23.43. Customizando a página de login
23.44. Customizando a página de OAuth2 Approval
24. Deploy em produção
24.1. Conhecendo o Twelve-Factor App
24.2. Onde fazer deploy?
24.3. Conhecendo a PWS (Pivotal Web Services)
24.4. Instalando o CLI do Cloud Foundry
24.5. Criando o bucket de produção na Amazon S3
24.6. Criando uma conta na PWS
24.7. Conhecendo o CLI do Cloud Foundry
24.8. Instanciando serviços com o marketplace da PWS
24.9. Configurando serviços externos com CUPS
24.10. Separando as configurações dos ambientes de produção e desenvolvimento com Spring Profiles
24.11. Adicionando propriedades adicionais com CUPS
24.12. Gerando o Fat JAR
24.13. Implantando a aplicação na PWS
24.14. Fazendo binding dos serviços
24.15. Subindo a aplicação e fazendo downgrade do Flyway
24.16. Inserindo dados no banco de produção
24.17. Testando o upload de fotos
24.18. Testando o envio de e-mail
24.19. Retirando as chaves de segurança do projeto
24.20. Conhecendo o Registro.br e Cloudflare
24.21. Registrando um domínio no Registro.br
24.22. Configurando a conta no Cloudflare
24.23. Escalando a aplicação
24.24. Blue-Green Deployment: implantando novas versões com zero downtime
24.25. Resolvendo problema de sessão com Spring Session e Redis
24.26. Conclusão e próximos passos
1. Introdução
1.1. Introdução ao React
1.2. Aprendendo o básico do React no Codepen
1.3. Configurando o ambiente de desenvolvimento
1.4. Iniciando a nossa SPA com React CLI
1.5. Como funciona o suporte da AlgaWorks
1.6. Estrutura do projeto SPA
1.7. Apresentando a aplicação final e dicas para seguir o curso
2. Mergulhando nos fundamentos do React
2.1. Criando o primeiro componente em React
2.2. Componentes baseados em classe
2.3. Ciclos de vida dos componentes
2.4. Componentes funcionais (com hooks)
2.5. Entendendo o hook useEffect
2.6. Dando cara à nossa aplicação (estilizando com CSS)
2.7. Entendendo tudo sobre Props
2.8. Shared components e arquitetura
2.9. Criando o componente Input
2.10. Renderização de listas em detalhes
2.11. Preparando para criar o componente de tabela
2.12. Estrutura HTML de uma tabela
2.13. Estilizando o componente de tabela com Sass
2.14. O grande problema do componente de tabela genérico
2.15. Resolvendo o problema do componente de tabela genérico com organização de dados
2.16. Propificando a tabela
2.17. Iniciando o componente de formulário
2.18. Interligando o estado do componente com o formulário
2.19. Cadastrando o produto no estado da aplicação
2.20. Reutilizando o componente de formulário
2.21. Limpando um formulário com estado
2.22. Habilitando botões de ação na tabela
2.23. Finalizando a interface do projeto
2.24. Revendo o que aprendemos neste módulo
3. Interligando com o back-end
3.1. Introdução a conexão com APIs
3.2. Fetch API: requisições com JavaScript moderno
3.3. Produtividade com Axios
3.4. OpenAPI: Configurando a API do AlgaStock na máquina
3.5. Entendendo o pattern de serviços
3.6. Atualizando o schema do produto
3.7. Finalizando o serviço de produtos
3.8. Mock server com Prism
3.4. OpenAPI: Configurando a API do AlgaStock na máquina
3.5. Entendendo o pattern de serviços
3.6. Atualizando o schema do produto
3.7. Finalizando o serviço de produtos
3.8. Mock server com Prism
4. Controlando o estado global com Redux
4.1. Introdução ao Redux
4.2. Store, Reducer e Actions
4.3. Debugando o estado com o Redux DevTools
4.4. Conectando componentes com o Redux
4.5. Disparando actions com componentes
4.6. Redux Thunk: Actions Assíncronas
4.7. Redux Thunk e o TypeScript
4.8. Redux conectado com API = Actions + Services
4.9. Refatoração e boas práticas
5. Roteamento
5.1. Introdução ao React Router
5.2. Criando a primeira rota
5.3. Criando a view 404 Not Found
5.4. Criando a view de Login
5.5. Criando a view de perfil (dica para mockar os dados do Redux)
5.6. Login: Autenticando o usuário com Redux Persist
5.7. Segurança: Protegendo views e componentes com um HOC (High Order Component)
6. Build e produção
6.1. Build vs Desenvolvimento Webpack, Babel e Sass
6.2. Gerando o bundle e entendendo os arquivos de map
6.3. Eject vale a pena?
6.4. Deploy do AlgaStock no Netlify
6.5. Conclusão e próximos passos
7. Bônus: aulas extras
7.1. Como funciona o logout
7.2. Redirecionando para a home após o login
7.3. Corrigindo o Redux DevTools em produção
1. Introdução
1.1. Introdução ao curso
1.2. Apresentando o projeto
1.3. Preparando o ambiente de desenvolvimento
2. Começando com HTML
2.1. O que é HTML?
2.2. Estrutura básica do documento
2.3. DOCTYPE e codificação
2.4. Primeiras tags: títulos, quebras de linhas e parágrafos
2.5. Comentários
2.6. Ênfase, importância e marcação
2.7. Imagens
2.8. ncoras (links)
2.9. Elementos estruturais
3. Começando com CSS
3.1. O que é CSS
3.2. Estilos incorporados e Regras CSS
3.3. Estilos em arquivos externos
3.4. Seletores de tipo, classe e ID
3.5. Agrupando seletores
3.6. Seletores descendentes
3.7. Seletores de filhos diretos
3.8. Cores
3.9. Formatação de textos
3.10. Inspecionando com Chrome DevTools
3.11. Entendendo a propriedade display
3.12. Adicionando bordas
3.13. Espaçamento interno (padding)
3.14. Margens de elementos
3.15. Box model e a propriedade box-sizing
4. Iniciando o projeto do curso
4.1. Preparando o projeto
4.2. Criando o cabeçalho da página
4.3. Listas ordenadas e não-ordenadas
4.4. Adicionando os planos
4.5. Flutuando elementos
4.6. Usando pseudo-elementos
4.7. Configurando os planos lado a lado com float
4.8. Criando um botão
4.9. As pseudo-classes :focus e :hover
4.10. Reset CSS e Normalize.css
5. Web Design Responsivo
5.1. O que é Responsive Web Design?
5.2. Unidade de medida: pixel
5.3. Unidade de medida: percentual
5.4. Meta tag viewport
5.5. Layout fixo e fluído
5.6. Layout responsivo e media queries
5.7. Como funciona um sistema de Grid CSS
5.8. Sistema de grid do Bootstrap
5.9. Ajustando o projeto para usar Grid CSS
6. Especificidade, BEM e boas práticas
6.1. Especificidade do CSS
6.2. Caos no CSS: porque uma metodologia é importante?
6.3. A Metodologia BEM: seu código escalável
6.4. Como usar BEM na prática - parte 1
6.5. Como usar BEM na prática - parte 2
6.6. Ajustando o projeto do curso com BEM
6.7. Mais organização: CSS com Guidelines
7. Encerrando o projeto e mais CSS
7.1. Unidades de medida: em e rem
7.2. Ajustando unidades de medida no projeto
7.3. Adicionando chamada principal
7.4. Adicionando depoimento
7.5. Adicionando rodapé
7.6. Posicionamento estático e fixo
7.7. Posicionamento relativo
7.8. Posicionamento absoluto
7.9. Adicionando rótulo no plano
7.10. Ajustando margem do plano
7.11. Adicionando aspas no depoimento
7.12. Adicionando o bloco de navegação
7.13. Adicionando o menu para telas pequenas
7.14. Ajustando o menu para telas médias e grandes
7.15. JavaScript Hook: chaveando o menu
7.16. Criando um formulário: assinatura de plano
7.17. Concluindo o formulário de assinatura de plano
7.18. Entendendo as tabelas do HTML
7.19. Aplicando estilos em tabelas com CSS
7.20. Conclusão e próximos passos
1. Introdução
1.1. Introdução ao workshop
1.2. Como usar o suporte
1.3. Introdução ao JavaScript
1.4. Instalando o Node.js no Mac
1.5. Instalando o Node.js no Windows
1.6. Rodando JavaScript no Sublime Text no Mac
1.7. Rodando JavaScript no Sublime Text no Windows
2. Fundamentos do JavaScript
2.1. Variáveis e hoisting
2.2. Tipagem dinâmica
2.3. Tipo Number
2.4. Tipo String
2.5. Tipo Boolean
2.6. O operador typeof
2.7. Operadores aritméticos
2.8. Operadores de comparação
2.9. Operadores lógicos
2.10. Estrutura de controle if, else if, else
2.11. Operador ternário
2.12. Estrutura de controle for
2.13. Estrutura de controle while
2.14. Valores null e undefined
3. Funções
3.1. Introdução a funções
3.2. Alert e console.log
3.3. Funções matemáticas
3.4. Criando funções
3.5. Escopo de função e global
3.6. Closures
4. Introdução a objetos
4.1. Introdução a objetos
4.2. Criando objetos
4.3. Objetos dentro de objetos
4.4. Apagando propriedades do objeto
4.5. Iterando sobre propriedades do objeto
4.6. Comparando objetos
5. Arrays
5.1. Introdução a arrays
5.2. Criando arrays
5.3. Array vs Object
5.4. Adicionando e removendo elementos do array
5.5. Iterando nos elementos com forEach
5.6. Funções toString() e join()
5.7. Elementos do array
5.8. Mais da API de arrays
6. JavaScript no Browser
6.1. Conhecendo o Developer Tools
6.2. Debug com o Developer Tools
6.3. Boas práticas
6.4. Objeto window
6.5. CDN vs local hosting
7. jQuery
7.1. Introdução ao jQuery
7.2. Seletores
7.3. CSS
7.4. Introdução ao HTTP
7.5. Ajax e promises
7.6. Manipulação do DOM
7.7. Plugins jQuery
8. Trabalhando com eventos
8.1. Introdução a eventos
8.2. Eventos de manipulação do DOM
8.3. Disparando eventos
8.4. Temporizadores
9. Funções e objetos
9.1. Entendendo o protótipo do objeto
9.2. Como funciona o shadowing
9.3. Funções fábrica
9.4. Funções construtoras
9.5. Module Pattern
9.6. Propriedade prototype das funções
9.7. Usando a função bind
9.8. Disparando eventos customizados
9.9. Chamando funções através de call e apply
9.10. Namespaces
9.11. Conclusão
1. Introdução
1.1. Introdução ao curso
1.2. O que é TypeScript?
1.3. Instalando o Node.js e NPM
1.4. Conhecendo e instalando o Visual Studio Code
1.5. Instalando o TypeScript
1.6. Primeiro código com TypeScript
2. Fundamentos do TypeScript
2.1. Declaração de variáveis (var, let e const)
2.2. Tipos básicos
2.3. Inferência de tipos
2.4. Arrays e iterações
3. Orientação a objetos
3.1. Classes e objetos
3.2. Propriedades e métodos
3.3. Construindo sua primeira classe
3.4. Herança
3.5. Interfaces
4. Outros recursos do ES6
4.1. Fat arrow functions
4.2. Template strings
4.3. Promise
4.4. Conclusão
1. Introdução
1.1. Como aprender Java?
1.2. A história do Java
1.3. As plataformas Java e como elas evoluem
1.4. Máquina virtual Java
1.5. Baixando, instalando e configurando a JDK
1.6. Exercício: instalação da JDK
2. Fundamentos da linguagem
2.1. Codificando, compilando e executando o programa "oi mundo"
2.2. Exercício: codificando um primeiro programa
2.3. Comentários
2.4. Sequências de escape
2.5. Palavras reservadas
2.6. Convenções de código
2.7. Trabalhando com variáveis
2.8. Nomeando variáveis
2.9. Operadores aritméticos
2.10. Exercício: variáveis e operadores aritméticos
2.11. Tipos primitivos
2.12. Outros operadores de atribuição
2.13. Conversão de tipos primitivos
2.14. Promoção aritmética
2.15. Exercício: tipos primitivos e outros operadores de atribuição
2.16. Trabalhando com strings
2.17. Recebendo entrada de dados
2.18. Operadores de comparação e igualdade
2.19. Estruturas de controle if, else if e else
2.20. Exercício: Strings, entrada de dados, operadores de comparação e if else
2.21. Escopo de variáveis
2.22. Operadores lógicos
2.23. Exercício: operadores lógicos
2.24. Estrutura de controle switch
2.25. Operador ternário
2.26. Operadores de incremento e decremento
2.27. Estrutura de controle while
2.28. Estrutura de controle do-while
2.29. Estrutura de controle for
2.30. Cláusulas break e continue
2.31. Exercício: operador ternário, decremento e estruturas de repetição
2.32. Introdução e instalação do Eclipse IDE
2.33. Depurando códigos com o Eclipse
2.34. Exercício: instalando o Eclipse IDE
3. Orientação a Objetos - parte 1
3.1. O que é POO?
3.2. Classes e objetos
3.3. Criando uma classe com atributos
3.4. Instanciando objetos
3.5. Acessando atributos de objetos
3.6. Exercício: instanciando e acessando atributos do objeto
3.7. Composição de objetos
3.8. Valores padrão
3.9. Variáveis referenciam objetos
3.10. Criando, nomeando e chamando métodos
3.11. Métodos com retorno
3.12. Passando argumentos para métodos
3.13. Argumentos por valor ou referência
3.14. Exercício: composição de objetos e chamada de métodos
4. Wrappers, boxing e arrays
4.1. Wrappers do java.lang
4.2. Boxing
4.3. Desafio: wrappers e boxing
4.4. Trabalhando com arrays
4.5. Exercício: arrays
5. Orientação a Objetos - parte 2
5.1. Introdução à UML e diagrama de classes
5.2. Desafio: diagrama de classes
5.3. O objeto this
5.4. Construtores
5.5. Encapsulamento e modificadores de acesso public e private
5.6. Criando JavaBeans
5.7. Desafio: objeto this, construtores e JavaBeans
5.8. Organizando os projetos em pacotes
5.9. Modificador de acesso default
5.10. Modificadores static e final
5.11. Desafio: static e final
5.12. Enumerações
5.13. Desafio: pacotes e enumerações
5.14. Herança e modificador protected
5.15. Classe java.lang.Object
5.16. Sobreposição
5.17. Desafio: herança e sobreposição
5.18. Sobrecarga
5.19. Exercício: sobrecarga
5.20. Polimorfismo, casting de objetos e instanceof
5.21. Classes abstratas
5.22. Desafio: polimorfismo e classes abstratas
5.23. Interfaces
5.24. Exercício: interfaces e polimorfismo
6. Tópicos avançados
6.1. Coleta de lixo
6.2. Classe java.lang.Math
6.3. Desafio: classe java.lang.Math
6.4. Tratando e lançando exceções
6.5. Desafio: exceções
6.6. Classes String, StringBuffer e StringBuilder
6.7. Trabalhando com datas
6.8. Desafio: datas
6.9. Trabalhando com números
6.10. Desafio: números
6.11. Collections Framework
6.12. Métodos equals e hashCode
6.13. Desafio: collections
6.14. Arquivos JAR
6.15. Exercício: arquivos JAR
6.16. Documentação javadoc
6.17. Desafio: javadoc
6.18. Ordenando objetos
7. Mais detalhes e frameworks
7.1. Métodos da classe String
7.2. StringBuilder e StringBuffer
7.3. JOptionPane
7.4. JDBC
7.5. Varargs
7.6. Introdução a XML
7.7. Introdução ao JSON
7.8. Arquivos properties
7.9. Geração de javadoc
7.10. Introdução a expressão regulares
7.11. Introdução a generics
7.12. Logging com log4j
7.13. Debug com Eclipse
7.14. Maven
7.15. Testes de unidade com JUnit
7.16. Parâmetros da JVM
8. Entrada e saída - I/O
8.1. Gravando arquivo
8.2. Lendo arquivo
8.3. A classe Scanner
9. Serialização de objetos
9.1. Salvando e lendo objetos em arquivo
9.2. Enviando objetos na rede
9.3. Criando uma aplicação de chat
10. Novidades do Java 7
10.1. Separador de dígitos em literais numéricos
10.2. Switch case com String
10.3. Diamond
10.4. try-with-resources e multi-catch
11. Novidades do Java 8
11.1. Introdução ao Lambda
11.2. Referência a métodos
11.3. Interfaces funcionais
11.4. Introdução a Stream
11.5. API de Data - Parte 1
11.6. API de Data - Parte 2
11.7. API de Data - Parte 3
11.8. API de Data - Parte 4
11.9. Próximos passos
11.10. Conclusão
Você precisa conhecer apenas o básico de Java e Orientação a Objetos.
Mas se você não tiver nenhum conhecimento sobre esses assuntos, sem problemas!
A boa notícia é que nessa turma você vai ganhar como bônus um curso online completo de Java e Orientação a Objetos e também um e-book sobre o mesmo assunto.
Então, a única coisa que você precisa saber é lógica de programação. O resto você vai aprender com a gente.
Nãaaaoooo! Você vai aprender tudo, do zero até o ultra avançado nesse treinamento.
Sim. Vamos implementar a segurança com autorização bem granular/contextual.
Exemplo:
Administradores da plataforma de delivery podem fazer tudo (mas dependendo do grupo que pertencem, as permissões ficam restritas).
Gestores de restaurantes podem fazer apenas coisas relacionadas aos seus restaurantes.
Clientes finais podem fazer apenas coisas relacionadas aos seus pedidos.
Ou seja, a segurança será por grupo/permissão, mas também será sensível ao dono da informação. Pedido que João fez não pode ser consultado/alterado pela Maria. Pedido feito para restaurante X, não pode ser consultado ou alterado pelo restaurante Y. Sebastião, que é um vendedor da empresa de delivery, não pode consultar pedidos, mas pode cadastrar restaurantes, etc.
Estamos usando as últimas versões estáveis no momento de início da gravação do curso, como por exemplo Spring Boot 2.1 e 2.2.
A maior parte das dependências são gerenciadas pelo Spring Boot, para garantir a compatibilidade.
Não. O ESR não é um treinamento de front-end.
O Especialista Spring REST é um treinamento imersivo focado em back-end, ou seja, é para quem quer se tornar especialista em desenvolvimento de REST APIs com Spring.
Nós temos algumas aulas ensinando como consumir uma REST API com JavaScript, mas não é o foco ensinar front-end nesse treinamento.
Essas aulas têm como único objetivo ensinar JavaScript na perspectiva de consumo de REST APIs (e não desenvolver páginas completas de um sistema).
API é uma interface usada para integração de sistemas. E hoje está usando muito até para separar os módulos dos sistemas, como por exemplo a parte de front-end e back-end.
Nesse treinamento nós vamos focar no back-end, ou seja, no desenvolvimento de APIs usando o estilo arquitetural REST.
Dessa forma, podemos ter páginas web, aplicativos, sistemas de terceiros, etc, usando a nossa mesma API, consumindo nossos serviços, realizando coisas no nosso sistema.
Resumindo:
Segurança: será bem mais avançado, com assinatura do token de forma simétrica e assimétrica, todos os fluxos do OAuth2, PKCE, Authorization Server e Resource Server juntos e separados, customização para armazenar Opaque Tokens em Redis, configuração de cadastro de clients no banco de dados, granularidade muito mais fina na autorização de endpoints.
Bean Validation: criação de validações compostas e programáticas, validações em nível de classe (quando um atributo depende do valor de outro), grupos de validações.
Exception handling: Diversas formas de tratar exceptions e uso de modelo de representação do erro, para deixar respostas de erro consistentes. Implementação da RFC 7808 (Problem Details for HTTP APIs).
Testes de integração: com Spring Boot Test, REST Assured, JUnit, AssertJ e Maven Failsafe Plugin.
Boas práticas de modelagem avançada de APIs: 5 leis fundamentais para trabalhar com data/hora, customizações do Jackson, boas práticas para nomear URIs de recursos, uso de DTO e ModelMapper, IDs vs UUIDs, Chatty vs Chunky APIs, modelagem de conceitos abstratos e ações não-CRUD, modelagem de recursos para ações em massa, etc.
Projeções, pesquisas complexas e relatórios: com DTO, @JsonView, property filter do Jackson, Squiggly, relatórios com JasperReports, etc.
Envio de e-mails transacionais: com implementações fake e sandbox de componentes para envio de e-mails (útil para testes).
Documentação com OpenAPI (Swagger): customizações avançadas para deixar a documentação consistente com a API.
Cache HTTP: Cache-control, ETags, Deep ETags, Shallow ETags, etc.
HATEOAS e Discoverability: vamos adicionar hypermedia na API usando Spring HATEOAS e HAL e revisar a API para adicionar links entre os recursos.
Versionamento de APIs: vamos discutir diversas estratégias, cuidados que devemos tomar e como implementar isso usando Media Type e URI.
E muuuuito mais.
O FSAS é um excelente treinamento imersivo. O ESR não substitui ele. E nem o FSAS substitui o ESR.
O FSAS é um treinamento que fala também de back-end, mas o foco é maior em front-end (Angular).
O ESR nasceu como um treinamento imersivo focado 100% em back-end, por isso temos a oportunidade agora de ensinar coisas que só dá pra ensinar em um curso como esse.
Sim, testes de integração com Spring Boot Test e REST Assured.
Não. O foco é REST API. Não faria sentido falar de GraphQL nesse treinamento e dividir o foco do curso, perdendo profundidade em REST.
Toda pergunta é boa, mas conceitualmente, essa pergunta não faz sentido. Sabe por que?
Porque uma coisa não substitui a outra. No treinamento, nós vamos usar Spring Boot E TAMBÉM Spring MVC (além de vários outros projetos do ecossistema).
O Spring MVC é o que nos permite desenvolver aplicações web (endpoints de uma REST APIs entra nisso).
Spring Boot nos ajuda a criar aplicações usando projetos do ecossistema Spring de uma forma muito mais produtiva, porque ele estabelece várias convenções. Ou seja, Spring Boot potencializa o Spring MVC e vários outros projetos.
Não. Isso é um assunto para um futuro curso de microservices, que não é o caso desse curso.
O ESR tem como foco total a modelagem e desenvolvimento do código da REST API com Spring, de forma ultra avançada. E apenas para ensinar isso, já precisamos de mais de 500 aulas.
Desenvolver REST APIs de forma profissional não é tão simples quanto parece, por isso o foco desse treinamento é esse.
Não será um clone do iFood. Imagino que o iFood tenha centenas de programadores trabalhando lá há alguns anos. Seria impossível fazer um clone e ensinar isso dentro de um treinamento.
O que vamos desenvolver é uma REST API inspirada no iFood e Uber Eats, para uma empresa de delivery de comidas.
O foco é ensinar os alunos a serem especialistas em desenvolvimento de APIs. O projeto é só uma forma de exercitar isso. Não espere sair do curso com um concorrente do iFood de igual para igual.
O FSAS é um treinamento imersivo que ensina tanto o back-end quanto o front-end, mas o foco maior é sem dúvidas o front-end.
O back-end do FSAS já é bem legal, mas não se compara com o ESR, que será um treinamento com foco total em back-end e por isso muuuuuito mais aprofundado.
Alguns assuntos acabarão se sobrepondo, naturalmente, mas no ESR nós vamos explicar com mais profundidade e detalhes. Outros assuntos mais avançados só serão ensinados no ESR (leia a descrição sobre o conteúdo do ESR aqui nessa página).
O SFE é um treinamento imersivo que ensina como desenvolver projetos web com a arquitetura tradicional (action-based), ou seja, com o front e back acoplados no mesmo projeto.
Apesar de também usar Spring, a arquitetura é totalmente diferente.
No SFE não falamos nada de REST APIs. No ESR, o foco é totalmente esse.
O “Começando com Web Services RESTful e Spring” é um curso introdutório sobre REST APIs com Spring, para dar uma ignição em quem precisa começar mas não tem dinheiro para adquirir um treinamento completo.
Se você já é aluno desse curso e quer avançar muuuuito mais no seu conhecimento, o ESR é o caminho natural e ideal pra você.
Se você não é aluno desse curso, não tem problemas, você pode começar direto no ESR.
Esse é um treinamento especialista em back-end. Não menospreze assim o back-end.
Tem desenvolvedores back-end ganhando R$15.000 fazendo "só" isso, nem sabem escrever um HTML direito, vivem do back-end. 😂
Apesar de ser um treinamento "só" de back-end, ele é o maior treinamento da AlgaWorks. Tem um nível de aprofundamento que nenhum outro treinamento de REST APIs no mundo possui.
Agradeço muito o seu interesse, mas não negociamos o nosso preço.
O treinamento já está com um excelente custo-benefício.
O retorno que ele pode te dar é infinitamente maior do que o valor que estamos cobrando. Mas entendo a sua situação de não ter condições agora.
Será que você conseguiria falar com algum familiar ou amigo para INVESTIR em você?
Explique a sua situação, o seu potencial, o seu comprometimento para fazer as coisas darem certo.
Tenho certeza que quem gosta de você, se puder, vai acreditar no seu potencial e vai investir em você com muito prazer.
Esse é um treinamento novo e único no mundo.
Você vai aprender um conjunto de coisas que não aprenderia em nenhum outro treinamento, justamente porque o nosso objetivo com o ESR foi aprofundar muito mais que o que já existe no mercado.
Independente se você já estudou desenvolvimento de REST APIs com Spring ou se está no zero, esse treinamento é pra você sim.
Faça a compra na sua pessoa física. Se a empresa aprovar o pagamento dentro de 30 dias, você envia um e-mail pra gente, nós recebemos da empresa e devolvemos o seu dinheiro. Ou então você pede reembolso da empresa.
Envie um e-mail para contato@algaworks.com informando a quantidade de pessoas e a nossa equipe vai te enviar uma proposta.
Fizemos isso no FSAS, SFE, SISJEE, JPA, etc. Então a previsão é que isso aconteça também no ESR. Geralmente nós adicionamos apêndices com novas funcionalidades e atualizações.
Esse é um treinamento imersivo, ou seja, um tipo de curso mais longo e avançado que nós oferecemos. É o maior treinamento da AlgaWorks.
São mais de 77 horas de videoaulas e 240 horas de carga horária.
Sim! Ela será enviada para seu e-mail após o vencimento da garantia de 30 dias.
AlgaWorks Softwares, Treinamentos e Serviços Ltda
CNPJ: 10.687.566/0001-97
