Equivalencias entre un proyecto Spring Boot y ASP .NET Core

En esta ocasión veremos una equivalencia entre un proyecto desarrollado con Spring Boot y ASP .NET Core.

Digamos que tenemos esta estructura de carpetas:

auditor/
  pom.xml
  src/resources/application.properties
  src/main/java/com/inforhomex/CursoSpring/AuditorSpringApplication.java
  src/main/java/com/inforhomex/CursoSpring/component/AuditorComponent.java
  src/main/java/com/inforhomex/CursoSpring/config/AuditorConfig.java
  src/main/java/com/inforhomex/CursoSpring/controller/AuditorController.java
  src/main/java/com/inforhomex/CursoSpring/model/Auditor.java
  src/main/java/com/inforhomex/CursoSpring/services/AuditorService.java
  src/main/java/com/inforhomex/CursoSpring/services/AuditorServiceImpl.java
  src/main/java/com/inforhomex/CursoSpring/repository/AuditorRepository.java

Su equivalente en ASP .NET Core sería:

Auditor/
  Auditor.csproj
  appsettings.json
  Program.cs
  Controllers/
      AuditorController.cs
  Models/
      Auditor.cs
  Services/
      IAuditorService.cs
      AuditorService.cs
  Repositories/
      IAuditorRepository.cs
      AuditorRepository.cs
  Data/
      ApplicationDbContext.cs
  Configuration/
      AuditorConfig.cs (opcional)

Explicación archivo por archivo

Spring usa Maven; .NET usa un archivo XML similar.

Auditor.csproj (equivale al pom.xml)

<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.0" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="8.0.0" />
  </ItemGroup>
</Project>

El appsettings.json de ASP .NET Core sería el application.properties de Spring Boot.

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=AuditorDb;Trusted_Connection=True;"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information"
    }
  }
}

Ahora veamos el programa principal llamado Program.cs que equivaldría a AuditorSpringApplication.java de Spring Boot.

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();
builder.Services.AddDbContext<ApplicationDbContext>();
builder.Services.AddScoped<IAuditorService, AuditorService>();
builder.Services.AddScoped<IAuditorRepository, AuditorRepository>();

var app = builder.Build();

app.MapControllers();
app.Run();

Quien ha usado Spring Boot sabrá lo que es la Inyección de dependencia.

@Autowired
AuditorService service;

En C# también existe ese concepto:

builder.Services.AddSingleton<AuditorComponent>();

¿Y qué con las configuraciones? Con Spring Boot tenemos clases para configuraciones especiales.

@Configuration
public class AuditorConfig { ... }

En ASP .NET Core tenemos esto:

public static class AuditorConfig {
    public static void AddAuditorServices(this IServiceCollection services) {
        services.AddScoped<IAuditorService, AuditorService>();
    }
}

Y en el programa principal Program.cs:

builder.Services.AddAuditorServices();

Las clases Controllers de Spring Boot también tendrían su equivalente:

AuditorController.cs

[ApiController]
[Route("auditor")]
public class AuditorController : ControllerBase {
    private readonly IAuditorService _service;

    public AuditorController(IAuditorService service) {
        _service = service;
    }

    [HttpGet]
    public IActionResult GetAll() => Ok(_service.GetAll());
}

Con las entidades Java pasaría lo mismo:

Auditor.java

@Entity
public class Auditor { ... }

Su equivalente sería:

Auditor.cs

public class Auditor {
    public int Id { get; set; }
    public string Nombre { get; set; }
}

Con las clases servicio de Java/SpringBoot también aplica:

public interface AuditorService { ... }

@Service
public class AuditorServiceImpl implements AuditorService { ... }

Con C#:

IAuditorService.cs

public interface IAuditorService {
    IEnumerable<Auditor> GetAll();
}

AuditorService.cs

public class AuditorService : IAuditorService {
    private readonly IAuditorRepository _repo;

    public AuditorService(IAuditorRepository repo) {
        _repo = repo;
    }

    public IEnumerable<Auditor> GetAll() => _repo.GetAll();
}

Y continuamos con las clases Repository:

AuditorRepository.java

@Repository
public interface AuditorRepository extends JpaRepository<Auditor, Long> { }

Y su equivalente:

Interface:

public interface IAuditorRepository {
    IEnumerable<Auditor> GetAll();
}

Implementación:

public class AuditorRepository : IAuditorRepository {
    private readonly ApplicationDbContext _context;

    public AuditorRepository(ApplicationDbContext context) {
        _context = context;
    }

    public IEnumerable<Auditor> GetAll() => _context.Auditors.ToList();
}

ApplicationDbContext.cs

public class ApplicationDbContext : DbContext {
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options) { }

    public DbSet<Auditor> Auditors { get; set; }
}

Con esto tendríamos la estructura de directorios equivalente a Spring Boot con ASP .NET Core :

- Controllers
- Models
- Services
- Repositories
- DbContext
- Configuración en Program.cs
- appsettings.json

Esta estructura no necesariamente la tendría un proyecto real. Sin embargo, es un acercamiento bastante formal.

Ahora veamos una tabla comparativa.

Comparativa ASP .NET Core vs Spring Boot

Criterio	ASP.NET Core (.NET)	Spring Boot (Java)
Lenguaje principal	C#, F#, VB.NET	Java, Kotlin, otros JVM
Plataformas soportadas	Windows, Linux, macOS (cross-platform)	Windows, Linux, macOS (via JVM)
Modelo de ejecución	.NET runtime (Core/5+) con JIT y opciones AOT	JVM (HotSpot, OpenJ9) con JIT
Tipo de framework	Framework web moderno, modular, orientado a middleware	Framework de arranque rápido sobre Spring, opinionated
Arquitectura y patrón principal	Soporta MVC, Razor Pages, Minimal APIs, gRPC, SignalR	Soporta MVC, WebFlux (reactivo), REST, SOAP, gRPC (via librerías)
Configuración	appsettings.json, configuración fuertemente tipada	application.properties / application.yml, Profiles
Inyección de dependencias	Contenedor DI integrado en el framework	Spring IoC Container muy maduro y extensible
Rendimiento en APIs	Muy alto; entre los más rápidos en benchmarks	Alto, generalmente por debajo de ASP.NET Core en pruebas crudas
Servidor embebido	Kestrel (servidor web propio, muy eficiente)	Tomcat por defecto; Jetty/Undertow opcionales
ORM / acceso a datos	Entity Framework Core, Dapper, otros ORMs	Spring Data JPA, Hibernate, MyBatis, etc.
Soporte cloud	Excelente integración con Azure; buen soporte AWS/GCP	Excelente integración con AWS, GCP, Azure (Spring Cloud)
Ecosistema y librerías	Ecosistema .NET, NuGet, fuerte integración con herramientas Microsoft	Ecosistema Java, gran cantidad de librerías, Spring Cloud, Spring Security, etc.
Curva de aprendizaje	Amigable si vienes de C# o stack Microsoft	Puede ser más compleja por la profundidad del ecosistema Spring
Herramientas y IDEs	Visual Studio, Rider, VS Code	IntelliJ IDEA, Eclipse, VS Code
Madurez en entornos enterprise	Muy usado en enterprise, fuerte en empresas Microsoft-centric	Dominante histórico en enterprise Java, ecosistema muy maduro
Licencia y open source	Open source (MIT), desarrollado por Microsoft y comunidad	Open source (Apache 2.0), desarrollado por VMware/Spring y comunidad
Casos de uso típicos	APIs de alto rendimiento, microservicios, backends corporativos, integraciones con Azure	Microservicios enterprise, sistemas bancarios, telecom, SaaS sobre JVM

Conclusiones:

ASP.NET Core y Spring Boot representan dos de los ecosistemas más sólidos, modernos y maduros para construir aplicaciones backend y microservicios. Ambos ofrecen rendimiento, modularidad, herramientas de desarrollo avanzadas y una comunidad activa, pero cada uno destaca en áreas distintas.

ASP.NET Core sobresale por su alto rendimiento, su servidor web Kestrel extremadamente eficiente y su integración natural con el ecosistema Microsoft, especialmente Azure. Su diseño minimalista, su DI nativo y su enfoque en middleware lo hacen muy directo y consistente.

Para equipos que ya trabajan con C#, Windows o Azure, ASP.NET Core suele ser la opción más natural y productiva.

Spring Boot, por otro lado, brilla por la amplitud y madurez de su ecosistema, especialmente en entornos enterprise donde Java ha sido dominante durante décadas.

Su integración con Spring Cloud, su flexibilidad para trabajar con múltiples servidores embebidos y su enorme catálogo de librerías lo convierten en una plataforma muy poderosa para arquitecturas complejas y distribuidas.

En términos prácticos, ninguno es “mejor” de forma absoluta. La elección depende del contexto:

• Si buscas máximo rendimiento, integración con Azure, o ya trabajas con C#, ASP.NET Core es una apuesta excelente. 
• Si necesitas ecosistema enterprise, herramientas maduras para microservicios distribuidos o ya tienes experiencia en Java, Spring Boot sigue siendo un estándar de oro.

En resumen, ambos frameworks son tecnologías de primera línea. La decisión final suele depender más del ecosistema, la experiencia del equipo y las necesidades del proyecto que de diferencias técnicas absolutas.

Enlaces:

https://blog.vtutor.com/es/cursos-en-linea/principales-razones-por-las-que-asp-net-core-es-el-mejor-framework-para-el-desarrollo-de-aplicaciones-web/
https://www.swiftorial.com/matchups/backend_framework/aspnet-core-vs-spring-boot-dotnet-vs-java
https://medium.com/@solomongetachew112/spring-boot-vs-net-core-which-backend-framework-wins-in-2024-2025-de9395008244
https://dev.to/umesh_kushwaha_6655ba4c0d/spring-boot-vs-net-core-complete-developer-migration-guide-4mfk

Microsoft Windows Services & Microsoft Worker Services

Windows Services y Worker Services son dos formas de crear procesos de larga duración en el ecosistema de Microsoft.

Windows Services pertenecen al .NET Framework y se ejecutan como servicios del sistema en Windows. Worker Services son la evolución moderna en .NET (Core/5+) y permiten procesos en segundo plano multiplataforma, usando el modelo de hospedaje de .NET.

¿Qué es un Windows Service? es una aplicación de larga duración que se ejecuta en su propia sesión, sin interfaz de usuario, iniciándose con el sistema operativo y administrándose desde el administrador de servicios de Windows. Históricamente se conocen como NT services y están pensados para tareas en segundo plano exclusivamente en Windows

¿Qué es .NET Worker Services? es una aplicación de fondo basada en el host genérico de .NET (IHostedService/BackgroundService). Permite procesar colas, tareas programadas o trabajos intensivos sin UI, y puede ejecutarse en Windows, Linux y macOS. Es la alternativa moderna a los servicios de Windows, con plantillas oficiales y soporte de extensiones de .NET para configuración, DI y logging.

Windows Services

• Modelo clásico, ligado a Windows. 
• Pensado para .NET Framework. 
• Difícil de portar, instalar y mantener en entornos modernos o cloud.

Worker Services

• Modelo moderno basado en el Generic Host de .NET. 
• Funciona en Windows, Linux y macOS. 
• Se integra nativamente con DI, logging, configuración, health checks, contenedores y DevOps. 
• Puede ejecutarse como servicio de Windows, como systemd en Linux o dentro de Docker.

Similitudes:

• Larga duración: Ambos modelos ejecutan tareas persistentes en segundo plano sin interfaz gráfica. 
• Automatización de procesos: Son adecuados para trabajos programados, procesamiento de colas y servicios que requieren estar activos continuamente.

Diferencias clave:

• Plataforma: Windows Services solo en Windows; Worker Services son multiplataforma. 
• Modelo de hospedaje: Windows Services usan el modelo del SO y ServiceController; Worker Services usan el host genérico de .NET con IHostedService/BackgroundService. 
• Desarrollo y despliegue: Windows Services requieren instalación y registro como servicio del sistema; Worker Services se hospedan como consola, servicio de Windows, systemd en Linux o contenedor. 
• Ecosistema moderno: Worker Services integran DI, configuración y logging de .NET; Windows Services carecen de estas integraciones nativas en .NET Framework.

¿Cuándo usar cada uno?

• Elige Windows Services: Cuando estás atado a Windows Server y a la administración nativa de servicios del sistema, o mantienes una solución existente en .NET Framework. 
• Elige Worker Services: Cuando buscas portabilidad, contenedores, despliegues cloud/devops, integración con DI y observabilidad moderna en .NET.

Comparativa entre Windows Services y Worker Services

He aquí una tabla comparativa:

Aspecto	Windows Services (.NET Framework)	Worker Services (.NET moderno)
Plataforma	Solo Windows	Multiplataforma (Windows, Linux, macOS)
Modelo de ejecución	Servicio del sistema administrado por SCM (Service Control Manager)	Host genérico de .NET (IHostedService/BackgroundService)
Instalación	Registro como servicio (sc.exe, instaladores, herramientas de administración)	Ejecutable de consola, servicio de Windows, systemd, contenedor
Integraciones	Limitadas; sin DI/Logging nativo del host de .NET	DI, configuración, logging, health checks, extensiones de .NET
Casos típicos	Procesos en background en entornos Windows/legacy	Trabajos en background portables, cloud-native, contenedores
Plantillas oficiales	Enfoque clásico de .NET Framework	Plantilla “Worker Service” en .NET
Mantenimiento	Dependiente de Windows y SCM	Observabilidad moderna, despliegues flexibles

Worker Services son la evolución moderna de Windows Services.

Creando un Worker Service

Para crear un Worker Service usaremos la herramienta dotnet. Ese servicio se ejecuatrá cada 5 segundos y mostrará un mensaje.

1. Crear el proyecto Worker:

$ dotnet new worker -n MiWorkerService

2. Nos ubicamos en el directorio creado:

$ cd MiWorkerService

3. Editamos la clase Worker.cs

using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace MiWorkerService;

public class Worker : BackgroundService
{
    private readonly ILogger<Worker> _logger;

    public Worker(ILogger<Worker> logger)
    {
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogInformation("Worker ejecutándose a las: {time}", DateTimeOffset.Now);
            await Task.Delay(5000, stoppingToken);
        }
    }
}

4. Editamos el programa principal Program.cs

using MiWorkerService;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

IHost host = Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        services.AddHostedService<Worker>();
    })
    .Build();

await host.RunAsync();

5. Ejecutar proyecto:

$ dotnet build
$ dotnet run

Salida:

info: MiWorkerService.Worker[0]          
Worker ejecutándose a las: 12/03/2025 21:10:34 -06:00                        
info: MiWorkerService.Worker[0]                                                          
      Worker ejecutándose a las: 12/03/2025 21:10:39 -06:00                        
info: MiWorkerService.Worker[0]                                                          
      Worker ejecutándose a las: 12/03/2025 21:10:44 -06:00

Podríamos implementarlo como un Servicio, pero será en otra ocasión.

Conclusión: un Worker Service es como un Windows Service modernizado que funciona en cualquier plataforma y listo para ser implementado en la Nube y/o Docker.

Enlaces:

https://learn.microsoft.com/es-es/dotnet/core/extensions/workers
https://medium.com/@adebanjoemmanuel01/running-a-worker-service-as-a-windows-service-c1d12a28a73c
https://web.valuesite.cl/index.php/2024/11/25/la-utilizacion-de-worker-service-para-servicios-automaticos-vs-frameworks/
https://learn.microsoft.com/es-es/dotnet/core/extensions/windows-service

Crow: un framework para C++

Crow es un microframework de C++ para crear servicios web HTTP o Websocket. Utiliza enrutamiento similar al de Flask de Python. Se considera sumamente rápido y eficiente.

Veamos un ejemplo

holamundo.cpp

#include "crow.h"

int main()
{
    crow::SimpleApp app;

    CROW_ROUTE(app, "/")([](){
        return "Hola, mundo";
    });

    app.port(18080).run();
}

Este código en C++ expone un sencillo servicio que imprime el famoso "Hola, mundo".

Requisitos para instalarlo:

• Git.
• Python (versión 3).
• CMake.
• VsCode con soporte a C++.
• VCPKG.

Validamos si tenemos Git:

$ git --version

Validamos si tenemos Python:

$ python --version

Validamos si tenemos CMake:

$ cmake --version

Ahora instalaremos VCPKG. Abrimos una terminal y tecleamos este comando git para clonar el repo.

$ git clone https://github.com/microsoft/vcpkg.git

Nos ubicamos en la carpeta:

$ cd vcpkg

Ejecutamos estos archivos:

$ bootstrap-vcpkg.bat
$ vcpkg integrate install

Si todo va bien, clonaremos el repo de Crow (antes sal del directorio de vcpkg):

$ git clone https://github.com/CrowCpp/Crow.git

Nos ubicamos en el directorio de Crow:

$ cd Crow

Buscar el directorio de ``scripts``. Ejecuta estos comandos:

$ python merge_all.py ..\include crow_all.h

Si todo va bien, salimos del directorio de Crow y creamos un proyecto C++ vacío:

$ mkdir proyecto-crow
$ cd proyecto-crow

Copiamos los archivos ``crow_all.h``, ``example_with_all.cpp`` y ``vcpkg.json`` del directorio Crow al directorio del proyecto nuevo. Además agregamos ``crow_all.h`` como archivo de encabezado y ``example_with_all.cpp`` como archivo fuente.

El directorio quedará de este modo:

proyecto-crow/ 
   crow_all.h
   example_with_all.cpp
   vcpkg.json

Abrimos nuestro Visual Studio Code. Editamos el nombre del archivo C++ para denominarlo ``holamundo.cpp``. Sustituimos el contenido por este otro:

#include "crow.h"

int main()
{
    crow::SimpleApp app;

    CROW_ROUTE(app, "/")([](){
        return "Hola, mundo";
    });

    app.port(18080).run();
}

Debemos hacer una instalación más. Nos ubicamos en el directorio de vcpkg y ejecutamos este comando:

$ vcpkg install asio

Lanzamos otro comando:

$ vcpkg integrate install

Con esto nos permitira instalar la librería asio. Necesaria para nuestra aplciación. Regresamos al directorio del proyecto (proyecto-crow) y creamos el ejecutable:

$ g++ holamundo.cpp -o holamundo.exe

Si todo va bien, creará el ejecutable. Otra forma es con Visual Studio Code. 

Abrimos el navegador en la ruta: http://localhost:18080/

Con el mensaje de "Hola, mundo".

Conclusión: este es uno de los 101010100 frameworks web que prometen la panacea universal; resolver todos los problemas que los demás frameworks prometieron hace miles de años. Se ve interesante, pero en el mundo laboral difícilmente se optaría abandonar algún desarrollo en, digamos Spring Boot, por este. Además de ser para C++. Para ello se optarían otros lenguajes como Java, Python o C#.

Enlaces:

https://crowcpp.org

Ktor: un framework para aplicaciones asincrónicas

Ktor es un framework para aplicaciones asincrónicas del lado del servidor y del lado del cliente. Su lenguaje de programación base es Kotlin.

Nos permite crear microservicios hasta todo tipo de aplicaciones cliente HTTP multiplataforma. Veamos un ejemplo de código en Ktor:

fun main() {
	embeddedServer(Netty, port = 8000) {
		routing {
			get ("/") {
				call.respondText("Hola, mundo!")
			}
		}
	}.start(wait = true)
}

¿Cómo comenzar? Simple, iremos al sitio: https://start.ktor.io/

En el Project Artifact colocaremos: com.inforhomex.ktor-helloword

El sitio te permite colocar plugins y ver un preview del proyecto a descargar:

Damos clic en el botón Download para descargar el proyecto. Lo descomprimimos y lo colocamos en algún directorio de nuestra máquina.

Es importante tener Gradle instalado. Pues con este construiremos el proyecto y echaremos a andar.

Abrimos la clase principal del proyecto creado

Application.kt

package com.inforhomex

import io.ktor.server.application.*

fun main(args: Array<String>) {
    io.ktor.server.netty.EngineMain.main(args)
}

fun Application.module() {
    configureRouting()
}

Editamos la clase ``Routing.kt``

package com.inforhomex

import io.ktor.server.application.*
import io.ktor.server.response.*
import io.ktor.server.routing.*

fun Application.configureRouting() {
    routing {
        get("/") {
            call.respondText("Hola, mundo!")
        }
    }
}

Podemos usar Visual Studio Code:

Compilando y ejecutando el proyecto.

Abrimos una terminal y nos ubicamos en el proyecto:

$ gradle build

Con esto construimos el proyecto y ahora lo ejecutamos:

$ gradle run

Si todo va bien, abrimos un navegador en la ruta: http://127.0.0.1:8080

Salida:

Hola, mundo!

¡Hemos creado nuestra primera aplicación sencilla con Ktor!

Continuaremos con este tema en próximas entregas.

Enlaces:

https://ktor.io/

Conociendo Apache Tapestry

Según el sitio oficial, Tapestry es: un framework orientado a componentes para la creación de aplicaciones web altamente escalables en Java.

Como buen framework promete:

• Ser altamente productivo. 
• Implementar eficientemente el manejo de errores. 
• Inyección de dependencia. 
• Configuración vía anotaciones. 
• Alta escalabilidad. 
• Compatibilidad con Selenium. 
• Con una arquitectura abierta y extensible. 
• Java puro, sin reflexión. 
• Puedes usar Java, Groovy o Scala como lenguaje de programación base.

Se puede descargar desde us sitio oficial: https://tapestry.apache.org/download.html

También se puede crear un proyecto usando Maven. La dependencia es la siguiente:

<dependency>
  <groupId>org.apache.tapestry</groupId>
  <artifactId>tapestry-core</artifactId>
  <version>5.8.7</version>
</dependency>

Creando un proyecto con Tapestry

Requisitos:

1. Tener Maven instalado. 
2. Tener Java 21 o más instalado.

Abrimos una terminal y tecleamos:

$ mvn archetype:generate -Dfilter=org.apache.tapestry:quickstart

Donde:

groupId= com.inforhomex
artifactId= tapestry-demo
version= 1.0-SNAPSHOT
package= com.inforhomex.demo
packageInPathFormat= com/inforhomex/demo
package= com.inforhomex.demo
groupId= com.inforhomex
artifactId= tapestry-demo
version= 1.0-SNAPSHOT

Nos ubicamos en el proyecto creado:

$ cd tapestry-demo

Ejecutamos la aplicación con Jetty:

$ mvn jetty:run

Abrimos el navegador en la ruta: http://localhost:8080/

Con esto hemos creado nuestra primera aplicación con Tapestry.

También podemos optar por clonar el proyecto base y probar las aplicaciones que vienen:

$ git clone https://github.com/apache/tapestry-5.git
$ cd tapestry-5

Nota: es necesario contar con Gradle instalado.

En conclusión: Tapestry es un framework Java para desarrollo web que se enfoca en componentes reutilizables y una arquitectura elegante. Sin embargo existen otros framework que a mi criterio llevan la delantera como Spring Framework con su Spring Boot, Quarkus, Micronaut y hasta Helidon.

Enlaces:

https://tapestry.apache.org/
https://github.com/apache/tapestry-5

Apache Camel: un framework para integración de sistemas y datos

 

Apache Camel es un framework de integración de código abierto basado en Java que facilita la conexión y comunicación entre diferentes sistemas, aplicaciones o servicios mediante patrones de integración empresarial (EIP). Permite definir rutas de procesamiento de mensajes de forma sencilla, soportando múltiples protocolos y formatos de datos. Además de integraciones más complejas, como conectar APIs o bases de datos.

Nos sirve para:

• Integración de sistemas: Conecta aplicaciones heterogéneas (ej. bases de datos, APIs, colas de mensajes). 
• Transformación de datos: Convierte formatos (XML, JSON, etc.). 
• Enrutamiento de mensajes: Dirige datos entre sistemas según reglas definidas. 
• Soporte de protocolos: Integra con HTTP, FTP, JMS, Kafka, y más.
• Automatización: Simplifica flujos de trabajo complejos.

Aunque está diseñado principalmente para entornos Java y se integra bien con aplicaciones basadas en JVM, también soporta otros lenguajes y entornos gracias a su flexibilidad y componentes.

Hagamos un sencillo ejemplo. Un simple "Hola, mundo". Primero debemos tener instalado:

1. JDK 8 o una versión mayor. 
2. Maven en su última versión.

Crear un proyecto Maven y agregar esta dependencia al pom.xml:

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-core</artifactId>
    <version>4.8.0</version>
</dependency>

Podemos crear el proyecto con estos comandos:

$ mvn archetype:generate -DgroupId=com.codemonkey -DartifactId=HolaMundo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Creamos una clase Java:

HolaMundoCamel.java

import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.main.Main;

public class HolaMundoCamel {
    public static void main(String[] args) throws Exception {
        Main camel = new Main();
        camel.configure().addRoutesBuilder(new RouteBuilder() {
            @Override
            public void configure() {
                from("timer:hello?period=2000")
                    .setBody(constant("Hola, Mundo"))
                    .to("log:output");
            }
        });
        camel.run();
    }
}

Construimos el proyecto:

$ mvn clean install

Ejecutamos:

$ mvn exec:java -Dexec.mainClass="HolaMundoCamel"

Cada 2 segundos se mostrará este mensaje:

[main] output INFO  Exchange[ExchangePattern: InOnly, Body: Hola, Mundo]

Apache Camel también se puede usar con Spring Boot y Quarkus.

Enlaces:

https://camel.apache.org/

Un framework web ligero para PHP: CodeIgniter

Según el sitio oficial:

CodeIgniter es un potente framework PHP de tamaño muy reducido, creado para desarrolladores que necesitan un conjunto de herramientas simple y elegante para crear aplicaciones web con todas las funciones.

Características:

• Ligero: footprint pequeño (~2MB). 
• MVC: soporta el patrón Modelo-Vista-Controlador. 
• Fácil configuración: mínima configuración inicial. 
• Rendimiento: optimizado para alta velocidad. 
• Seguridad: incluye herramientas para proteger contra CSRF, XSS, y validación de datos. 
•  Documentación clara: guías detalladas y comunidad activa. 
•  Flexibilidad: no impone estructuras rígidas, compatible con PHP 7.4+.

Como ya es habitual en este blog crearemos un sencillo ejemplo usando ahora este micro framework.

Usaremos Composer para crear el proyecto.

Creando un proyecto con CodeIgniter(y Composer)

Creamos el proyecto:

$ composer create-project codeigniter4/appstarter hola-mundo

Nos ubicamos en el directorio creado:

$ cd hola-mundo

Copiamos el archivo env a .env

$ cp env .env

Editamos el archivo .env y descomentamos y ajustamos la variable app.baseURL para que quede de la siguiente manera:

app.baseURL = 'http://localhost:8080'

Ejecutamos la aplicación:

$ php spark serve

Abrimos el navegador en la dirección:

http://localhost:8080

¡Hemos creado nuestra primera aplicación usando CodeIgniter y Compose!

En algunos casos deberás editar el archivo php.ini y descomentar extension=intl (quitando el ;) :

extension=intl

Ejecutar este comando e iniciar de nuevo el server:

$ compose install
$ php spark serve

Enlaces:

https://www.codeigniter.com/