Java

Fundamentos del Lenguaje Java

  • Lenguaje orientado a objetos multiplataforma, basado en la JVM (Java Virtual Machine).
  • Código fuente → compilado con javac → genera bytecode (.class) → ejecutado por la JVM.
  • Componentes principales:
    • JDK (Java Development Kit): herramientas de desarrollo.
    • JRE (Java Runtime Environment): entorno de ejecución.
    • JVM: ejecuta bytecode, garantiza portabilidad (“Write once, run anywhere”).
  • Comandos esenciales:
    • javac Main.java → compila a Main.class
    • java Main → ejecuta el programa
    • Estructura típica:
      • cd src
      • java com.amigoscode.Main
      • cd com/amigoscode
      • rm Main.class
    • Organización mediante packages.
  • Versiones LTS recomendadas: Java 11, 17, 21.
  • IDE recomendados: IntelliJ IDEA, Eclipse, VSCode.

Arquitectura y Ecosistema

  • Java SE (Standard Edition): API base, colecciones, POO, I/O, networking, generics, streams, lambdas.
  • Java EE (Jakarta EE): Servlets, JSP, JSF, JPA, EJB, CDI, Web Services.
  • Java ME: Edición para dispositivos móviles/embebidos.
  • JDK y JVMs populares: OpenJDK, Amazon Corretto, Azul Zulu, GraalVM.

Programación Orientada a Objetos (POO)

  • Principios: Encapsulación, Herencia, Polimorfismo, Abstracción.
  • Clases, objetos, interfaces y herencia múltiple mediante interfaces.
  • Conceptos clave:
    • Constructores, getters/setters
    • Clases abstractas e interfaces
    • Modificadores de acceso: public, protected, private, default
    • Polimorfismo: sobrecarga y sobrescritura
    • Relaciones UML: asociación, agregación, composición

Programación Funcional y Modern Java

  • Lambdas (()->{}) y Streams API para manipulación funcional de datos.
  • Optional<T>: evita NullPointerException.
  • Generics: seguridad de tipos en colecciones y métodos.
  • Wildcards: <?>`, `extends`, `super`.
  • Expresiones comunes:
    • list.stream().filter(x -> x > 10).collect(Collectors.toList());
    • Optional.ofNullable(value).orElse(defaultValue);
  • Threads y Concurrencia:
    • Runnable, Callable, ExecutorService
    • API moderna: CompletableFuture, Virtual Threads (desde Java 21 - Project Loom)

Colecciones y Tipos de Datos

  • Colecciones principales: List, Set, Map, Queue, Stack.
  • Implementaciones comunes: ArrayList, HashMap, LinkedList, TreeMap, HashSet.
  • Streams: operaciones intermedias (map, filter, sorted) y terminales (collect, forEach).

Herramientas y Build Systems

  • Automatizacion y Build
  • Conceptos clave:
    • pom.xml (Maven), build.gradle (Gradle)
    • Dependencias, repositorios, perfiles, plugins
    • Ejecución de tests automatizados

Frameworks y Desarrollo Web con Java

  • Desarrollo web
  • Backend:
    • Springboot, Spring MVC, hibernate, JPA
    • Arquitectura multicapa: Controlador → Servicio → Repositorio
    • DTO (Data Transfer Object) y DAO (Data Access Object)
  • Frontend Java:
  • Microservicios:
    • Comunicación mediante REST o gRPC
    • Herramientas: Feign, Eureka (Service Registry), Config Server, Gateway, Circuit Breaker
    • Monolitos vs microservicios
  • J2EE y java EE (Jakarta EE)
  • JHipster y yeoman para scaffolding de proyectos.

Seguridad en Java

  • Autenticación y autorización: Spring Security, JWT, OAuth2, Keycloak.
  • Cifrado con javax.crypto o java.security.
  • Buenas prácticas:
    • No exponer contraseñas en código.
    • Usar HTTPS y certificados.
    • Validar entrada de usuario.

Testing y Calidad del Código

  • Testing
    • JUnit: testing unitario.
    • JMeter: pruebas de rendimiento.
    • Mockito: mocks y stubs.
  • Tipos de pruebas:
    • Unitarias, integración, end-to-end.
    • Cobertura de código con Jacoco.
    • CI/CD con GitHub Actions, Jenkins o GitLab.

Persistencia y Bases de Datos

  • Databases
  • hibernate y JPA:
    • ORM (Object-Relational Mapping)
    • Anotaciones: @Entity, @Table, @Id, @GeneratedValue
    • Relaciones: @OneToMany, @ManyToOne, @ManyToMany
    • Consultas JPQL o Criteria API.
  • Conexiones: JDBC, Connection Pool (HikariCP)

Java en Contenedores y Cloud

Servicios Web y APIs

  • JAX-WS: Servicios SOAP.
  • swagger: Documentación automática de APIs REST.
  • Spring Boot REST:
    • @RestController, @GetMapping, @PostMapping.
    • Serialización con Jackson (@JsonProperty, @JsonIgnore).

Documentación y Recursos Oficiales

Ejercicios, Casos y Pruebas Técnicas

Material Histórico y Cursos

Enlaces y Herramientas Adicionales

Java Avanzado y Ecosistema 2025

Nota complementaria a Java — expansión de temas intermedios y avanzados del lenguaje, entorno y ecosistema Java actual.

🧩 Modularidad en Java

  • Sistema de módulos (Java 9+): define dependencias explícitas con module-info.java.
  • Controla visibilidad de paquetes con exports y dependencias con requires.
  • Permite crear aplicaciones más ligeras, seguras y mantenibles.
  • Buenas prácticas:
    • No exportar todo el código público.
    • Modularizar librerías comunes y definir APIs claras.

🔍 Reflexión y Anotaciones

  • Reflexión: inspección y manipulación de clases en tiempo de ejecución (java.lang.reflect).
  • Anotaciones: metadatos que guían compiladores o frameworks (@Override, @Inject, @Entity, etc.).
  • Usos comunes:
    • Inyección de dependencias (Spring, CDI)
    • Serialización dinámica (Jackson, Gson)
    • Testing (JUnit, Mockito)
  • Precaución: la reflexión puede degradar el rendimiento y violar encapsulamiento.

♻️ Memoria, Garbage Collection y Rendimiento

  • Gestión automática pero no mágica:
    • Heap: memoria de objetos.
    • Stack: variables locales y llamadas.
    • Generaciones: joven, vieja, survivor.
  • Recolección moderna:
    • G1 (por defecto), ZGC y Shenandoah para baja latencia.
  • Consejos:
    • Evitar referencias estáticas innecesarias.
    • Usar try-with-resources y AutoCloseable.
    • Monitorizar con jvisualvm, JConsole, Java Mission Control.

⚙️ Concurrencia y Paralelismo

  • API moderna: ExecutorService, CompletableFuture, ForkJoinPool.
  • Virtual Threads (Java 21) → hilos ligeros del Project Loom.
  • Recomendaciones:
    • Minimizar estado compartido.
    • Usar estructuras concurrentes (ConcurrentHashMap, CopyOnWriteArrayList).
    • Evitar deadlocks y bloqueos innecesarios.

🧱 Diseño, Patrones y Arquitectura

  • Patrones clásicos: Singleton, Factory, Builder, Strategy, Observer.
  • Principios: SOLID, DRY, KISS, YAGNI.
  • Estructura de aplicación por capas:
    1. Presentación
    2. Negocio/Dominio
    3. Persistencia
  • DTOs, eventos, repositorios → separación limpia de responsabilidades.

🔐 Seguridad y Criptografía

  • APIs principales: java.security, javax.crypto.
  • Cifrado, firmas digitales, generación de claves.
  • Autenticación y autorización moderna: JWT, OAuth2, OpenID Connect.
  • Buenas prácticas:
    • Validar toda entrada externa.
    • Evitar deserialización insegura.
    • Habilitar HTTPS y certificados válidos.
    • Integración con Spring Security o frameworks equivalentes.

🌍 Internacionalización y Localización

  • Clases clave: Locale, ResourceBundle, DateTimeFormatter.
  • Evita hardcodear texto → usa ficheros .properties.
  • Soporte Unicode completo.
  • Accesibilidad: adaptar formatos de fecha, moneda y texto dinámicamente.

🚀 Novedades del Lenguaje y Futuro

  • JEP (JDK Enhancement Proposals) → seguimiento de mejoras oficiales.
  • Novedades recientes:
    • record, sealed classes, switch expressions, pattern matching.
  • Proyectos en curso:
    • Valhalla → tipos de valor.
    • Loom → concurrencia ligera.
    • Amber → simplificación de sintaxis.
  • Mantente al día con las versiones LTS (Java 17, 21, 25).

🧪 Testing, CI/CD y DevOps

  • Frameworks: JUnit 5, Mockito, Testcontainers.
  • Calidad: SonarQube, Checkstyle, JaCoCo.
  • CI/CD: GitHub Actions, Jenkins, GitLab CI.
  • Pruebas de carga y seguridad automatizadas.
  • Integración en pipelines Docker/Kubernetes.

📡 Integración y Sistemas Distribuidos

  • Mensajería: JMS, Kafka, RabbitMQ.
  • APIs remotas: REST, gRPC, GraphQL.
  • Patrones de resiliencia: Circuit Breaker, Retry, Bulkhead.
  • Observabilidad:
    • Logs: SLF4J, Logback.
    • Métricas: Micrometer, Prometheus.
    • Trazas distribuidas: OpenTelemetry.

🖥️ Interfaces gráficas y Aplicaciones Desktop

  • JavaFX como sucesor moderno de Swing.
  • CSS y FXML para UI declarativa.
  • Integración con hardware o sistemas embebidos.
  • JavaFX → buena opción para herramientas internas o educativas.

🧰 Ecosistema y Herramientas Populares

  • Librerías útiles:
    • Lombok → menos boilerplate.
    • MapStruct → mapeo automático de DTOs.
    • Guava / Apache Commons → utilidades ampliadas.
    • Flyway / Liquibase → migración de bases de datos.
  • Versionado y dependencias:
    • Mantener control de licencias (MIT, Apache 2.0, etc.)
    • Modularizar dependencias para compilaciones rápidas.

🔗 Enlaces relacionados

  • Java
  • Spring Framework
  • Spring Boot
  • Jakarta EE
  • Testing en Java
  • DevOps con Java y Docker
  • Arquitectura de microservicios

Resumen:
Esta nota amplía tu visión del ecosistema Java, tocando áreas de rendimiento, seguridad, modularidad, concurrencia moderna y prácticas de ingeniería. Ideal para desarrolladores que ya dominan la base y quieren evolucionar hacia arquitecturas robustas, distribuidas y sostenibles.

Fundamentos Internos de Java y la JVM

Tercera nota complementaria a Java — centrada en los fundamentos técnicos del lenguaje y la máquina virtual (JVM), profundizando en cómo Java ejecuta, compila y gestiona los programas.

🧠 Arquitectura Interna de Java

  • Java Platform Components:
    • JDK (Java Development Kit) → compilador (javac), herramientas y bibliotecas.
    • JRE (Java Runtime Environment) → librerías + JVM.
    • JVM (Java Virtual Machine) → ejecuta bytecode, gestiona memoria y seguridad.
  • Proceso de ejecución:
    1. Código fuente .java
    2. Compilación → bytecode .class
    3. Carga en JVM → ejecución optimizada por el JIT (Just-In-Time Compiler)

🔩 JVM y Bytecode

  • Bytecode: formato intermedio multiplataforma ejecutado por la JVM.
  • Inspección con herramientas:
    • javap -c Main.class
    • Desensamblado para entender el flujo real de instrucciones.
  • Classloaders:
    • Bootstrap → carga clases del núcleo.
    • Extension → carga librerías estándar.
    • Application → carga clases del usuario.
    • Custom → permite crear cargadores propios (plugins, frameworks).

⚙️ JIT Compilation y HotSpot

  • HotSpot JVM analiza el código en ejecución y optimiza las partes más usadas.
  • Tiered Compilation:
    • Interpreter → rápido inicio.
    • C1 / C2 JIT compilers → optimización progresiva.
  • GraavVM (alternativa moderna):
    • Compilación AOT (Ahead-of-Time).
    • Soporte multilenguaje (Java, Kotlin, JS, Python, etc.).
    • Ideal para microservicios ligeros.

🧮 Gestión de Memoria

  • Heap Memory:
    • Espacio donde viven los objetos.
    • Dividido en generaciones: Young, Old, Survivor.
  • Stack Memory:
    • Almacena variables locales y llamadas de métodos.
  • Garbage Collectors modernos:
    • G1GC → predeterminado, equilibrio entre latencia y rendimiento.
    • ZGC / Shenandoah → baja latencia, escalabilidad extrema.
  • Técnicas de optimización:
    • Evitar objetos temporales excesivos.
    • Usar object pooling cuando es viable.
    • Medir con profilers antes de optimizar.

🧭 Ciclo de Vida de una Clase

  1. Carga (Loading) → lectura del .class.
  2. Vinculación (Linking) → verificación, preparación y resolución.
  3. Inicialización (Initialization) → ejecución de bloques static y constructores.
  4. Uso → instancia y métodos disponibles.
  5. Descarga → elegible para GC si no hay referencias activas.

🔐 Seguridad y Sandbox JVM

  • Java mantiene un modelo de seguridad por clases cargadas.
  • Cada ClassLoader impone límites de acceso.
  • SecurityManager (deprecado) → reemplazado por sandboxing y políticas modernas.
  • Firmas digitales en .jar aseguran integridad.
  • En entornos cloud, se usan contenedores o sandboxing nativo.

🧩 Tipos, Generics y Erasure

  • Type Erasure:
    • Los genéricos no existen en tiempo de ejecución.
    • La JVM solo ve tipos base (Object).
  • Wildcards y límites (extends, super) definen flexibilidad y seguridad.
  • Reflection + Generics:
    • Permite inspeccionar los tipos genéricos originales usando ParameterizedType.

🧵 Sincronización Interna

  • Monitores y Locks:
    • Cada objeto tiene un monitor interno.
    • synchronized bloquea acceso concurrente.
  • Problemas comunes:
    • Deadlocks → interbloqueos circulares.
    • Livelocks → procesos activos sin progreso.
  • Alternativas modernas:
    • ReentrantLock, ReadWriteLock, StampedLock.
    • Estructuras no bloqueantes (Atomic, Concurrent).

🔍 Instrumentación y Diagnóstico

  • Herramientas estándar:
    • jconsole, jvisualvm, jstat, jmap, jcmd.
    • Permiten analizar uso de memoria, hilos y rendimiento.
  • Java Flight Recorder (JFR):
    • Perfilador nativo de bajo impacto.
    • Integrado con Java Mission Control (JMC).
  • Instrumentación con agentes:
    • java.lang.instrument → modificar bytecode en tiempo de carga.
    • Usado por frameworks como Spring, Hibernate o agentes APM.

🚀 Compilación AOT y GraalVM Native Image

  • AOT (Ahead-of-Time) → convierte bytecode a binario nativo antes de ejecutar.
  • GraalVM Native Image:
    • Reduce tiempos de arranque (ideal microservicios).
    • Menor consumo de memoria.
    • Requiere configuración de reflexión estática.
  • Uso:
	native-image -jar app.jar
	```


---

## 📚 Enlaces Relacionados

- Java
- Java Avanzado y Ecosistema 2025
- Spring Internals
- Optimización y Profiling JVM
- GraalVM
- [Testing](/testing/testing/)
- Microservicios Java
- Rendimiento y Monitoreo

---

> **Resumen:**  
> Esta nota cierra la base teórica de Java abordando su estructura interna, ejecución, memoria y compilación. Es esencial para comprender cómo el código Java se transforma, se ejecuta y se optimiza dentro de la JVM, permitiendo desarrollar software más eficiente, seguro y predecible.

# Java Práctico y Patrones de Uso

> Nota complementaria a Java y Fundamentos Internos de Java y la JVM centrada en la práctica moderna del lenguaje, patrones, sintaxis actualizada (Java 17–21–23 LTS), y consejos de desarrollo profesional.

---

## 🧱 Fundamentos del Lenguaje Moderno

- **Tipos de datos y var**  
	- Desde Java 10: `var nombre = "texto";` → inferencia local de tipos.  
	- Solo dentro de métodos, nunca en campos de clase.  
- **Records (Java 14+)**  
	- Clases inmutables con menos código:
	
```java
	public record Persona(String nombre, int edad) {}
	```

- **Text Blocks (Java 15+)**
	
```java
	String json = """
	{
		"clave": "valor"
	}
	""";
	```


---

## 🧩 Colecciones y Estructuras de Datos

- **List, Set, Map** son interfaces principales.
- Implementaciones comunes:
	- `ArrayList`, `LinkedList`, `HashSet`, `TreeSet`, `HashMap`, `LinkedHashMap`.
- **Ejemplo:**
	
```java
	Map<String, Integer> puntuaciones = new HashMap<>();
	puntuaciones.put("Juan", 10);
	puntuaciones.forEach((k,v) -> System.out.println(k + ": " + v));
	```

- **Streams API** (Java 8+):
	- Procesamiento funcional de colecciones.
	
```java
	List<String> nombres = List.of("Ana", "Luis", "Eva");
	nombres.stream()
		.filter(n -> n.startsWith("E"))
		.map(String::toUpperCase)
		.forEach(System.out::println);
	```


---

## 🔁 Programación Funcional y Lambdas

- **Lambdas** permiten pasar funciones como parámetros:
	
```java
	lista.forEach(e -> System.out.println(e));
	```

- **Interfaces funcionales**:
	- `Predicate<T>`, `Function<T,R>`, `Consumer<T>`, `Supplier<T>`
- **Method References**:
	
```java
	lista.forEach(System.out::println);
	```


---

## 🧵 Concurrencia Moderna

- **Thread y Runnable** → básicos:
	
```java
	new Thread(() -> System.out.println("Hilo!")).start();
	```

- **ExecutorService** → control avanzado:
	
```java
	ExecutorService pool = Executors.newFixedThreadPool(4);
	pool.submit(() -> tarea());
	pool.shutdown();
	```

- **CompletableFuture** (asíncrono):
	
```java
	CompletableFuture.supplyAsync(() -> consultaBD())
		.thenApply(resultado -> procesar(resultado))
		.thenAccept(System.out::println);
	```

- **Virtual Threads (Java 21+)**
	- Ligereza extrema (miles de hilos sin overhead):
	
```java
	try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
		scope.fork(() -> tarea1());
		scope.fork(() -> tarea2());
		scope.join();
	}
	```


---

## 🧰 Manejo de Excepciones

- **Checked vs Unchecked**
	- `IOException` → checked.
	- `RuntimeException` → unchecked.
- **Buenas prácticas**:
	- Evita capturar `Exception` genérico.
	- Lanza excepciones específicas.
	- Usa `try-with-resources`:
	
```java
	try (var reader = new BufferedReader(new FileReader("archivo.txt"))) {
		reader.lines().forEach(System.out::println);
	}
	```


---

## 🧮 Clases, Interfaces y Abstracción

- **Abstract Class vs Interface**:
	- Abstracta: puede tener estado.
	- Interface: contrato puro (ahora con métodos `default` y `static`).
- **Sealed Classes (Java 17+)**
	- Restringen la herencia:
	
```java
	public sealed class Forma permits Circulo, Cuadrado {}
	```


---

## 🧭 Patrones de Diseño Esenciales

- **Singleton**  
	
```java
	public class Conexion {
		private static final Conexion INSTANCIA = new Conexion();
		private Conexion() {}
		public static Conexion getInstancia() { return INSTANCIA; }
	}
	```

- **Factory Method**
	
```java
	interface Creador { Producto crear(); }
	class CreadorConcreto implements Creador {
		public Producto crear() { return new ProductoConcreto(); }
	}
	```

- **Builder**
	
```java
	Persona p = new Persona.Builder().nombre("Juan").edad(30).build();
	```

- **Strategy / Observer / Decorator** → muy comunes en [Springboot](/backend/springboot/) y Java EE.

---

## 🧩 Serialización y JSON

- **Bibliotecas comunes**:
	- `Jackson`, `Gson`, `Json-B` (JEE)
- **Ejemplo con Jackson**:
	
```java
	ObjectMapper mapper = new ObjectMapper();
	String json = mapper.writeValueAsString(objeto);
	Persona persona = mapper.readValue(json, Persona.class);
	```


---

## 🧪 Testing y Buenas Prácticas

- **Unit Testing**: [JUnit](/testing/junit/)
	
```java
	@Test
	void sumaDebeSerCorrecta() {
		assertEquals(4, suma(2,2));
	}
	```

- **Mocks**: Mockito
	
```java
	when(servicio.obtener()).thenReturn(List.of("dato"));
	```

- **Integration Tests**: usan [Springboot](/backend/springboot/) context y [JMeter](/testing/jmeter/).
- **Principios de calidad**:
	- SOLID, DRY, KISS, YAGNI.
	- Cobertura no es igual a calidad → centrarse en *path crítico*.
	- Usa `assertThrows()` y `@Nested` tests para claridad.

---

## 🧮 Entrada/Salida y Archivos

- **NIO.2 (Java 7+)**
	
```java
	Files.walk(Path.of("src"))
		.filter(Files::isRegularFile)
		.forEach(System.out::println);
	```

- **Serialización binaria**
	
```java
	try (var out = new ObjectOutputStream(new FileOutputStream("obj.ser"))) {
		out.writeObject(obj);
	}
	```


---

## 🧰 Herramientas de Productividad

- **Build tools**: Maven, [Gradle](/automatizacion%20y%20build/gradle/)
- **Gestión de versiones**: Git, GitHub Actions, CI/CD.
- **Depuración**:
	- Breakpoints en IntelliJ IDEA o VSCode.
	- Logs con SLF4J + Logback.
- **Code style y linting**:
	- Checkstyle, PMD, SpotBugs.
- **Documentación automática**:
	- Javadoc → `/** descripción */`
	- Integrable con Swagger para APIs.

---

## 🧭 Recomendaciones de Flujo de Aprendizaje

1. Sintaxis y tipos → curso java con codes
2. Colecciones y streams → Java Avanzado y Ecosistema 2025
3. Concurrencia y patrones → esta nota
4. JVM y optimización → Fundamentos Internos de Java y la JVM
5. Frameworks y despliegue → [Springboot](/backend/springboot/), [Docker](/software%20engineering/docker/), Microservicios

---

## 📚 Recursos Prácticos y Referencias

- [Java version history - Wikipedia](https://en.wikipedia.org/wiki/Java_version_history)
- [Effective Java (Joshua Bloch)](https://effectivejava.dev/)
- [Java 23 Documentation](https://docs.oracle.com/en/java/javase/23/)
- [Learn Java Online](https://www.learnjavaonline.org/)
- [Java Pattern Catalog](https://refactoring.guru/design-patterns/java)

---

> **Resumen:**  
> Esta nota se centra en el uso práctico del lenguaje, las técnicas modernas de programación funcional, concurrencia, patrones y testing. Completa el ecosistema Java proporcionando la base aplicada que conecta teoría, frameworks y rendimiento real.


# Java y Arquitectura Empresarial

> Nota complementaria a Java, Java Práctico y Patrones de Uso, y Fundamentos Internos de Java y la JVM centrada en diseño de arquitecturas empresariales modernas, principios de ingeniería, y patrones de integración para proyectos escalables con Java.

---

## 🧱 Estructura por Capas y Módulos

- **Arquitectura Clásica en Capas (N-tier)**:
	1. **Presentación (UI)** – JSP, JSF, Thymeleaf, Angular, React.
	2. **Servicio / Lógica de Negocio** – [Springboot](/backend/springboot/), EJBs, servicios REST.
	3. **Persistencia / Datos** – JPA, Hibernate, JDBC.
	4. **Infraestructura / Configuración** – Maven, [Docker](/software%20engineering/docker/), Seguridad, Logs.
- **Separación de responsabilidades (SRP)**:
	- Evita mezclar lógica de negocio con acceso a datos.
	- Usa interfaces en la capa de servicio para testabilidad.
- **Domain Model Pattern**:
	- Entidades con lógica propia y valor semántico.
	- Evita el “anemic model” (clases con solo getters/setters).

---

## 🧭 Clean Architecture / Hexagonal / DDD

- **Clean Architecture (Uncle Bob)**:
	- Dependencias hacia el centro (dominio puro).
	- Frameworks y detalles técnicos en la periferia.
- **Hexagonal Architecture (Ports & Adapters)**:
	- **Puertos (Ports)** → interfaces del dominio.
	- **Adaptadores (Adapters)** → implementaciones concretas (DB, REST, etc.).
	- Facilita testeo, mantenimiento y reemplazo de tecnologías.
- **DDD (Domain-Driven Design)**:
	- **Entidades**: con identidad propia.
	- **Value Objects**: definidos por su valor, inmutables.
	- **Aggregates** y **Aggregate Roots**: agrupan consistencia.
	- **Repositories**: abstraen persistencia.
	- **Services**: encapsulan lógica de dominio transversal.

---

## ⚙️ Arquitecturas Modernas en Java

- **Monolito modular**:
	- Estructurado por módulos independientes.
	- Ideal para apps medianas con despliegue simple.
- **Microservicios**:
	- Cada servicio = dominio acotado.
	- Comunicación por REST, mensajería (Kafka, RabbitMQ).
	- Despliegue aislado con [Docker](/software%20engineering/docker/) + [Kubernetes](/virtualizacion/kubernetes/).
- **Serverless y FaaS**:
	- Java en AWS Lambda, Google Cloud Run, Azure Functions.
	- Optimizaciones necesarias: *GraalVM Native Image*, tiempos de arranque bajos.

---

## 🧩 Integración y Comunicación

- **REST APIs** (Spring MVC, JAX-RS):
	
```java
	@RestController
	@RequestMapping("/api/clientes")
	public class ClienteController {
		@GetMapping("/{id}")
		public ResponseEntity<Cliente> obtener(@PathVariable Long id) {
			return ResponseEntity.ok(servicio.buscarPorId(id));
		}
	}
	```

- **Feign Client (Spring Cloud)**:
	
```java
	@FeignClient(name = "usuarios", url = "${api.usuarios.url}")
	interface UsuarioClient {
		@GetMapping("/usuarios/{id}")
		UsuarioDTO obtener(@PathVariable Long id);
	}
	```

- **Mensajería Asíncrona**:
	- Kafka, [RabbitMQ](/backend/rabbitmq/), ActiveMQ.
	- Patrones: *Event Sourcing*, *CQRS*, *Outbox Pattern*.
- **GraphQL y gRPC**:
	- Alternativas modernas a REST con menor overhead.

---

## 🔒 Seguridad Empresarial

- **Autenticación y Autorización**:
	- Spring Security + JWT + OAuth2.
	- Integración con Keycloak, Auth0, o Okta.
- **Roles y Claims**:
	
```java
	@PreAuthorize("hasRole('ADMIN')")
	public void eliminarUsuario() {}
	```

- **Cifrado y hashing**:
	- `BCryptPasswordEncoder`, AES, RSA.
- **Auditoría y Logging seguro**:
	- Spring AOP para interceptar llamadas críticas.
	- SLF4J + Logback + ELK (Elastic Stack).

---

## 🧮 Persistencia y ORM

- **JPA / Hibernate**:
	- Entidades anotadas:
	
```java
	@Entity
	public class Usuario {
		@Id @GeneratedValue
		private Long id;
		private String nombre;
	}
	```

	- Relaciones:
		- `@OneToMany`, `@ManyToOne`, `@OneToOne`, `@ManyToMany`.
	- Consultas:
		- JPQL, Criteria API, Native Queries.
- **Spring Data JPA**:
	- Repositorios automáticos:
	
```java
	public interface UsuarioRepo extends JpaRepository<Usuario, Long> {}
	```

- **Mapeo DTOs**:
	- Evita exponer entidades directamente.
	- Usa MapStruct o `ModelMapper`.

---

## 🧠 Patrones Empresariales y Escalabilidad

- **Patrones de Integración**:
	- Service Registry (Eureka)
	- API Gateway (Zuul, Spring Cloud Gateway)
	- Circuit Breaker (Resilience4j)
	- Config Server, Load Balancer, Distributed Tracing.
- **Caching**:
	- Redis, Caffeine, EHCache.
	- Anotaciones:
		
```java
		@Cacheable("productos")
		public List<Producto> listar() { ... }
		```

- **CQRS (Command Query Responsibility Segregation)**:
	- Separar comandos (mutaciones) y consultas (lectura).
	- Mejora rendimiento en dominios complejos.
- **Saga Pattern** (transacciones distribuidas):
	- Control de flujo entre microservicios.
	- Implementable con orquestadores (Camunda, Temporal.io).

---

## 🧰 DevOps y Despliegue

- **Contenedores y Orquestación**:
	- [Docker](/software%20engineering/docker/) → empaquetado por microservicio.
	- [Kubernetes](/virtualizacion/kubernetes/) → escalado automático, secretos, monitoreo.
- **CI/CD**:
	- GitHub Actions, Jenkins, GitLab CI.
	- Pipelines para compilar, testear y desplegar.
- **Infraestructura como código (IaC)**:
	- Terraform, Ansible, Pulumi.
- **Observabilidad**:
	- Prometheus + Grafana
	- ELK Stack (Logs)
	- Jaeger o Zipkin (tracing distribuido)
- **Testing de arquitectura**:
	- ArchUnit → asegura capas y dependencias correctas.

---

## 🚀 Buenas Prácticas de Arquitectura

- Usa **DTOs y Mappers** para desacoplar API ↔ Dominio.
- Aplica **SOLID, DRY, KISS, YAGNI** a nivel de módulo.
- **Documenta** con Swagger o [OpenAPI](/backend/openapi/).
- **Versiona APIs** (`/api/v1/...`).
- **Externaliza configuración** (Spring Config Server, `.env`, Secrets Manager).
- **Automatiza tests de integración y contract testing**.

---

## 📦 Ejemplo de Estructura Empresarial

src/ ├─ domain/ │ ├─ model/ │ ├─ repository/ │ └─ service/ ├─ infrastructure/ │ ├─ config/ │ ├─ persistence/ │ └─ messaging/ ├─ application/ │ ├─ controller/ │ ├─ dto/ │ └─ mapper/ └─ main/ ├─ SpringBootApp.java




---

## 📚 Enlaces Relacionados

- [Springboot](/backend/springboot/)
- Spring Cloud
- Microservicios
- JPA
- [Docker](/software%20engineering/docker/)
- [Testing](/testing/testing/)
- Maven
- [Gradle](/automatizacion%20y%20build/gradle/)
- [Kubernetes](/virtualizacion/kubernetes/)
- Arquitectura Hexagonal
- Keycloak
- Swagger

---

> **Resumen:**  
> Esta nota unifica los conceptos de diseño empresarial en Java, abarcando desde la arquitectura por capas hasta microservicios y despliegue en la nube. Es el puente final entre el desarrollo práctico y la ingeniería de software profesional con Java.

# 🧠 Guía Completa de Java – Cheatsheet + Trucos + Problemas Comunes (2025)

> Guía práctica y moderna de Java con sintaxis esencial, ejemplos reales, atajos, errores típicos y soluciones.  
> Compatible con [Springboot](/backend/springboot/), JPA, Streams, Records y otras características de Java 21+.

---

## 🧩 1. Sintaxis y Conceptos Fundamentales

### ✳️ Estructura básica


```java
public class HolaMundo {
	public static void main(String[] args) {
		System.out.println("¡Hola Java 2025!");
	}
}

`

🧮 Variables y tipos

int edad = 30;
double precio = 19.99;
boolean activo = true;
String nombre = "Eduardo";
var saludo = "Hola"; // inferencia desde Java 10

💡 Truco: Usa var solo para inicializaciones claras. Evita: var x = obtener(); // ¿qué devuelve?

🧱 2. Control de Flujo

if (edad >= 18) System.out.println("Adulto");
else System.out.println("Menor");

for (int i = 0; i < 3; i++) System.out.println(i);

while (true) break;

switch (opcion) {
	case 1 -> System.out.println("Uno");
	case 2 -> System.out.println("Dos");
	default -> System.out.println("Otro");
}

💡 Switch con expresiones (Java 14+)

String tipo = switch (codigo) {
	case 1 -> "Admin";
	case 2,3 -> "User";
	default -> "Guest";
};

🧬 3. Clases, Objetos y Encapsulación

public class Persona {
	private String nombre;
	private int edad;

	public Persona(String nombre, int edad) {
		this.nombre = nombre;
		this.edad = edad;
	}

	public void saludar() {
		System.out.println("Hola, soy " + nombre);
	}
}

🧰 Constructor por defecto y sobrecarga

public Persona() {}
public Persona(String nombre) { this.nombre = nombre; }

📜 record (Java 16+)

Ideal para DTOs y modelos inmutables.

public record Usuario(String nombre, String email) {}

🧭 4. Herencia, Interfaces y Polimorfismo

abstract class Animal {
	abstract void sonido();
}

class Perro extends Animal {
	void sonido() { System.out.println("Guau!"); }
}

🧩 Interfaces

interface Volador { void volar(); }

class Pajaro implements Volador {
	public void volar() { System.out.println("Volando alto!"); }
}

💡 Usa sealed classes (Java 17+) para restringir jerarquías:

sealed class Figura permits Circulo, Cuadrado {}

⚙️ 5. Colecciones y Streams

🪣 Colecciones

List<String> nombres = new ArrayList<>();
nombres.add("Ana");
nombres.add("Luis");

Set<Integer> numeros = Set.of(1,2,3);
Map<String,Integer> edades = Map.of("Ana",25, "Luis",30);

🧵 Streams API

List<Integer> pares = numeros.stream()
	.filter(n -> n % 2 == 0)
	.map(n -> n * 10)
	.toList();

💡 Trucos Streams:

  • Usa peek() solo para debug.
  • Evita streams anidados; usa flatMap().
  • Para colecciones grandes, usa parallelStream() (cuidado con IO).

🔁 6. Lambdas y Funcional

List<String> lista = List.of("a", "b", "c");
lista.forEach(s -> System.out.println(s.toUpperCase()));

Predicate<Integer> mayorDe10 = x -> x > 10;
Function<String, Integer> longitud = String::length;

💡 Tips:

  • var se puede usar en lambdas: (var x, var y) -> x + y
  • Usa Comparator.comparing() para ordenar fácilmente:
lista.sort(Comparator.comparing(String::length).reversed());

💾 7. Excepciones

try {
	int x = 10 / 0;
} catch (ArithmeticException e) {
	System.err.println("Error: " + e.getMessage());
} finally {
	System.out.println("Finalizado");
}

💡 Trucos comunes:

  • No atrapes Exception genérica.
  • Crea excepciones personalizadas (extends RuntimeException).
  • Usa try-with-resources para cerrar streams o conexiones.
try (var lector = new BufferedReader(new FileReader("archivo.txt"))) {
	lector.lines().forEach(System.out::println);
}

🧮 8. Entrada/Salida y Archivos

Files.writeString(Path.of("datos.txt"), "Hola mundo!");
String contenido = Files.readString(Path.of("datos.txt"));

💡 Usa Files.lines() para leer grandes ficheros como stream.

🧠 9. Concurrencia Moderna

🧵 Hilos

new Thread(() -> System.out.println("Hilo paralelo")).start();

💡 ExecutorService

ExecutorService pool = Executors.newFixedThreadPool(4);
pool.submit(() -> System.out.println("Task ejecutada"));
pool.shutdown();

⚡ Virtual Threads (Java 21)

Thread.startVirtualThread(() -> System.out.println("Ligero y rápido!"));

🌐 10. HTTP y JSON

🔗 HTTP Client (Java 11+)

var client = HttpClient.newHttpClient();
var req = HttpRequest.newBuilder(URI.create("https://api.github.com")).build();
var res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

📦 JSON con Jackson

ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(new Usuario("Ana", "ana@mail.com"));
Usuario u = mapper.readValue(json, Usuario.class);

🧰 11. Trucos y Buenas Prácticas

✅ Usa Optional<T> en lugar de null:

Optional<String> nombre = Optional.ofNullable(usuario.getNombre());
nombre.ifPresent(System.out::println);

✅ record para DTOs, evita boilerplate. ✅ Usa String.format o text blocks:

String html = """
	<html>
		<body>Hola</body>
	</html>
	""";

✅ Ordena dependencias con Maven o Gradle. ✅ Usa @Override SIEMPRE para evitar errores de método.

⚡ 12. Problemas Comunes y Soluciones

Problema Causa Solución
NullPointerException Variable no inicializada Usa Optional o validaciones previas
ConcurrentModificationException Modificar lista en bucle Usa Iterator.remove() o CopyOnWriteArrayList
ClassNotFoundException Dependencia no encontrada Verifica classpath y pom.xml
StackOverflowError Recursión infinita Añadir condición base o tail recursion
OutOfMemoryError Fugas en colecciones Monitorear con VisualVM o JConsole
LazyInitializationException Acceso a entidad fuera de sesión Usa fetch = EAGER o JOIN FETCH

🧠 13. Cheatsheet Rápido de Comandos

Acción Código
Imprimir en consola System.out.println()
Leer entrada new Scanner(System.in).nextLine()
Redondear Math.round(3.7)
Ordenar lista lista.sort(Comparator.naturalOrder())
Crear hilo new Thread(runnable).start()
Leer JSON mapper.readValue(json, Clase.class)
Crear archivo Files.write(Path.of("x.txt"), data.getBytes())

🧩 14. Herramientas y Frameworks Clave

  • Springboot → apps empresariales.
  • JPA / Hibernate → persistencia ORM.
  • Maven / Gradle → build y dependencias.
  • Lombok → elimina boilerplate (@Getter, @Builder).
  • JUnit5 / Mockito → testing.
  • Docker + Kubernetes → despliegue cloud-ready.

🧱 15. Ejemplo Completo

@SpringBootApplication
public class DemoApp {
	public static void main(String[] args) {
		SpringApplication.run(DemoApp.class, args);
	}
}

@RestController
@RequestMapping("/api")
class HelloController {
	@GetMapping("/hola")
	String hola() {
		return "Hola desde Spring Boot + Java 21!";
	}
}

🧩 Enlaces Recomendados

Resumen: Esta guía sirve como referencia rápida y práctica de Java moderno (Java 17–21), con ejemplos, trucos y soluciones a errores comunes para acelerar el desarrollo profesional.

Perfecto 💪 — aquí tienes la extensión avanzada de tu guía Java, centrada en rendimiento, profiling y optimización de la JVM, actualizada a 2025. Se complementa perfectamente con tu nota principal, sin repetir conceptos.

⚙️ Java – Rendimiento, Profiling y Optimización JVM (2025)

Guía avanzada de optimización de rendimiento en Java: análisis de la JVM, JIT, GC tuning, herramientas de profiling y patrones de eficiencia.
Aplicable a entornos Springboot, Microservicios, Docker, Cloud y producción.

🔬 1. Entendiendo el rendimiento en Java

Java es rápido gracias al JIT (Just-In-Time Compiler), pero el rendimiento depende de:

  • Configuración correcta de la JVM
  • Eficiencia en uso de memoria
  • Reducción de bloqueos y sincronización
  • Análisis con profiler

💡 Principio base: medir antes de optimizar — “What you don’t measure, you can’t improve.”

🧠 2. La JVM por dentro

🔹 Componentes clave

  • ClassLoader → carga clases y dependencias.
  • JIT Compiler (C1/C2) → compila bytecode a código nativo optimizado.
  • GC (Garbage Collector) → gestiona memoria automática.
  • Heap & Stack → memoria de objetos y de ejecución.

📊 Usa:

java -XshowSettings:all -version

`

para ver configuración completa.

⚡ 3. JIT Compiler: optimización en caliente

El JIT convierte bytecode en código nativo justo a tiempo.

🧩 Trucos y ajustes

Opción Descripción
-XX:+PrintCompilation Muestra métodos compilados JIT
-XX:+TieredCompilation Híbrido C1 + C2 para balance velocidad/optimización
-XX:+PrintInlining Ver qué métodos se inlinan
-XX:MaxInlineSize=200 Aumenta el tamaño máximo de métodos inlinables

💡 Tip: evita micro-métodos innecesarios — el JIT optimiza llamadas frecuentes pero los métodos demasiado grandes pueden impedir inlining.

🧹 4. Garbage Collector (GC) Tuning

🔸 Coleccionadores modernos

GC Ideal para Características
G1 GC (default Java 17+) Apps server, latencia baja Equilibrio entre throughput y pausas
ZGC Microservicios, apps de baja latencia Pausas < 10 ms
Shenandoah Apps interactivas, servidores con mucha RAM Compacción concurrente
Parallel GC Jobs batch, CPU alta Rendimiento bruto

⚙️ Configuración básica

java -XX:+UseG1GC -Xms512m -Xmx2g -XX:+PrintGCDetails -Xlog:gc

💡 Trucos:

  • Ajusta -Xmx y -Xms iguales para evitar heap expansion.
  • Usa -XX:+UseStringDeduplication para ahorrar memoria con strings repetidos.
  • Monitorea pausas con -Xlog:gc*:file=gc.log:time,uptime,level,tags.

🔍 5. Profiling y Monitoreo

🔹 Herramientas nativas de Java

Herramienta Uso
jconsole Monitoreo en tiempo real de heap, threads, CPU
jvisualvm Profiling completo (CPU, heap, GC)
jcmd Comandos en vivo (jcmd <pid> GC.heap_info)
jstack Dump de hilos bloqueados
jmap Heap dump para análisis offline
jstat Estadísticas de GC y compilador

🧰 Ejemplo:

jcmd <PID> GC.heap_dump heapdump.hprof

Luego abre con VisualVM → File → Load… → heapdump.hprof

🔎 6. Java Flight Recorder (JFR)

📦 Integrado desde Java 11+, ofrece profiling de bajo overhead.

Activar JFR en ejecución:

java -XX:StartFlightRecording=filename=app.jfr,duration=60s,settings=profile

Analizar resultados:

  • Abre con JDK Mission Control (JMC).
  • Analiza GC, compilación, I/O, CPU, locks, heap, threads.

💡 Truco: ejecuta sesiones JFR periódicas en producción para detectar degradaciones antes de que impacten usuarios.

🧮 7. Medición de rendimiento en código

Usa JMH (Java Microbenchmark Harness) para medir métodos o algoritmos.

@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Benchmark)
public class MiBenchmark {

	private List<Integer> lista = IntStream.range(0, 1000).boxed().toList();

	@Benchmark
	public int sumaStream() {
		return lista.stream().reduce(0, Integer::sum);
	}

	@Benchmark
	public int sumaFor() {
		int total = 0;
		for (int n : lista) total += n;
		return total;
	}
}

Ejecución:

mvn clean install
java -jar target/benchmarks.jar

💡 Truco: nunca uses System.nanoTime() manualmente para comparar — JMH compensa JIT warmup y GC.

🧵 8. Concurrencia y rendimiento

🧩 Problemas comunes

Problema Causa Solución
Bloqueos largos synchronized excesivo Usa ReentrantLock, StampedLock, o ReadWriteLock
Deadlocks Recursos compartidos mal ordenados Usa ThreadMXBean para detectar
CPU alta parallelStream() sin control Limita ForkJoinPool.commonPool()
Contención Variables globales compartidas Usa ThreadLocal o Atomic*

💡 Tips:

  • Usa Virtual Threads (Project Loom, Java 21) para I/O masivo.
  • Evita crear ExecutorService por request.
  • Usa CompletableFuture para programación reactiva.

🔐 9. Buenas prácticas de rendimiento

✅ Reduce Boxing/Unboxing

int suma = Integer.valueOf(10) + 2; // Evita autobox

✅ Evita concatenación excesiva de Strings Usa StringBuilder o String.join()

✅ Colecciones adecuadas

  • ArrayList > LinkedList (salvo inserciones frecuentes en medio)
  • EnumMap / EnumSet para enums
  • ConcurrentHashMap para multi-thread

✅ Evita crear objetos innecesarios

private static final Pattern P = Pattern.compile("\\d+");

(no recrees el patrón en cada llamada)

✅ Usa caches ligeras Map<String, Object> cache = new ConcurrentHashMap<>();

🧠 10. Diagnóstico en producción

# Ver uso de heap y GC
jstat -gc <PID> 1s 10

# Hilos bloqueados
jstack <PID> | grep BLOCKED

# Top consumo CPU
top -H -p <PID>

# Dump heap y analizar con Eclipse MAT o VisualVM
jmap -dump:live,format=b,file=heap.hprof <PID>

🔥 Ejemplo real:

Problema: pausas GC largas Solución: migrar de G1 a ZGC

-XX:+UseZGC -Xmx2g -Xms2g

🚀 11. Optimización en entornos Cloud / Spring Boot

🔧 JVM en contenedores

# Ajusta automáticamente heap según cgroups (Java 10+)
java -XX:+UseContainerSupport -XshowSettings:vm

🧩 Spring Boot tips

  • Usa spring-context-indexer para arranque más rápido.
  • Desactiva autoconfiguraciones innecesarias:
spring:
  autoconfigure:
    exclude:
      - org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration
  • Usa @ConfigurationProperties en lugar de @Value para configuración masiva.

🧠 Image Build Optimizations

  • Usa GraalVM para generar ejecutables nativos:
  native-image -jar app.jar
  • Usa Layered JARs (spring-boot:build-image) para caching en Docker.

📈 12. Herramientas recomendadas (2025)

Herramienta Propósito
VisualVM Perfilado de CPU y memoria
JDK Mission Control (JMC) Análisis JFR
JProfiler / YourKit Profiling comercial avanzado
Async Profiler Muestreo de CPU nativo, compatible con JFR
Eclipse MAT Análisis de heap dumps grandes
Micrometer + Prometheus + Grafana Monitoreo Spring Boot
Java Flight Recorder + Loki Logging + Telemetría

🧩 13. Scripts útiles

🧮 Heap size dinámico

export JAVA_OPTS="-Xms512m -Xmx2g -XX:+UseG1GC -XX:+HeapDumpOnOutOfMemoryError"

📊 Registrar rendimiento

java -Xlog:gc*:file=gc.log:tags,time,uptime,level

🧩 Visualizar heap en Docker

docker exec -it myapp jcmd 1 GC.heap_info

🧩 14. Recursos Recomendados

Resumen: Esta nota amplía la guía principal con herramientas y técnicas de profiling, optimización de memoria, GC tuning y análisis de rendimiento real. Ideal para entornos de producción, microservicios y aplicaciones críticas en Java 21 y Springboot.

🧠 Cheatsheet Completo de Comandos Java (2025)

📦 Básicos del compilador y ejecución

  • Compilar un archivo Java
	javac Main.java
	```

	Genera `Main.class` (bytecode).

- **Ejecutar una clase compilada**
	
```bash
	java Main
	```


- **Compilar y ejecutar directamente**
	
```bash
	java Main.java
	```

	*(Desde Java 11 puedes ejecutar un .java directamente sin compilar antes.)*

- **Compilar varios archivos**
	
```bash
	javac src/com/ejemplo/*.java
	```


- **Especificar carpeta de salida para .class**
	
```bash
	javac -d out src/com/ejemplo/*.java
	java -cp out com.ejemplo.Main
	```


- **Eliminar archivos compilados**
	
```bash
	rm *.class
	```


---

## 🧭 Classpath y Paquetes

- **Ejecutar una clase con paquetes**
	
```bash
	java com.amigoscode.Main
	```


- **Añadir varios paths al classpath**
	
```bash
	java -cp ".:libs/*" com.amigoscode.Main
	```


- **Definir classpath al compilar**
	
```bash
	javac -cp libs/* -d out src/com/app/Main.java
	```


- **Crear paquete**
	
```java
	package com.app.util;
	```


---

## 🧰 Crear y usar archivos JAR

- **Empaquetar clases compiladas en un JAR**
	
```bash
	jar cf app.jar -C out/ .
	```


- **Ejecutar un JAR**
	
```bash
	java -jar app.jar
	```


- **Crear JAR ejecutable con `Main-Class`**
	
```bash
	jar cfe app.jar com.ejemplo.Main -C out .
	```


- **Listar contenido del JAR**
	
```bash
	jar tf app.jar
	```


- **Extraer contenido**
	
```bash
	jar xf app.jar
	```


---

## 🧩 Modularización (Java 9+)

- **Compilar módulo**
	
```bash
	javac -d out --module-source-path src $(find src -name "*.java")
	```


- **Ejecutar módulo**
	
```bash
	java --module-path out -m com.ejemplo/com.ejemplo.Main
	```


---

## 🪄 Java Tooling (JDK Utilities)

### 🔍 `javap` – Desensamblar bytecode

```bash
javap -c -p com.ejemplo.Main

`

Muestra los bytecodes generados y los métodos privados (-p).

🧮 jstat – Estadísticas de la JVM

jstat -gc <pid> 1000

Muestra estadísticas de Garbage Collection cada segundo.

🧠 jinfo – Configuración de JVM en ejecución

jinfo <pid>

🔧 jmap – Mapear heap

jmap -heap <pid>
jmap -histo <pid>

Muestra el uso de memoria y conteo de objetos.

🧹 jcmd – Interfaz moderna de diagnóstico

jcmd <pid> VM.flags
jcmd <pid> GC.run
jcmd <pid> Thread.print

🚀 jconsole – Monitor GUI

jconsole

Conecta a una JVM local o remota.

🔥 jfr / jcmd JFR – Java Flight Recorder

Grabación de perfiles de rendimiento:

jcmd <pid> JFR.start name=apprecord filename=recording.jfr
jcmd <pid> JFR.dump name=apprecord
jcmd <pid> JFR.stop name=apprecord

Abrir el .jfr con Java Mission Control (JMC).

📈 visualvm – Monitor visual de JVM

visualvm

Herramienta gráfica para profiling, heap dumps, CPU usage y GC.

⚙️ Gestión de versiones (Java 11+)

  • Ver versión instalada
  java -version
  • Listar todas las herramientas JDK
  java --help
  • Cambiar versión con SDKMAN
  sdk list java
  sdk use java 21-tem

🧪 Testing desde terminal

  • JUnit con Maven
  mvn test
  • JUnit con Gradle
  gradle test

⚡ Trucos de rendimiento

  • Activar modo rápido JIT
  java -XX:+TieredCompilation -XX:+AggressiveOpts Main
  • Ver detalles del Garbage Collector
  java -XX:+PrintGCDetails -XX:+PrintGCDateStamps Main
  • Usar G1GC o ZGC
  java -XX:+UseG1GC Main
  java -XX:+UseZGC Main
  • Limitar memoria
  java -Xms512m -Xmx2g Main
  • Obtener estadísticas de compilación JIT
  java -XX:+PrintCompilation -XX:+PrintInlining Main

🧩 Comandos útiles extra

  • Depurar
  jdb Main
  • Generar documentación Javadoc
  javadoc -d docs src/com/ejemplo/*.java
  • Compilar con advertencias
  javac -Xlint:all Main.java
  • Ver rutas de instalación
  echo $JAVA_HOME
  where java
  • Ver librerías cargadas
  jcmd <pid> VM.native_memory summary

🧾 Enlaces útiles

💡 Tip Pro

Usa un alias shell para simplificar:

alias jrun='javac $1.java && java $1'

Ejemplo:

jrun Main

🧰 Cheatsheet de Consola Profesional – Java (2025)

🔹 Fundamentos

Acción Comando Ejemplo / Notas
Ver versión instalada java -version Muestra versión del JRE y JVM
Compilar código fuente javac <archivo>.java javac Main.java
Ejecutar bytecode java <Clase> java Main
Compilar y ejecutar (Java 11+) java <archivo>.java Sin generar .class
Compilar múltiples fuentes javac src/com/app/*.java Útil para proyectos pequeños
Salida compilada personalizada javac -d out src/*.java java -cp out com.app.Main
Borrar .class rm *.class Limpieza rápida

📦 Paquetes y Classpath

Uso Comando / Ejemplo Descripción
Paquete dentro de código package com.app.utils; Define namespace
Ejecutar clase con paquete java com.app.Main Desde raíz del proyecto
Añadir dependencias java -cp ".:libs/*" Main Linux/Mac (; en Windows)
Compilar con dependencias javac -cp libs/* -d out src/*.java Con librerías externas
Variable de entorno export CLASSPATH=.:libs/* Configuración global

🧱 Archivos JAR

Acción Comando Ejemplo
Crear JAR simple jar cf app.jar -C out . Empaqueta clases compiladas
Crear JAR ejecutable jar cfe app.jar com.app.Main -C out . Con clase principal
Ejecutar JAR java -jar app.jar Ejecuta la app
Listar contenido jar tf app.jar Inspecciona el contenido
Extraer contenido jar xf app.jar Desempaqueta JAR

🧩 Modularización (Java 9+)

Tarea Comando Descripción
Compilar módulos javac --module-source-path src -d out $(find src -name "*.java") Compila proyecto modular
Ejecutar módulo java --module-path out -m com.app/com.app.Main Ejecución modular

🧮 Herramientas de Diagnóstico (JDK)

Herramienta Uso Ejemplo / Descripción
jps Lista procesos Java activos jps -l
jinfo Configuración JVM jinfo <pid>
jstat Métricas GC / memoria jstat -gc <pid> 1000
jmap Heap dump o histogramas jmap -histo <pid>
jcmd API moderna de comandos jcmd <pid> GC.run, jcmd <pid> VM.flags
jconsole GUI monitor JVM jconsole
visualvm Monitor visual avanzado visualvm
jfr / JFR Flight Recorder jcmd <pid> JFR.start filename=recording.jfr
jdb Depurador CLI jdb Main
javap Desensamblar bytecode javap -c com.app.Main

🚀 Optimización y JVM Flags

Área Flag / Comando Descripción
Ver todos los flags java -XX:+PrintFlagsFinal Lista completa de opciones
Límite de memoria -Xms512m -Xmx2g Define tamaño inicial y máximo del heap
Selección GC -XX:+UseG1GC / -XX:+UseZGC Cambia el recolector
Mostrar GC logs -Xlog:gc*,gc+ref=debug Diagnóstico de recolección
Mostrar compilaciones JIT -XX:+PrintCompilation -XX:+PrintInlining Analiza optimizaciones
Encender Tiered Compilation -XX:+TieredCompilation Mezcla C1 y C2 JIT
Ver uso nativo jcmd <pid> VM.native_memory summary Diagnóstico avanzado
Detener GC manual jcmd <pid> GC.run Forzar recolección

🧠 Profiling y Rendimiento

Herramienta Comando / Uso Descripción
VisualVM visualvm Profiling CPU/heap y análisis en vivo
Java Flight Recorder (JFR) jcmd <pid> JFR.start name=recording filename=profile.jfr Captura datos de rendimiento
Java Mission Control (JMC) GUI Analiza .jfr para encontrar cuellos de botella
jstat jstat -gcutil <pid> 1000 Tasa de uso de GC cada segundo
jmap jmap -histo <pid> Cuenta objetos en heap
Async Profiler java -agentpath:libasyncProfiler.so=start,event=cpu,file=profile.html -jar app.jar Perfilado nativo, ultraligero

🧪 Testing CLI

Herramienta Comando Descripción
Maven mvn test Ejecuta pruebas unitarias
Gradle gradle test Idem con Gradle
JUnit (directo) java -jar junit-platform-console-standalone.jar --scan-class-path CLI runner para JUnit 5
Coverage mvn test jacoco:report Genera informe de cobertura

🧾 Documentación

Acción Comando Ejemplo
Generar Javadoc javadoc -d docs src/*.java Crea documentación HTML
Solo una clase javadoc Main.java Doc individual

🧰 Otros útiles

Acción Comando Descripción
Buscar instalación where java / which java Ruta binaria
Ver JAVA_HOME echo $JAVA_HOME Ubicación del SDK
Listar herramientas JDK java --help Comandos disponibles
Versiones instaladas (SDKMAN) sdk list java Cambiar entre versiones
Activar versión sdk use java 21-tem Cambia el entorno activo
Comprobar encoding java -XshowSettings:properties | grep encoding Ver configuración de caracteres

🧠 Alias útiles para consola

alias jrun='javac $1.java && java $1'
alias jheap='jcmd $(jps -q | head -1) GC.heap_info'
alias jmem='jstat -gc $(jps -q | head -1) 1000'

`

Ejemplo:

jrun Main

💎 Recursos recomendados

⚡ Ejemplo completo: ejecutar con tuning

java \
  -Xms512m -Xmx4g \
  -XX:+UseG1GC \
  -XX:+TieredCompilation \
  -XX:+PrintGCDetails \
  -XX:+PrintCompilation \
  -jar app.jar

🧩 Debug remoto y monitoreo

Propósito Flag / Ejemplo Descripción
Habilitar depuración remota -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005 Adjunta un IDE remoto
Ver threads activos jcmd <pid> Thread.print Diagnóstico de deadlocks
Heap dump manual jmap -dump:live,format=b,file=heapdump.hprof <pid> Exporta heap
Análisis heapdump jvisualvm o Eclipse MAT Detectar memory leaks

🪶 Pro Tips

  • Usa jcmd en lugar de jmap, jinfo, jstack → más rápido y soportado.
  • Siempre activa -Xlog:gc* en producción.
  • JFR + VisualVM combinan bajo overhead y análisis en vivo.
  • SDKMAN es la mejor forma de gestionar múltiples JDKs.
  • javac --release <versión> garantiza compatibilidad binaria.

📘 “Un buen ingeniero Java domina la JVM desde la consola.”

omnivore Java

type: list
name: "Notas con #java en Omnivore"
order:
  - property: date_saved
    direction: desc
columns:
  - file.name
  - date_saved
filters:
  and:
    - file.inFolder("Omnivore")
    - file.hasTag("java")
views:
  - type: table
    name: Table
    sort:
      - property: file.mtime
        direction: DESC