Si alguna vez necesitaste conectar sistemas, transformar datos entre formatos, o integrar aplicaciones que «no se hablan entre sí», probablemente escuchaste hablar de Apache Camel. Y si estás en el Quarkiverso, la buena noticia es que Camel y Quarkus se llevan muy bien.
Camel Quarkus combina el poder de integración de Apache Camel con la eficiencia de Quarkus. El resultado: rutas de integración que arrancan en milisegundos, consumen poca memoria, y se desarrollan con Live Reload.
En este artículo construimos tu primera ruta: recibir un pedido por HTTP, transformarlo, y devolver el resultado.
¿Qué es Apache Camel?
Apache Camel es un framework de integración que implementa los Enterprise Integration Patterns (EIP): patrones probados para conectar sistemas heterogéneos.
En lugar de escribir código repetitivo, Camel te ofrece un DSL (Domain Specific Language), es decir, un lenguaje especializado para definir flujos de integración de forma clara y concisa:
from("platform-http:/api/pedido")
.unmarshal().json(Pedido.class)
.process(this::transformar)
.marshal().json();Cuatro líneas que se leen casi como una oración: «desde HTTP, deserializa JSON, procesa, y serializa JSON». Esa legibilidad es la magia del DSL de Camel.
Lo que vamos a construir
Vamos a crear algo sencillo pero completo: un endpoint que recibe un pedido en formato JSON, lo marca como procesado, y devuelve el resultado.
POST /api/pedido → [Transformar] → Respuesta JSONEs un ejemplo mínimo, pero suficiente para entender cómo fluyen los datos en una ruta Camel.
Requisitos:
- Java 17 ó 21 (soportadas por Quarkus)
- Maven 3.9 o superior
- Quarkus CLI
¿No cumples todos los requisitos? Revisa Entorno de desarrollo ideal para Quarkus donde explicamos cómo instalar todo fácilmente.
Manos a la obra
Crear el proyecto
Empezamos creando un proyecto Quarkus con las extensiones de Camel que necesitamos:
quarkus create app io.quarkiverso:camel-intro \
--extension=camel-quarkus-core,camel-quarkus-platform-http,camel-quarkus-jacksoncd camel-introEl modelo de datos
Antes de definir la ruta, necesitamos una clase que represente nuestro pedido. Jackson (la librería de JSON) la usará para convertir entre JSON y objetos Java.
Crea src/main/java/io/quarkiverso/Pedido.java:
package io.quarkiverso;
public class Pedido {
private String id;
private String producto;
private double monto;
private boolean procesado;
public String getId() { return id; }
public void setId(String id) { this.id = id; }
public String getProducto() { return producto; }
public void setProducto(String producto) { this.producto = producto; }
public double getMonto() { return monto; }
public void setMonto(double monto) { this.monto = monto; }
public boolean isProcesado() { return procesado; }
public void setProcesado(boolean procesado) { this.procesado = procesado; }
}La ruta de integración
Aquí está el corazón de Camel. Una ruta define el camino que siguen los datos: de dónde vienen, qué transformaciones sufren, y a dónde van.
Para crear rutas, extendemos la clase RouteBuilder y definimos el flujo en el método configure().
Crea src/main/java/io/quarkiverso/RutaPedido.java:
package io.quarkiverso;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.model.dataformat.JsonLibrary;
import jakarta.enterprise.context.ApplicationScoped;
@ApplicationScoped
public class RutaPedido extends RouteBuilder {
@Override
public void configure() {
from("platform-http:/api/pedido?httpMethodRestrict=POST")
.unmarshal().json(JsonLibrary.Jackson, Pedido.class)
.log("📦 Recibido: ${body.id} - ${body.producto}")
.process(exchange -> {
Pedido pedido = exchange.getIn().getBody(Pedido.class);
pedido.setProcesado(true);
})
.marshal().json(JsonLibrary.Jackson)
.log("✅ Procesado");
}
}Eso es todo. En unas pocas líneas definimos un endpoint completo que recibe, transforma y responde.
Veamos qué hace cada parte:
| Código | Qué hace |
|---|---|
from("platform-http:/api/pedido") | Expone un endpoint HTTP en /api/pedido |
.unmarshal().json(...) | Convierte el JSON de entrada en un objeto Pedido |
.process(...) | Ejecuta tu lógica de negocio |
.marshal().json(...) | Convierte el objeto de vuelta a JSON para la respuesta |
Ejecutar y probar
Arrancamos la aplicación en modo desarrollo:
quarkus devVerás que Camel registró nuestra ruta:
Routes startup (total:1)
Started route1 (platform-http:///api/pedido)Ahora, en otra terminal, enviamos un pedido de prueba:
curl -X POST http://localhost:8080/api/pedido \
-H "Content-Type: application/json" \
-d '{"id": "001", "producto": "Laptop", "monto": 1500, "procesado": false}'Respuesta:
{"id":"001","producto":"Laptop","monto":1500.0,"procesado":true}¡El campo procesado cambió de false a true! Nuestra ruta recibió el pedido, lo transformó, y devolvió el resultado.
Más allá del ejemplo: el poder de Camel
Lo que construimos es solo la punta del iceberg. Con el mismo patrón que aprendiste, Camel te permite:
- Cambiar el origen o destino fácilmente: reemplaza
platform-httpporkafka,file,ftp,aws-s3… y el resto de la ruta queda igual - Encadenar transformaciones: XML → JSON → enriquecer con API → guardar en BD
- Manejar errores automáticamente: reintentos, dead letter queues, circuit breakers
- Orquestar flujos complejos: dividir mensajes, agregar resultados, enrutar según contenido
Con más de 300 componentes disponibles, Camel te abre las puertas a prácticamente cualquier integración que necesites.
Conclusión
Con unas pocas líneas de código declarativo construiste una ruta que expone un endpoint HTTP, parsea JSON, transforma datos, y responde.
Esto es solo el comienzo. El verdadero poder de Camel está en usar este mismo patrón para conectar cualquier sistema, sin importar qué tan diferente sea.
Código fuente: gitlab.com/quarkiverso/camel-intro