Java Avanzado: Guía Completa

5 minuto(s)

En esta página:

Aprender cosas avanzadas acerca del lenguaje de programación Java nos ayuda a dar un salto profesional y escalar en nuestra carrera.

Esta guía cubre temas de Java avanzado, desde internals de la JVM y concurrencia hasta optimización, patrones, pruebas y despliegue.

Incluye ejemplos listos para copiar y respuestas a preguntas frecuentes.

1. Entendiendo la JVM y el ciclo de vida

La JVM ejecuta bytecode generado por el compilador javac.

Conceptos clave:

Class loader: carga clases (bootstrap, platform, application y custom loaders).
Bytecode: el formato que interpreta la JVM.
JIT (Just-In-Time): compila métodos calientes a código nativo para rendimiento.
AOT (Ahead-Of-Time) en algunos entornos (ej. GraalVM native-image).

Comando básico para ejecutar con parámetros de JVM:


java -Xms512m -Xmx2g -XX:+UseG1GC -jar app.jar

java -Xms512m -Xmx2g -XX:+UseG1GC -jar app.jar

En la siguiente imagen puedes apreciar de forma estandar el ciclo de vida de la JVM (Java Virtual Machine) o Máquina Virtual de Java:

2. Memoria, heap, stack y Garbage Collector

Estructura de memoria:

Heap: objetos; dividido en young (eden + survivor) y old generation.
Stack: frames por método, variables locales y control de ejecución.
Metaspace: metadata de clases (reemplaza PermGen).

GCs importantes hoy:

G1: buen equilibrio; pausas predecibles.
Parallel: alto throughput.
ZGC y Shenandoah: pausas muy bajas para heaps grandes.

Cómo recolectar información de GC:


java -Xlog:gc*:file=gc.log:time -jar app.jar

java -Xlog:gc*:file=gc.log:time -jar app.jar

Consejo: primero mide con un profiler antes de tocar -Xmx/-Xms o cambiar GC.

3. Concurrencia y paralelismo

Conceptos imprescindibles:

Thread vs Task: usa ExecutorService para tareas.
SINCRONIZACIÓN: synchronized, ReentrantLock, volatile.
Concurrent Collections: ConcurrentHashMap, CopyOnWriteArrayList.
CompletableFuture y programación asíncrona.
Fork/Join y parallelStream() para tareas divididas.

Ejemplo: CompletableFuture


import java.util.concurrent.*;

CompletableFuture.supplyAsync(() -> heavyCalculation())
  .thenCompose(result -> CompletableFuture.supplyAsync(() -> nextStep(result)))
  .thenAccept(finalResult -> System.out.println(finalResult))
  .exceptionally(ex -> { ex.printStackTrace(); return null; });

import java.util.concurrent.*;

CompletableFuture.supplyAsync(() -> heavyCalculation())

.thenCompose(result -> CompletableFuture.supplyAsync(() -> nextStep(result)))

.thenAccept(finalResult -> System.out.println(finalResult))

.exceptionally(ex -> { ex.printStackTrace(); return null; });

Buenas prácticas

Sigue estas buenas practicas al trabajar con concurrencias y paralelismo:

Evitar bloqueo global; preferir diseños lock-free cuando sea posible.
No crear threads a mano en producción.
Dimensionar pools según la naturaleza: CPU-bound vs IO-bound.
Usar timeouts y circuit breakers (ej. Resilience4j) en IO/servicios externos.

4. Patrones de diseño y buenas prácticas

Cuando trabajas en Java avanzado considera:

Factory / Builder — para construcción compleja de objetos.
Singleton — usar enums o mecanismos thread-safe.
Strategy / Command — para comportamientos intercambiables.
Decorator — para añadir comportamiento dinámico.
Observer / Event Bus — comunicación desacoplada.

Principios SOLID y KISS: imprescindibles para código mantenible.

5. Generics, Streams y APIs funcionales

Generics advance: wildcards (?), bounded types, tipo y covarianza/contravarianza.


// Ejemplo de uso de wildcards
List<? extends Number> nums = List.of(1, 2.5); // lectura segura
List<? super Integer> integers = new ArrayList<>(); // escritura segura

// Ejemplo de uso de wildcards

List<? extends Number> nums = List.of(1, 2.5); // lectura segura

List<? super Integer> integers = new ArrayList<>(); // escritura segura

Streams: no mutar estado, preferir operaciones sin efectos secundarios.


List<String> names = people.stream()
  .filter(p -> p.getAge() >= 18) 
  .map(Person::getName) 
  .sorted() 
  .collect(Collectors.toList());

List<String> names = people.stream()

.filter(p -> p.getAge() >= 18)

.map(Person::getName)

.sorted()

.collect(Collectors.toList());

Optional: usar para evitar null, pero no abusar (no usar Optional como campo en entidades JPA).

6. Modularidad y empaquetado

Java Modules (JPMS): module-info.java permite declarar dependencias y encapsulación a nivel de módulo. Útil para aplicaciones grandes y reducidas imágenes JLINK.


module com.example.app {
  requires java.sql;
  exports com.example.app.api;
}

module com.example.app {

requires java.sql;

exports com.example.app.api;

}

Alternativas: usar contenedores y empaquetado tradicional (fat-jar/uber-jar) si JPMS complica integración con frameworks.

7. Spring y microservicios

Es importante que conoscas los siguientes conceptos de Java en el área de microservicios y el ecosistema de Spring:

Spring Boot: auto-configuración, starters, perfiles.
Spring Data: repositorios y pagination.
Spring Security: JWT, OAuth2, roles y CSRF.
Spring Cloud: configuración distribuida, discovery, circuit breaker.

Ejemplo simple controller


@RestController
@RequestMapping("/api")
public class MyController {
  @GetMapping("/hello")
  public ResponseEntity&lt;String&gt; hello() { return ResponseEntity.ok("Hola"); }
}

@RestController

@RequestMapping("/api")

public class MyController {

@GetMapping("/hello")

public ResponseEntity<String> hello() { return ResponseEntity.ok("Hola"); }

}

Microservicios: diseñar bounded contexts, APIs contract-first (OpenAPI), observability (tracing + metrics).

8. Rendimiento: profiling, benchmarking y tuning

Herramientas imprescindibles:

JMH — benchmarking correcto y reproducible.
VisualVM / Java Mission Control / Flight Recorder — profiling y análisis de heap/CPU.
async-profiler — perfiles de CPU y contention.

Consejos de tuning:

Medir antes de optimizar (profiling).
Evitar micro-optimización prematura; identificar hotspots.
Preferir algoritmos y estructuras de datos correctas (ej. ArrayList vs LinkedList).
Reducir allocations cuando el GC es cuello de botella.

Ejemplo: benchmark con JMH (plantilla básica)


import org.openjdk.jmh.annotations.*;

@State(Scope.Thread)
public class MyBenchmark {
  @Benchmark
  public void testMethod() { /* trabajo a medir */ }
}

import org.openjdk.jmh.annotations.*;

@State(Scope.Thread)

public class MyBenchmark {

@Benchmark

public void testMethod() { /* trabajo a medir */ }

}

9. Testing avanzado

Técnicas y herramientas:

Unit tests: JUnit 5 + Mockito.
Integration tests: Spring Test, Testcontainers para dependencias reales (DB, Kafka).
Contract tests: Pact o Spring Cloud Contract para garantizar contratos entre servicios.
Property-based testing: jqwik, junit-quickcheck.
Mutation testing: PIT para validar la calidad de las pruebas.

Ejemplo JUnit 5 + Mockito:


@ExtendWith(MockitoExtension.class)
class ServiceTest {
  @Mock Repo repo;
  @InjectMocks Service service;

  @Test
  void testSomething() {
    when(repo.find()).thenReturn(...);
    assertEquals(..., service.doWork());
  }
}

@ExtendWith(MockitoExtension.class)

class ServiceTest {

@Mock Repo repo;

@InjectMocks Service service;

@Test

void testSomething() {

when(repo.find()).thenReturn(...);

assertEquals(..., service.doWork());

}

10. DevOps, contenedores y despliegue

Recomendaciones prácticas:

Construir imágenes pequeñas: multi-stage Docker builds, usar distroless o JRE minimal.
Configuración por entorno: variables de entorno, Spring Cloud Config o Vault.
CI/CD: pipelines (GitHub Actions, GitLab CI, Jenkins) que ejecuten tests, linters y escaneos de seguridad.
Observability: métricas (Prometheus), logs estructurados (JSON + ELK/EFK) y tracing (OpenTelemetry).

Ejemplo Dockerfile básico:


FROM eclipse-temurin:17-jdk AS build
WORKDIR /app
COPY . .
RUN ./mvnw -DskipTests package

FROM eclipse-temurin:17-jre
COPY --from=build /app/target/app.jar /app/app.jar
ENTRYPOINT ["java","-jar","/app/app.jar"]

FROM eclipse-temurin:17-jdk AS build

WORKDIR /app

COPY . .

RUN ./mvnw -DskipTests package

FROM eclipse-temurin:17-jre

COPY --from=build /app/target/app.jar /app/app.jar

ENTRYPOINT ["java","-jar","/app/app.jar"]

11. Seguridad y mejores prácticas

Sigue las siguientes buenas practicas de seguridad:

Evitar inyección: usar prepared statements, evitar concatenar SQL.
Validar y sanear entrada del usuario.
Controlar dependencias (dependabot, OWASP Dependency Check).
Manejo de secretos: no subir claves a repositorios; usar Vault o secretos del cloud.
Configuración de CORS, rate limiting y protección contra CSRF en aplicaciones web.

12. Interoperabilidad y otros lenguajes JVM

Kotlin, Scala y Groovy son comunes en el ecosistema JVM. Ventajas de Kotlin: interoperabilidad total con Java, sintaxis concisa y coroutines para concurrencia.

GraalVM: permite compilar a binario nativo (start-up más rápido, menor memoria), útil para CLI o microservicios con cold-start sensibles.

13. Novedades del lenguaje (features modernas)

Java agrega características en cada nueva versión, a continuación algunas de ellas:

Records — clases inmutables ligeras para datos.
Sealed classes — control de jerarquía de tipos.
Pattern matching para instanceof y switch (mejora legibilidad).
Mejoras en switch, text blocks y inferencia local con var.


public record Person(String name, int age) {
  //
}

public record Person(String name, int age) {

}

En sus nuevas versiones veremos otras nuevas características.

14. Consejos prácticos y checklist antes de producción

Antes de pasar tu proyecto a producción considera los siguientes consejos:

Revisar métricas y alertas: establecer SLOs/SLAs.
Perf tests en entorno parecido a producción.
Configurar backups y estrategias de rollback.
Automatizar despliegue e infra como código (Terraform, Pulumi).
Revisiones de seguridad y dependencias.

15. Recursos recomendados

Para complementar tu aprendizaje considera los siguientes libros y recursos:

Los 5 Mejores Libros de Java en Español (Blog de Nube Colectiva)
Documentación oficial de OpenJDK y Oracle JDK.
Libros clásicos: Java Concurrency in Practice, Effective Java (Joshua Bloch).
Herramientas: JMH, VisualVM, JFR, JProfiler, async-profiler, Testcontainers, JUnit 5.
Comunidades: foros, StackOverflow, blogs de ingeniería de grandes empresas.

16. Preguntas frecuentes

Para despejar tus dudas:

¿Cuándo debo preocuparme por GC?

Cuando ves pausas largas, alta latencia o uso excesivo de CPU por GC. Perfil y cambia estrategia si es necesario.

¿Usar microservicios o monolito?

Empieza por un monolito modular si el equipo es pequeño. Pasa a microservicios cuando tengas límites claros entre dominios, necesidad de escalado independiente o equipos distribuidos.

¿Cómo medir rendimiento real?

Perf tests (JMH para micro-benchmarks, pruebas de carga para end-to-end), profiling y observability en producción (JFR, traces, metrics).

¿Es Kotlin mejor que Java?

Kotlin ofrece sintaxis moderna y concisa; la elección depende del equipo, la interoperabilidad y los requisitos del proyecto. Muchas empresas usan ambos.

¿Qué JVM elegir?

Todas son compatibles con bytecode, pero distribuciones como Eclipse Temurin, Microsoft Build of OpenJDK o Oracle tienen diferencias en soporte, licencias y builds. Elige según SLA y soporte que necesites.