Document 2

Prévia do material em texto

Programaçao web 
 
🎓 AULA COMPLETA — PROGRAMAÇÃO 
WEB (Java + Spring) 
 
🧩 UNIDADE 1 — Fundamentos da Linguagem Java 
 
🔹 Seção 1.1 – Introdução à Linguagem de Programação Java 
🧠 O que é Java? 
Java é uma linguagem de programação orientada a objetos, portável, segura, 
multiplataforma e baseada em classes. 
 Seu lema é: "Write Once, Run Anywhere" (Escreva uma vez, rode em qualquer 
lugar) — graças à JVM (Java Virtual Machine). 
⚙️ Características principais: 
• Compilada e interpretada: o código é compilado em bytecode, executado pela 
JVM. 
• Fortemente tipada: exige declaração de tipos. 
• Multithread: suporta várias tarefas simultâneas. 
• Portabilidade: funciona em qualquer sistema com JVM. 
• Segurança: controle de memória e verificação de código em tempo de 
execução. 
💡 Estrutura básica de um programa Java: 
public class OlaMundo { 
 public static void main(String[] args) { 
 System.out.println("Olá, Perform Farma!"); 
 } 
} 
 
🧱 Componentes: 
• Classe: estrutura principal do código. 
• Método: conjunto de instruções executadas. 
• main: ponto inicial do programa. 
• System.out.println: imprime saída no console. 
🧰 Ferramentas: 
• JDK (Java Development Kit): compila e executa código. 
• JRE (Java Runtime Environment): ambiente de execução. 
• IDE: Eclipse, IntelliJ, NetBeans, VSCode. 
 
🔹 Seção 1.2 – Programação Orientada a Objetos (P.O.O.) em Java 
A POO é o coração do Java. 
 Ela organiza o código em objetos que representam elementos do mundo real. 
🧠 Conceitos principais: 
Conceito Explicação Exemplo 
Classe 
Modelo que define atributos e 
comportamentos 
class Carro { String modelo; 
void acelerar(){} } 
Objeto Instância da classe Carro c1 = new Carro(); 
Atributo Característica do objeto String modelo; 
Método Ação que o objeto executa acelerar() 
Encapsu
lamento 
Protege dados (getters/setters) 
private int velocidade; public 
int getVelocidade(){...} 
Herança 
Reaproveita código de outra 
classe 
class Moto extends Veiculo {} 
Polimorf
ismo 
Um mesmo método com 
comportamentos diferentes 
veiculo.acelerar(); (pode ser 
carro ou moto) 
💡 Exemplo: 
public class Animal { 
 void som() { System.out.println("Som genérico"); } 
} 
 
class Cachorro extends Animal { 
 void som() { System.out.println("Au Au!"); } 
} 
 
class Gato extends Animal { 
 void som() { System.out.println("Miau!"); } 
} 
 
🧭 Boas práticas: 
• Nomear classes com inicial maiúscula. 
• Um arquivo por classe. 
• Encapsular atributos. 
• Reutilizar código via herança e interfaces. 
 
🔹 Seção 1.3 – Trabalhando com Exceptions 
⚠️ O que são Exceptions? 
Exceptions são erros que acontecem em tempo de execução. 
 Elas permitem tratar falhas sem encerrar o programa. 
🧱 Tipos: 
• Checked Exceptions: devem ser tratadas (ex: IOException, SQLException). 
• Unchecked Exceptions: não obrigatórias (ex: NullPointerException). 
🧰 Estrutura básica: 
try { 
 int resultado = 10 / 0; 
} catch (ArithmeticException e) { 
 System.out.println("Erro: divisão por zero!"); 
} finally { 
 System.out.println("Finalizando operação."); 
} 
 
💡 Criando sua própria Exception: 
class SaldoInsuficienteException extends Exception { 
 public SaldoInsuficienteException(String msg) { super(msg); } 
} 
 
 
🔹 Seção 1.4 – Heranças e Interfaces 
🧠 Herança: 
Permite reaproveitar código de uma classe base. 
class Veiculo { 
 void mover() { System.out.println("Veículo em movimento"); } 
} 
class Carro extends Veiculo { 
 void mover() { System.out.println("Carro rodando"); } 
} 
 
💡 Interface: 
Define contratos que devem ser implementados por outras classes. 
interface Animal { 
 void emitirSom(); 
} 
class Cachorro implements Animal { 
 public void emitirSom() { System.out.println("Au Au"); } 
} 
 
🧭 Boas práticas: 
• Usar herança apenas quando há relação “é um” (is a). 
• Preferir interfaces para comportamentos genéricos. 
• Evitar herança múltipla (Java não permite para classes). 
 
🌐 UNIDADE 2 – Fundamentos de Web e Serviços HTTP 
 
🔹 Seção 2.1 – Introdução à Arquitetura Web 
🧠 Conceito: 
A arquitetura web define como clientes (navegadores) e servidores interagem via 
protocolo HTTP. 
💡 Componentes: 
• Cliente: navegador ou app que faz requisições. 
• Servidor: processa e envia respostas. 
• HTTP: protocolo de comunicação. 
• URL: localiza recursos na web. 
• HTML/CSS/JS: camada de apresentação. 
🔄 Ciclo de requisição: 
1. Usuário acessa uma URL. 
2. Navegador envia requisição HTTP. 
3. Servidor processa e devolve resposta HTTP. 
4. O cliente exibe o conteúdo. 
🧰 Métodos HTTP: 
Método Função 
GET Buscar dados 
POST Enviar dados 
PUT 
Atualizar 
dados 
DELETE 
Remover 
dados 
 
🔹 Seção 2.2 – Servlets em Java 
⚙️ O que são Servlets? 
Um Servlet é uma classe Java que roda no servidor e processa requisições HTTP. 
 Eles são a base da tecnologia Java EE (Jakarta EE). 
💡 Exemplo: 
@WebServlet("/hello") 
public class HelloServlet extends HttpServlet { 
 protected void doGet(HttpServletRequest req, HttpServletResponse 
res) 
 throws IOException { 
 res.getWriter().print("Olá Mundo via Servlet!"); 
 } 
} 
 
🧭 Ciclo de vida: 
1. init() — inicializa o servlet. 
2. service() — processa requisições. 
3. destroy() — finaliza o servlet. 
 
🔹 Seção 2.3 – Desenvolvimento com Servlets 
🧱 Componentes principais: 
• web.xml: define rotas e configurações. 
• @WebServlet: anotação moderna para mapeamento. 
• Request e Response: entrada e saída de dados HTTP. 
• Dispatcher: redireciona requisições entre páginas. 
💡 Exemplo: recebendo parâmetros: 
@WebServlet("/saudacao") 
public class SaudacaoServlet extends HttpServlet { 
 protected void doPost(HttpServletRequest req, 
HttpServletResponse res) 
 throws IOException { 
 String nome = req.getParameter("nome"); 
 res.getWriter().print("Olá, " + nome + "!"); 
 } 
} 
 
 
🔹 Seção 2.4 – Sessões em Servlets 
🧠 Sessão: 
A sessão HTTP guarda dados do usuário enquanto ele navega. 
HttpSession sessao = request.getSession(); 
sessao.setAttribute("usuario", "Nayara"); 
String user = (String) sessao.getAttribute("usuario"); 
 
• Criação automática: request.getSession(true) 
• Encerramento: session.invalidate() 
 
💻 UNIDADE 3 – Programação Cliente-Servidor (JSP) 
 
🔹 Seção 3.1 – JSP: Primeiros Passos 
JSP (JavaServer Pages) é usada para criar páginas dinâmicas em Java, misturando 
HTML e código Java. 
💡 Exemplo básico: 
 
 
 Olá, ! 
 
 
 
Vantagens: 
• Integração fácil com Servlets. 
• Ideal para protótipos e sistemas simples. 
• Roda dentro de containers (Tomcat, Jetty, etc.). 
 
🔹 Seção 3.2 – Conteúdos de uma página JSP 
🧩 Tipos de tags: 
Tipo Função 
 Código Java embutido 
 
Exibir resultado 
 
Declarações de 
variáveis/métodos 
 
Diretivas (import, page, include) 
💡 Exemplo: 
 
 
Data atual: 
 
 
🔹 Seção 3.3 – Adicionando TagLibs com JSP 
TagLibs (Tag Libraries) são bibliotecas de tags personalizadas, usadas para simplificar 
código JSP. 
Exemplo com JSTL: 
 
 
 Bem-vindo, ${usuario.nome} 
 
 
 
🔹 Seção 3.4 – Desenvolvendo em JSP com TagLibs 
🧠 Benefícios: 
• Código mais limpo e sem Java embutido. 
• Separação de lógica e apresentação. 
• Melhor manutenção e segurança. 
💡 Padrão MVC: 
• Model: classes e regras de negócio. 
• View: JSP (exibe os dados). 
• Controller: Servlet que recebe e direciona as requisições. 
 
☕ UNIDADE 4 – Desenvolvimento Web Cliente-
Servidor (Spring) 
 
🔹 Seção 4.1 – Introdução ao Spring 
Spring Framework é o principal framework Java para desenvolvimento web 
corporativo. 
• Baseado em Injeção de Dependência. 
• Facilita o uso do padrão MVC. 
• Usa anotaçõesmodernas (@RestController, @Autowired, etc.). 
 
🔹 Seção 4.2 – Modelo MVC com Spring 
🧱 Estrutura: 
Camada Função Exemplo 
Model Dados e lógica 
Classes, entidades 
JPA 
View Exibição JSP, Thymeleaf, HTML 
Controller Controle de fluxo Classes @Controller 
💡 Exemplo: 
@Controller 
public class HomeController { 
 @GetMapping("/home") 
 public String home(Model model) { 
 model.addAttribute("mensagem", "Bem-vindo!"); 
 return "home"; // página home.jsp 
 } 
} 
 
 
🔹 Seção 4.3 – Ambiente Necessário para Desenvolvimento 
🧰 Ferramentas: 
• JDK 17+ 
• Spring Boot (via Spring Initializr) 
• IDE: IntelliJ IDEA, Eclipse, ou VS Code 
• Servidor: Tomcat embutido 
• Maven/Gradle: gerenciamento de dependências 
 
🔹 Seção 4.4 – Desenvolvimento de Aplicações Spring 
⚙️ Exemplo prático de API REST: 
@RestController 
@RequestMapping("/api/usuarios") 
public class UsuarioController { 
 
 @GetMapping 
 public List listar() { 
 return List.of("Nayara", "Gabriel", "Ana"); 
 } 
} 
 
🧭 Recursos Spring Boot: 
• application.properties para configurações. 
• @Service e @Repository para camadas organizadas. 
• @Autowired para injetar dependências. 
• Testes com @SpringBootTest. 
 
📚 RESUMO GERAL 
Unidade Tema Conceitos-chave 
1 Java e POO 
Classes, objetos, herança, 
exceptions 
2 Web e HTTP Servlets, sessões, métodos HTTP 
3 JSP Páginas dinâmicas, TagLibs, MVC 
4 Spring MVC moderno, APIs REST, IoC 
 
🧭 Plano de Estudo Recomendado 
Sem
ana 
Tópico Prática 
1 
Java básico + 
POO 
Criar classes, objetos e tratar exceptions 
2 Servlets + HTTP Fazer formulário e servlet de resposta 
3 JSP + MVC Criar mini site com login em JSP 
4 Spring Boot 
Criar API REST + integração com front JSP ou 
Thymeleaf 
 
🧠 Desafio Final 
Desenvolva uma aplicação web simples com Spring Boot + MVC que: 
• Possua página JSP de login 
• Armazene usuários em lista ou banco H2 
• Use controller Spring para processar o login 
• Mostre mensagem personalizada no JSP com TagLib 
 
 
 
 
 
Perfeito — vou destrinchar com máximo detalhe cada seção das 4 unidades que você 
indicou: conceitos, exemplos de código, boas práticas, armadilhas comuns, exercícios 
práticos (com gabarito/guia quando aplicável), sugestões de implementação passo a 
passo e recursos para aprofundar. Vai ficar extenso — mas organizado por seção para 
você estudar e usar como apostila. Vamos lá! 
✅ UNIDADE 1 — Fundamentos da 
Linguagem Java 
 
Seção 1.1 — Introdução à Linguagem Java (detalhado) 
O que é / por que usar 
• Java é linguagem orientada a objetos, compilada para bytecode, executada na 
JVM → portabilidade (WORA). Usada em backend corporativo, Android 
(históricamente), ferramentas, e grande ecossistema de bibliotecas. 
• Versões: conheça LTS (8, 11, 17, 21…) — prefira uma LTS atual (ex.: JDK 17/21). 
Ambiente 
• Instalar JDK (variantes: OpenJDK, Oracle JDK), configurar JAVA_HOME, PATH. 
• IDEs: IntelliJ IDEA (recomendado), Eclipse, NetBeans, VS Code + extensions. 
• Build tools: Maven (pom.xml), Gradle (build.gradle). Saiba criar um projeto com 
cada um. 
Fluxo de compilação/executação 
1. .java -> javac -> .class (bytecode) 
2. java executa bytecode na JVM 
3. Ferramentas modernas: java -jar, mvn spring-boot:run, gradle 
bootRun. 
Sintaxe e tipos 
• Primitivos: int, long, double, boolean, char. 
• Referência: String, arrays, classes. 
• Conversões (casting), wrapper classes (Integer, Long) e autoboxing. 
Exemplo mínimo 
public class Ola { 
 public static void main(String[] args) { 
 System.out.println("Olá, Perform Farma!"); 
 } 
} 
 
Boas práticas iniciais 
• Use nomes significativos, camelCase para métodos/variáveis, PascalCase para 
classes. 
• Preferir var (Java 10+) com critério — não em excesso; seja explícito quando 
clareza exigir. 
• Tratar exceções, usar logging (slf4j + logback) ao invés de 
System.out.println em apps reais. 
Erros comuns 
• NullPointerException (NPE): sempre valide objetos; prefira Optional quando 
fizer sentido. 
• Confusão entre igualdade de referência == e equals(). 
Exercício 
• Criar um programa que leia nome e idade, calcule ano de nascimento 
(assumindo que já fez aniversário) e mostre mensagem. 
 
Seção 1.2 — POO em Java (detalhado) 
Conceitos fundamentais 
• Encapsulamento: private atributos + get/set. Protege e permite validação. 
• Herança: extends. Reutiliza código, mas cuidado com acoplamento. 
• Polimorfismo: sobrescrita (@Override) e uso de tipos abstratos/superclasses. 
• Abstração: abstract class e interface. Use interfaces para contratos e 
composição. 
Exemplo com camadas 
public class Produto { 
 private String nome; 
 private double preco; 
 
 public Produto(String nome, double preco) { this.nome = nome; 
this.preco = preco; } 
 
 public double getPreco() { return preco; } 
 public void setPreco(double preco) { 
 if(preco 2 níveis). 
• Problema da herança: tight coupling, substitua por composição quando 
possível. 
Interfaces 
• interface oculta implementação; desde Java 8 interfaces podem ter default 
methods. 
• Exemplos: Comparable, Runnable. 
Exercício avançado 
• Criar interface Imprimivel com método imprimir(); implementar em 
RelatorioPDF e RelatorioHtml. Demonstre uso polimórfico. 
 
✅ UNIDADE 2 — Fundamentos de Web e 
Serviços HTTP 
 
Seção 2.1 — Introdução à Arquitetura Web (detalhado) 
Modelo cliente-servidor 
• Cliente (browser/mobile) faz requisição HTTP/HTTPS; servidor processa e 
responde. 
• HTTP é stateless por natureza — sessões e cookies permitem estado. 
Camadas comuns 
• Frontend (View) — HTML/CSS/JS, frameworks SPA (React/Angular/Vue). 
• Backend (API) — processa lógica, acessa BD, autentica, valida. 
• Banco de Dados. 
• Infra (CDN, load balancer, cache). 
HTTP em detalhe 
• Métodos: GET (idempotente), POST (cria), PUT (atualiza substituindo), PATCH 
(atualizaparcialmente), DELETE. 
• Códigos: 2xx (sucesso), 3xx (redirecionamento), 4xx (cliente), 5xx (servidor). 
• Cabeçalhos: Content-Type, Authorization, Cache-Control, Set-Cookie, CORS-
related (Access-Control-Allow-Origin). 
• HTTPS/TLS: obrigatórios em produção. 
Segurança 
• Autenticação: sessions, JWT, OAuth2/OpenID Connect. 
• CSRF: proteja formulários (tokens) ou use cabeçalhos + SameSite cookies. 
• XSS: escape de saída (templates), Content Security Policy (CSP). 
Exercício 
• Fazer uma sequência de requisições curl para um endpoint REST (GET, POST 
com JSON, PUT, DELETE) e analisar respostas. 
 
Seção 2.2 — Servlets em Java (detalhado) 
O que são 
• Servlets implementam javax.servlet / jakarta.servlet. São classes que 
respondem a requisições HTTP no container (Tomcat, Jetty). 
Ciclo de vida 
• init() (uma vez), service() (por requisição, chama doGet/doPost), 
destroy(). 
Implementação com exemplo 
@WebServlet(name="Hello", urlPatterns={"/hello"}) 
public class HelloServlet extends HttpServlet { 
 protected void doGet(HttpServletRequest req, HttpServletResponse 
resp) 
 throws ServletException, IOException { 
 resp.setContentType("text/plain;charset=UTF-8"); 
 resp.getWriter().write("Olá do Servlet!"); 
 } 
} 
 
Configurações 
• web.xml histórico vs Anotações (@WebServlet, @WebFilter). Hoje anotações 
são preferidas. 
Multithreading 
• Container pode reutilizar a mesma instância do servlet para várias requisições 
simultâneas → não armazenar estado na instância sem sincronização. 
Exercício 
• Criar servlet que recebe formulário POST com nome e escreve uma resposta 
personalizada. 
 
Seção 2.3 — Desenvolvimento com Servlets 
(detalhado) 
Parametrização e envio 
• req.getParameter("campo") para parâmetros form-data / query string. 
• req.getReader() / req.getInputStream() para ler corpo raw (JSON). 
• resp.setStatus() e resp.setContentType(). 
Dispatcher e forward 
• request.getRequestDispatcher("/pagina.jsp").forward(request, 
response) para manter URL. 
• response.sendRedirect("/outra") para redirecionamento (nova 
requisição). 
Sessões e Cookies 
• Sessões: HttpSession (get/set attributes). Cuidado com escalabilidade (sticky 
sessions vs session store). 
• Cookies: new Cookie("chave", "valor"), cookie.setHttpOnly(true), 
cookie.setSecure(true). 
Upload de arquivos 
• Multipart (@MultipartConfig) e usar Part para ler uploads. 
Exercício 
• Implementar upload de imagem via servlet e salvar em diretório temporário. 
 
Seção 2.4 — Sessões em Servlets (detalhado) 
Criando e gerenciando sessão 
• HttpSession session = request.getSession(); 
• Sessões geradas com cookie JSESSIONID por padrão. 
Configurações 
• Timeout da sessão: session.setMaxInactiveInterval(segundos) ou 
web.xml. 
• Persistência de sessão: em clusters, usar Redis, DB ou sticky sessions. 
Segurança 
• Regenerar id de sessão após login para mitigar session fixation. 
• Cookies: HttpOnly, Secure, SameSite=Strict/Lax. 
Exercício 
• Implementar login simples com sessão: Servlet de login define 
session.setAttribute("usuario", usuario); servlet protegido checa 
atributo e redireciona para login se ausente. 
 
✅ UNIDADE 3 — Programação Cliente-
Servidor com JSP 
 
Seção 3.1 — JSP: primeiros passos (detalhado) 
O que é JSP 
• Tecnologia para gerar HTML dinâmico no servidor. Compila JSP em servlets pelo 
container. 
Estrutura 
• Diretivas: , 
• Scriptlets (não recomendados): 
• Expressões: 
Melhor abordagem 
• Evite lógica Java em JSP. Use JSTL, EL e taglibs para manter view limpa. 
Exercício 
• Criar página JSP com formulário e mostrar dados enviados usando Expression 
Language ${param.nome}. 
 
Seção 3.2 — Conteúdos de uma página JSP (detalhado) 
EL (Expression Language) 
• ${objeto.propriedade} facilita acesso a atributos de request/session/app. 
• Operadores, funções JSTL. 
JSTL (JSP Standard Tag Library) 
• Core tags: , . 
• Formatting: , i18n. 
• SQL JSTL existe, mas não recomendado em produção (lógica de BD na view é 
má prática). 
Boas práticas 
• Model (servlet/Bean) prepara dados, JSP apenas renderiza. 
• Use MVC: Servlets como controllers, JSP como views. 
Exercício 
• Criar JSP que lista uma coleção List passada pelo servlet usando 
. 
 
Seção 3.3 — Adicionando TagLibs com JSP (detalhado) 
Criar TagLibs 
• Pode criar tags customizadas (TLD) ou usar bibliotecas prontas (JSTL, Spring 
tags, Apache tiles). 
• Taglibs ajudam reutilização e legibilidade da view. 
Exemplo JSTL 
 
 
 ${p.nome} - ${p.preco} 
 
 
Exercício 
• Substituir scriptlets por JSTL em uma JSP existente. 
 
Seção 3.4 — Desenvolvendo em JSP com TagLibs 
(detalhado) 
Internacionalização (i18n) 
• Use ResourceBundle + JSTL para locales. 
Templates e includes 
• para componentes reutilizáveis. 
• Em projetos modernos, considere Thymeleaf em vez de JSP (melhor integração 
com Spring Boot). 
Exercício final 
• Criar pequena aplicação: login -> área restrita -> lista de tarefas -> logout. View 
em JSP, controller em servlet. 
 
✅ UNIDADE 4 — Desenvolvimento Web 
Cliente-Servidor com Spring 
 
Seção 4.1 — Spring (detalhado) 
Por que Spring 
• Facilita IoC/DI, modularidade, configuração mínima com Spring Boot, 
ecossistema amplo (Security, Data, Cloud, Actuator). 
Conceitos 
• Beans: objetos gerenciados pelo container Spring. 
• Component scanning, @Component, @Service, @Repository, @Controller. 
• Profiles (@Profile) para ambientes. 
Inicializando projeto 
• Spring Initializr (start.spring.io), escolher dependências: Spring Web, Spring 
Data JPA, H2, Spring Security se necessário. 
Exercício 
• Criar projeto com Spring Boot que expõe GET /ping retornando JSON { 
"pong": true }. 
 
Seção 4.2 — Modelo MVC com Spring (detalhado) 
Controller 
• @Controller (retorna view) vs @RestController (json por padrão). 
• @GetMapping, @PostMapping para rotas. 
Model 
• Entities (JPA) e DTOs (projeções). 
• Services: camada de negócio, @Service. 
Repository 
• interface UsuarioRepository extends JpaRepository {} — CRUD pronto. 
View 
• Templates: Thymeleaf, FreeMarker, JSP. Em Spring Boot, Thymeleaf é mais 
integrada que JSP. 
Exemplo completo (esquema) 
• Controller -> chama Service -> Service chama Repository -> Repository persiste 
entitade -> Controller retorna view/JSON. 
Boas práticas 
• Não expor entidades JPA diretamente na API; use DTOs/Mapper (MapStruct). 
• Usar @Transactional na camada de serviço, não no controller. 
Exercício 
• Implementar CRUD de Produto com Spring Boot + Spring Data JPA + Thymeleaf. 
 
Seção 4.3 — Ambiente necessário para 
desenvolvimento (detalhado) 
Ferramentas 
• JDK 17/21, Maven/Gradle, IntelliJ/VsCode, Git. 
• Banco embarcado para desenvolvimento: H2; para produção: 
PostgreSQL/MySQL. 
• Test containers (Testcontainers) para testes de integração com DB real. 
• Postman/Insomnia para testar endpoints. 
Configurações úteis 
• application.properties / application.yml com profiles (application-
dev.yml, application-prod.yml). 
• Log: logback-spring.xml para configurar níveis (INFO/DEBUG). 
Exercício 
• Configurar projeto Spring Boot com profiles dev (H2) e prod (Postgres stub), e 
alternar via argumento de JVM. 
 
Seção 4.4 — Desenvolvimento de aplicações Spring 
(detalhado) 
Segurança 
• Spring Security: autenticação via formulário, Basic, JWT, OAuth2. 
• Exemplo básico: configurar WebSecurityConfigurerAdapter (ou a nova API 
em versões recentes) para permitir endpoints públicos e proteger outros. 
Validação 
• @Valid + @NotNull, @Size etc. (Bean Validation / Hibernate Validator). 
• Tratar erros com @ControllerAdvice e retornar mensagens amigáveis emAPIs. 
Testes 
• Unitários: @WebMvcTest para controllers, Mockito para mocks. 
• Integração: @SpringBootTest com @AutoConfigureMockMvc ou 
Testcontainers para DB. 
Deploy 
• JAR/War: Spring Boot gera jar com Tomcat embutido. 
• Dockerfile típico: 
FROM eclipse-temurin:17-jre 
COPY target/app.jar /app.jar 
ENTRYPOINT ["java","-jar","/app.jar"] 
 
• Orquestração: Kubernetes, Docker Compose para ambientes multi-container. 
Exercício final (projeto) 
• Projeto completo solicitado no desafio da unidade anterior: Spring Boot que 
serve JSP/Thymeleaf página de login, persiste usuários H2, redireciona para 
dashboard. Incluir testes unitários e integração, dockerização, e documentação 
README com passos para rodar. 
 
✅ ATIVIDADES PRÁTICAS, EXERCÍCIOS 
E AVALIAÇÃO (por nível) 
Exercícios Rápidos (iniciante → avançado) 
1. (Fácil) Java: Escreva classe ContaCorrente com depositar, sacar, e testar 
exceção de saldo insuficiente. 
2. (Médio) Servlet/JSP: Formulário HTML que chama Servlet para criar objeto 
Contato e mostrar lista em JSP (use session para armazenar temporariamente). 
3. (Médio) Spring: CRUD de Aluno com JPA/H2 e páginas Thymeleaf para 
listar/editar/remover. 
4. (Avançado) Integração: Dockerizar app Spring + PostgreSQL, configurar GitHub 
Actions que roda testes e gera imagem Docker. 
5. (Avançado) Segurança: Implementar login com Spring Security + JWT; proteger 
endpoints e criar refresh tokens. 
Projeto Capstone (entregável) 
• Requisitos: Login, CRUD de entidade (ex.: Treino), upload de foto, proteção de 
rotas, persistência em DB, testes automatizados, Dockerfile, pipeline CI 
simples (GitHub Actions), README com instruções. 
• Entregáveis: repositório Git com branches main e dev, imagens Docker, 
documentação. 
 
✅ ARMADILHAS COMUNS E COMO 
EVITÁ-LAS (resumo prático) 
• Nunca coloque lógica de negócio nas views (JSP) → sempre no 
controller/service. 
• Evite scriptlets; use JSTL/EL ou templates modernos (Thymeleaf). 
• Cuidado com synchronized e estado em servlets (thread-safety). 
• Use LAZY fetch e evite N+1 — aprenda a usar JOIN FETCH ou DTO projections. 
• Não exponha entidades JPA diretamente pela API. 
• Valide entradas (server-side) e sanitize saída (escape) contra XSS. 
 
✅ MATERIAIS E RECURSOS 
RECOMENDADOS 
• Documentação oficial Java (Oracle / OpenJDK) 
• Effective Java (Joshua Bloch) — boas práticas 
• Spring Guides (https://spring.io/guides) — tutoriais práticos 
• Javier & Baeldung (artigos Spring/Hibernate) 
• JSTL docs e exemplos 
• Cursos: plataformas (Alura, Udemy) — procurar por "Spring Boot + Thymeleaf", 
"Servlets and JSP" e "Java Web Services". 
 
✅ PLANO DE ESTUDO PRÁTICO (4 
semanas intensivo — versão de projeto) 
• Semana 1: Java e POO (exercícios, testes), Exceptions, Collections. 
• Semana 2: Servlets + JSP (formularios, sessões, uploads), JSTL. 
• Semana 3: Spring Boot básico (controllers, services, repositories), JPA/H2. 
• Semana 4: Segurança (Spring Security/JWT), testes, dockerização, CI. 
https://spring.io/guides
 
• Spring Boot + Thymeleaf (ou JSP) + JPA/H2, exemplos de servlets/JSP, Dockerfile 
e GitHub Actions. 
 
 
	🎓 AULA COMPLETA — PROGRAMAÇÃO WEB (Java + Spring)
	🧩 UNIDADE 1 — Fundamentos da Linguagem Java
	🔹 Seção 1.1 – Introdução à Linguagem de Programação Java
	🧠 O que é Java?
	⚙️ Características principais:
	💡 Estrutura básica de um programa Java:
	🧱 Componentes:
	🧰 Ferramentas:
	🔹 Seção 1.2 – Programação Orientada a Objetos (P.O.O.) em Java
	🧠 Conceitos principais:
	💡 Exemplo:
	🧭 Boas práticas:
	🔹 Seção 1.3 – Trabalhando com Exceptions
	⚠️ O que são Exceptions?
	🧱 Tipos:
	🧰 Estrutura básica:
	💡 Criando sua própria Exception:
	🔹 Seção 1.4 – Heranças e Interfaces
	🧠 Herança:
	💡 Interface:
	🧭 Boas práticas:
	🌐 UNIDADE 2 – Fundamentos de Web e Serviços HTTP
	🔹 Seção 2.1 – Introdução à Arquitetura Web
	🧠 Conceito:
	💡 Componentes:
	🔄 Ciclo de requisição:
	🧰 Métodos HTTP:
	🔹 Seção 2.2 – Servlets em Java
	⚙️ O que são Servlets?
	💡 Exemplo:
	🧭 Ciclo de vida:
	🔹 Seção 2.3 – Desenvolvimento com Servlets
	🧱 Componentes principais:
	💡 Exemplo: recebendo parâmetros:
	🔹 Seção 2.4 – Sessões em Servlets
	🧠 Sessão:
	💻 UNIDADE 3 – Programação Cliente-Servidor (JSP)
	🔹 Seção 3.1 – JSP: Primeiros Passos
	💡 Exemplo básico:
	Vantagens:
	🔹 Seção 3.2 – Conteúdos de uma página JSP
	🧩 Tipos de tags:
	💡 Exemplo:
	🔹 Seção 3.3 – Adicionando TagLibs com JSP
	Exemplo com JSTL:
	🔹 Seção 3.4 – Desenvolvendo em JSP com TagLibs
	🧠 Benefícios:
	💡 Padrão MVC:
	☕ UNIDADE 4 – Desenvolvimento Web Cliente-Servidor (Spring)
	🔹 Seção 4.1 – Introdução ao Spring
	🔹 Seção 4.2 – Modelo MVC com Spring
	🧱 Estrutura:
	💡 Exemplo:
	🔹 Seção 4.3 – Ambiente Necessário para Desenvolvimento
	🧰 Ferramentas:
	🔹 Seção 4.4 – Desenvolvimento de Aplicações Spring
	⚙️ Exemplo prático de API REST:
	🧭 Recursos Spring Boot:
	📚 RESUMO GERAL
	🧭 Plano de Estudo Recomendado
	🧠 Desafio Final
	✅ UNIDADE 1 — Fundamentos da Linguagem Java
	Seção 1.1 — Introdução à Linguagem Java (detalhado)
	Seção 1.2 — POO em Java (detalhado)
	Seção 1.3 — Trabalhando com Exceptions (detalhado)
	Seção 1.4 — Heranças e Interfaces (detalhado)
	✅ UNIDADE 2 — Fundamentos de Web e Serviços HTTP
	Seção 2.1 — Introdução à Arquitetura Web (detalhado)
	Seção 2.2 — Servlets em Java (detalhado)
	Seção 2.3 — Desenvolvimento com Servlets (detalhado)
	Seção 2.4 — Sessões em Servlets (detalhado)
	✅ UNIDADE 3 — Programação Cliente-Servidor com JSP
	Seção 3.1 — JSP: primeiros passos (detalhado)
	Seção 3.2 — Conteúdos de uma página JSP (detalhado)
	Seção 3.3 — Adicionando TagLibs com JSP (detalhado)
	Seção 3.4 — Desenvolvendo em JSP com TagLibs (detalhado)
	✅ UNIDADE 4 — Desenvolvimento Web Cliente-Servidor com Spring
	Seção 4.1 — Spring (detalhado)
	Seção 4.2 — Modelo MVC com Spring (detalhado)
	Seção 4.3 — Ambiente necessário para desenvolvimento (detalhado)
	Seção 4.4 — Desenvolvimento de aplicações Spring (detalhado)
	✅ ATIVIDADES PRÁTICAS, EXERCÍCIOS E AVALIAÇÃO (por nível)
	Exercícios Rápidos (iniciante → avançado)
	Projeto Capstone (entregável)
	✅ ARMADILHAS COMUNS E COMO EVITÁ-LAS (resumo prático)
	✅ MATERIAIS E RECURSOS RECOMENDADOS
	✅ PLANO DE ESTUDO PRÁTICO (4 semanas intensivo — versão de projeto)