Aulas

Como criar objetos e manipular classes em tempo de execução: por que Class.newInstance() ficou obsoleto, como usar corretamente getConstructor/ getDeclaredConstructor e Constructor.newInstance, invocar métodos via Method.invoke e ler/alterar campos via Field. Vamos analisar exceções típicas ( ReflectiveOperationException e outras), restrições do sistema de módulos, boas práticas e um miniutilitário para instanciação dinâmica. Além disso — um esquema visual de todo o processo.

Nesta aula, analisamos a prática de reflexão em Java: como, por meio de Class, Field e Method, ler campos privados ( setAccessible( true)) e montar um serializador simples; como contêineres de DI injetam dependências por anotações ( @Inject, @Autowired) via construtores e campos; como proxies dinâmicos baseados em Proxy e InvocationHandler interceptam chamadas; onde isso é aplicado na prática ( Spring, JUnit, Jackson) e quais limitações e erros ocorrem.

Por que os aplicativos precisam de logs e por que apenas System.out.println não resolve em produção. Vamos analisar os níveis ERROR/ WARN/ INFO/ DEBUG/ TRACE, a pilha embutida java.util.logging e o arquivo de configuração logging.properties, conhecer Log4j 2, Logback e a fachada SLF4J. Vamos comparar com a saída no console, adicionar dependências e examinar erros típicos de configuração e de uso.

Analisamos do que é composta uma boa mensagem de log (hora, nível INFO/ ERROR, nome do logger, texto, stack trace), como formatar corretamente as entradas usando templates do SLF4J/Log4j2 ( "{}" em vez de concatenação), como registrar exceções ( logger.error(..., ex)), quando usar os níveis ERROR/ WARN/ INFO/ DEBUG/ TRACE, além de melhores práticas: sem dados sensíveis, mensagens claras, IDs de correlação ( orderId, userId) e configuração adequada do log4j2.xml.

Como tornar os logs confiáveis em multithread e na web: segurança de threads das bibliotecas prontas ( Logback, Log4j 2, java.util.logging), contexto MDC com propagação de requestId, integração com filtros do Spring e handlers de erro, diferença em relação a System.out, nuances de pools de threads e tracing em microsserviços (traceId, OpenTelemetry). Analisamos exemplos práticos e erros comuns, usando SLF4J e Logger como campo static final.

Esta aula é um guia prático de monitoramento da JVM: como ler métricas padrão via JMX e JConsole, como observar visualmente a memória, as threads e fazer perfilamento de métodos no VisualVM (incluindo heap dump e thread dump), bem como como gravar a “caixa‑preta” com Java Flight Recorder e analisá‑la no JDK Mission Control. Vamos mostrar os comandos de inicialização ( -XX:StartFlightRecording), revisar cenários típicos de análise de GC/threads e erros comuns.

Vamos entender em que o perfilamento difere do monitoramento, quais métricas importam (tempo de execução de métodos, memória, threads, bloqueios) e quais ferramentas usar: VisualVM, Java Flight Recorder, além de profilers comerciais. Na prática, investigamos um “calculador lento”, aprendemos a encontrar “hot spots”, analisar heap dump e eliminar gargalos substituindo algoritmos, reduzindo alocações e aplicando cache. Encerramos com um diagrama visual do processo de otimização e uma análise de erros típicos.

Para onde vão as variáveis locais, os objetos e os metadados de classes em um processo da JVM: vamos dissecar a pilha das threads, o heap e a evolução de PermGen → MetaSpace. Vamos falar sobre como funciona o GC, quais são os erros de memória ( StackOverflowError, OutOfMemoryError) e como os flags de inicialização ( -Xss, -Xmx, -XX:MaxMetaspaceSize) influenciam. Esquemas, diagrama mermaid e um exemplo funcional acompanham.

Nesta aula, analisamos como funciona o coletor de lixo ( GC) na JVM, em que os clássicos Serial/ Parallel/ CMS diferem dos modernos G1, ZGC e Shenandoah, o que são as gerações jovem e antiga, por que ocorrem pausas Stop-the-World e como minimizá-las. Na prática, veremos como ativar coletores diferentes por flags ( -XX:+UseG1GC, -XX:+UseZGC, -XX:+UseShenandoahGC), ajustar pausas ( -XX:MaxGCPauseMillis) e o tamanho do heap ( -Xms/ -Xmx), ler logs ( -Xlog:gc*) e evitar erros comuns (por exemplo, chamar System.gc() explicitamente).

Nesta aula você vai aprender onde vivem as variáveis locais (a pilha da thread) e como ela difere do heap, por que em Java ainda são possíveis vazamentos de memória apesar do GC e como evitá-los. Vamos analisar cenários reais: “eternas” static-coleções, listeners não removidos e caches. Vamos conhecer a família de referências: SoftReference, WeakReference, PhantomReference, bem como o contêiner WeakHashMap. Vamos praticar corrigir vazamentos e discutir por que chamar System.gc() — é apenas uma dica para a JVM, não uma ordem, e como pode terminar em OutOfMemoryError.

Guia prático para diagnosticar problemas de memória na JVM: capturamos um instantâneo da heap ( heap dump) com a ferramenta jmap, lemos os resumos via -heap e -histo, investigamos o aplicativo no jvisualvm (abas Monitor, Heap Dump, Threads, Profiler), analisamos um vazamento em um exemplo e conhecemos o Eclipse MAT e o jconsole. No final — erros comuns e dicas.

Análise prática de por que um aplicativo Java pode “vazar” memória e ficar lento: ouvintes esquecidos ( addActionListener/ removeActionListener), coleções estáticas eternas, recursos não fechados (dica: try-with-resources), classes anônimas/internas que retêm referências e abuso de System.gc(). Vamos aprender a ler logs do GC ( -Xlog:gc*, -XX:+PrintGCDetails), escolher o coletor, construir caches com WeakHashMap, monitorar ( jvisualvm, jconsole), analisar heap dump e configurar corretamente -Xmx/ -Xms. No final — exemplos reais de vazamentos e suas correções.