Day 23/30 — A Evolução do Aprendizado Java: Com e Sem Spring

"Aprender Java sem Spring é como aprender a dirigir sem carro: você entende o motor, mas não sabe como tudo funciona junto." — Reflexão sobre aprendizado moderno

🎯 Por que esta Reflexão é Importante?

Recentemente, alguém comentou: "Todo mundo agora só aprende Java com Spring. Antigamente não era assim."

Isso me fez pensar:

• Como era aprender Java antigamente?
• A evolução do aprendizado: como fica?
• Será que a tecnologia está deixando profissionais incompletos?
• Como eu seria se tivesse aprendido Java sem Spring?

Esta reflexão não é sobre certo ou errado, mas sobre entender a evolução e como podemos ser profissionais mais completos.

📅 Como Era Antigamente?

Java nos Anos 2000

O que você aprendia:

• ✅ Core Java: Classes, objetos, herança, polimorfismo
• ✅ Collections: List, Set, Map, como funcionam internamente
• ✅ Threads: Programação concorrente do zero
• ✅ I/O: FileInputStream, BufferedReader, manipulação manual
• ✅ Sockets: Programação de rede TCP/IP
• ✅ JDBC: Conexão com banco de dados manual
• ✅ Servlets: HTTP do zero, request/response manual
• ✅ JSP: Views com scriptlets e JSTL

O que você NÃO tinha:

• ❌ Frameworks que faziam "mágica"
• ❌ Injeção de dependência automática
• ❌ ORM que gerenciava transações
• ❌ Anotações que simplificavam tudo

Resultado:

• ✅ Você entendia como tudo funcionava por baixo dos panos
• ✅ Você sabia o que cada linha de código fazia
• ✅ Você construía tudo do zero
• ⚠️ Mas levava muito mais tempo para fazer coisas simples

Exemplo: Criar uma API REST

Antigamente (2005):

// 1. Criar servlet
public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        // 2. Parse manual da URL
        String path = req.getPathInfo();
        String[] parts = path.split("/");
        Long userId = Long.parseLong(parts[1]);
        
        // 3. Conexão manual com banco
        Connection conn = DriverManager.getConnection(...);
        PreparedStatement stmt = conn.prepareStatement("SELECT * FROM users WHERE id = ?");
        stmt.setLong(1, userId);
        ResultSet rs = stmt.executeQuery();
        
        // 4. Converter manualmente para objeto
        User user = new User();
        if (rs.next()) {
            user.setId(rs.getLong("id"));
            user.setName(rs.getString("name"));
            // ... mais 20 linhas
        }
        
        // 5. Serializar manualmente para JSON
        resp.setContentType("application/json");
        PrintWriter out = resp.getWriter();
        out.print("{");
        out.print("\"id\":" + user.getId() + ",");
        out.print("\"name\":\"" + user.getName() + "\"");
        out.print("}");
        
        // 6. Fechar conexões manualmente
        rs.close();
        stmt.close();
        conn.close();
    }
}

Hoje (2025):

@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private UserRepository repository;
    
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return repository.findById(id)
            .orElseThrow(() -> new EntityNotFoundException("User not found"));
    }
}

Diferença:

• Antigamente: ~50 linhas, tudo manual, você controla cada passo
• Hoje: 5 linhas, Spring faz a mágica, você não vê o que acontece

🧠 A Evolução do Aprendizado

Vantagens do Aprendizado Antigo

1. Fundamentos Sólidos

   • Você entende como HTTP funciona
   • Você sabe como banco de dados se conecta
   • Você compreende o ciclo de vida de objetos

2. Debugging Profundo

   • Quando algo quebra, você sabe onde procurar
   • Você entende stack traces complexos
   • Você pode debugar sem ferramentas

3. Flexibilidade

   • Você pode criar soluções customizadas
   • Você não depende de frameworks
   • Você entende trade-offs

Vantagens do Aprendizado Moderno

1. Produtividade

   • Você entrega valor rápido
   • Você foca no negócio, não em infraestrutura
   • Você usa melhores práticas já validadas

2. Manutenibilidade

   • Código mais limpo e organizado
   • Padrões consistentes
   • Fácil de entender para outros desenvolvedores

3. Evolução

   • Você usa tecnologias modernas
   • Você segue tendências do mercado
   • Você está preparado para o futuro

⚠️ O Problema: Profissionais Incompletos?

O Risco do Aprendizado Apenas com Spring

Cenário comum hoje:

• Desenvolvedor aprende Spring Boot
• Cria APIs REST facilmente
• Usa JPA sem entender SQL
• Usa anotações sem saber o que fazem
• Problema: Quando algo quebra, não sabe o que fazer

Exemplo real:

@Transactional
public void transferMoney(Long from, Long to, BigDecimal amount) {
    Account accountFrom = repository.findById(from).get();
    Account accountTo = repository.findById(to).get();
    
    accountFrom.debit(amount);
    accountTo.credit(amount);
    
    repository.save(accountFrom);
    repository.save(accountTo);
}

Pergunta: O que acontece se accountTo não existir?

• Com Spring: Pode funcionar "por acaso" ou quebrar de forma estranha
• Sem entender transações: Você não sabe quando commit acontece
• Sem entender JPA: Você não sabe quando queries são executadas

Resultado: Código que funciona "na maioria das vezes", mas quebra em produção de forma inesperada.

🎓 Como Ser um Profissional Completo?

1. Aprenda os Fundamentos Primeiro

Antes de Spring Boot, aprenda:

• ✅ Core Java (classes, objetos, herança)
• ✅ Collections (como funcionam internamente)
• ✅ Threads (programação concorrente)
• ✅ I/O (streams, files)
• ✅ JDBC (conexão com banco manual)
• ✅ HTTP (como funciona request/response)

Por quê?

• Quando Spring faz "mágica", você entende o que está acontecendo
• Quando algo quebra, você sabe onde procurar
• Quando precisa customizar, você sabe como fazer

2. Entenda o que Spring Faz Por Você

Não aceite "mágica" sem entender:

@Autowired
private UserService userService;

O que acontece aqui?

1. Spring cria uma instância de UserService
2. Spring injeta dependências (se houver)
3. Spring gerencia o ciclo de vida
4. Spring pode criar proxy para transações

Você deveria saber:

• Como injeção de dependência funciona
• O que é um proxy
• Quando objetos são criados
• Como Spring resolve dependências

3. Faça Projetos Sem Framework

Exercício prático:

1. Crie uma API REST sem Spring
2. Use apenas Servlets e JDBC
3. Faça tudo manualmente
4. Depois, refatore para Spring Boot

Resultado:

• Você entende o que Spring faz
• Você valoriza o que Spring oferece
• Você sabe quando NÃO usar Spring

4. Leia o Código Fonte

Quando usar uma anotação, leia a implementação:

• @Transactional: Como funciona?
• @Autowired: Como resolve dependências?
• @RestController: O que faz diferente de @Controller?

Ferramentas:

• IDE: "Go to Declaration"
• GitHub: Código fonte do Spring
• Documentação: Explicações técnicas

🏗️ Aplicação no Desafio das Águias

Como isso se aplica ao projeto:

O que eu fiz:

1. Aprendi Core Java primeiro (anos atrás)
2. Entendi fundamentos antes de usar Spring
3. Aplico conhecimento em cada implementação

Exemplo: Error Handling

Sem entender HTTP:

• Você não saberia que 400 é diferente de 500
• Você não entenderia status codes
• Você não saberia como estruturar respostas

Com fundamentos:

• Você entende o protocolo HTTP
• Você sabe quando usar cada status code
• Você cria respostas consistentes

Exemplo: CORS

Sem entender navegadores:

• Você não saberia por que CORS existe
• Você não entenderia preflight requests
• Você não saberia como configurar corretamente

Com fundamentos:

• Você entende Same-Origin Policy
• Você sabe como navegadores funcionam
• Você configura CORS de forma segura

💬 Pergunta para Você

Como você aprendeu Java?

• Começou com Core Java ou direto com Spring?
• Você entende o que Spring faz por você?
• Você já fez um projeto sem framework?

E a questão mais importante:

• Você se sente um profissional completo?
• O que você faria diferente se pudesse voltar no tempo?

Compartilhe sua jornada nos comentários! 👇

🧠 Insight Principal

"Aprender apenas com Spring é como aprender a dirigir sem entender o motor: você chega ao destino, mas não sabe o que fazer quando o carro quebra."

Por quê isso importa?

1. Fundamentos são para sempre

   • Frameworks mudam, fundamentos não
   • Java core é a base de tudo
   • Entender fundamentos te torna flexível

2. Debugging profundo

   • Quando Spring quebra, você precisa entender o que está acontecendo
   • Stack traces complexos exigem conhecimento de fundamentos
   • Problemas de produção raramente são "mágica do Spring"

3. Profissional completo

   • Você pode trabalhar com ou sem framework
   • Você entende trade-offs
   • Você pode criar soluções customizadas

📈 Resultados Reais

Minha experiência:

• Aprendi Core Java primeiro (2008-2010)
• Fiz projetos sem framework (Servlets, JDBC manual)
• Depois aprendi Spring (2012+)
• Resultado: Entendo o que Spring faz, posso debugar profundamente, posso criar soluções customizadas

Se tivesse aprendido só Spring:

• ❌ Não entenderia como HTTP funciona
• ❌ Não saberia debugar problemas profundos
• ❌ Dependeria de frameworks para tudo
• ❌ Não poderia criar soluções customizadas

🎓 Lições Aprendidas

✅ O que funcionou bem

• Aprender fundamentos primeiro: Base sólida para tudo
• Fazer projetos sem framework: Entender o que frameworks fazem
• Ler código fonte: Entender implementações
• Aplicar conhecimento: Usar fundamentos em projetos reais

⚠️ Desafios e soluções

• Desafio: Aprendizado leva mais tempo

  • Solução: Vale a pena, você se torna profissional completo

• Desafio: Pode parecer "desatualizado"

  • Solução: Fundamentos nunca ficam desatualizados

• Desafio: Muitos tutoriais pulam fundamentos

  • Solução: Buscar recursos que ensinam fundamentos primeiro

📚 Recursos para Aprender Fundamentos

Core Java

• Oracle Java Tutorials: https://docs.oracle.com/javase/tutorial/
• Effective Java (Joshua Bloch)
• Java: The Complete Reference

Sem Framework

• Criar API REST com Servlets
• Conexão com banco usando JDBC puro
• Programação de rede com Sockets

Entender Spring

• Spring Framework Documentation
• Spring Source Code (GitHub)
• "Spring in Action" (livro)

🔗 Links

• Repositório: https://github.com/adelmonsouza/30DiasJava-Day23-LearningEvolution
• Artigo completo: https://enouveau.io/blog/2025/11/23/java-learning-evolution.html

Next episode → Day 24/30 — Testing Strategies & Quality Assurance