LabHub

Blog

EAI (Enterprise Application Integration) Complete Guide: Everything About Enterprise System Integration

2026-03-23 · 23 min read · #eai#enterprise-integration#middleware#esb#api-gateway#mulesoft#kafka#microservices#soa#integration-patterns#2026-03

한국어English日本語

Introduction

Most enterprises do not run on a single system. Dozens to hundreds of applications operate simultaneously -- ERP, CRM, WMS, HR, and accounting systems, to name a few. The problem is that these systems use different vendors, different technology stacks, and different data formats. EAI (Enterprise Application Integration) is the technology and strategy that ties these heterogeneous systems together into one cohesive ecosystem.

This guide covers EAI from A to Z: history and core concepts, four integration topologies, Gregor Hohpe's Enterprise Integration Patterns, major platform comparisons, and a hands-on project.

1. What Is EAI?

1-1. The Need for Enterprise System Integration: The Silo Problem

As companies grow, data silos naturally emerge:

When each system operates independently, the following problems arise:

  1. Data inconsistency: Customer address updated in CRM but not reflected in ERP
  2. Increased manual work: Download CSV and manually upload to another system
  3. Lack of real-time data: Must log into WMS separately to check inventory
  4. Wasted costs: Duplicate entry of the same data across multiple systems

EAI breaks down these silos and integrates data and processes across systems automatically, in real-time, and reliably.

1-2. History of EAI

The evolution of EAI mirrors the development of enterprise IT infrastructure:

EraIntegration MethodKey TechnologiesCharacteristics
Early 1990sPoint-to-PointCustom code, FTPIndividual connections, spaghetti
Late 1990sHub-and-SpokeTIBCO, IBM MQCentral hub management
2000sESBMuleSoft ESB, Oracle ESB, IBM IIBDistributed bus, SOA
2010sAPI-LedREST API, API GatewayMicroservices era
2020sEvent-Driven + iPaaSKafka, Workato, MuleSoft AnypointEvent-driven, cloud-native

1-3. EAI vs SOA vs Microservices vs API Management

These four concepts are frequently confused. Let's clarify their relationship:

EAI (Integration Strategy)
├── SOA (Architecture Style)
│   └── Microservices (SOA Evolution)
├── API Management (API Management Layer)
├── Message Broker (Async Integration)
└── iPaaS (Cloud Integration Platform)

1-4. Integration Market Size

The EAI/integration market continues to grow steadily:

2. Four EAI Integration Topologies

2-1. Point-to-Point

The most primitive integration approach. System A connects directly to System B.

System A ←→ System B
System A ←→ System C
System B ←→ System C
System A ←→ System D
System B ←→ System D
System C ←→ System D

Connection formula: For N systems, N*(N-1)/2 connections needed

This is called spaghetti architecture. Maintenance becomes a nightmare.

When is it acceptable?

2-2. Hub-and-Spoke

All systems connect through a central Hub.

         System A
            |
System D ── HUB ── System B
            |
         System C

Advantages:

Disadvantages:

Representative products: IBM WebSphere Message Broker, TIBCO BusinessWorks

2-3. ESB (Enterprise Service Bus)

ESB emerged to solve the single point of failure problem of Hub-and-Spoke. It uses a distributed bus architecture.

System A ── Adapter ──┐
                      │
System B ── Adapter ──┼── ESB (Distributed Message Bus) ──┼── Adapter ── System E
                      │                                    │
System C ── Adapter ──┘                                    └── Adapter ── System F

Core ESB capabilities:

  1. Message routing: Delivers messages to appropriate destinations
  2. Protocol transformation: Converts between SOAP/REST/JMS/FTP protocols
  3. Data transformation: Converts between XML/JSON/CSV data formats
  4. Orchestration: Composes multiple service calls in sequence
  5. Security: Authentication/authorization, message encryption
  6. Monitoring: Message tracing, performance monitoring

Major ESB products:

Why ESB is declining:

2-4. API-Led Connectivity (Modern Approach)

A modern integration methodology proposed by MuleSoft. Uses a 3-tier API architecture.

[Mobile/Web/Partners]
       │
  Experience API (Channel-specific)
       │
   Process API (Business logic composition)
       │
   System API (Backend system abstraction)
       │
[SAP / Salesforce / DB / Legacy]

3-tier explanation:

Modern hybrid: API Gateway + Event Mesh

[Clients]
    │
API Gateway (Synchronous requests)
    │                    Event Mesh (Asynchronous events)
    ├── REST API ───────── Kafka / EventBridge
    └── GraphQL             │
                     ┌──────┼──────┐
                  Service A  Service B  Service C

Comparison: Four Topologies

AspectPoint-to-PointHub-and-SpokeESBAPI-Led
ComplexityExplodes with system countMediumHighMedium
ScalabilityVery lowLowMediumHigh
Failure impactIndividual connectionsFull outage if hub downPartialIsolated by tier
MaintenanceVery difficultMediumDifficultEasy
Cloud fitnessLowLowLowHigh
CostLow initial, high long-termMediumHighMedium
Recommended forSmall-scale temporaryMid-size on-premiseLegacy SOAModern cloud/MSA

3. Enterprise Integration Patterns (EIP) -- The Gregor Hohpe Bible

Published in 2003 by Gregor Hohpe and Bobby Woolf, Enterprise Integration Patterns is considered the bible of EAI. This book systematically organizes 65 messaging patterns and remains the theoretical foundation for nearly every integration framework -- Apache Camel, Spring Integration, MuleSoft -- even 20+ years later.

3-1. Message Channel

A pipeline for delivering data between applications.

// Apache Camel - Message Channel definition
from("jms:queue:orders")       // Input channel
    .to("jms:queue:validated"); // Output channel

Channel types:

3-2. Message Router

Routes messages to appropriate channels based on conditions.

Content-Based Router

Analyzes message content to determine routing.

// Apache Camel - Content-Based Router
from("jms:queue:orders")
    .choice()
        .when(xpath("/order/country = 'US'"))
            .to("jms:queue:orders-us")
        .when(xpath("/order/country = 'EU'"))
            .to("jms:queue:orders-eu")
        .when(xpath("/order/country = 'APAC'"))
            .to("jms:queue:orders-apac")
        .otherwise()
            .to("jms:queue:orders-other")
    .end();

Message Filter

Passes only messages that match a condition.

// Apache Camel - Message Filter
from("jms:queue:orders")
    .filter(xpath("/order/amount > 10000"))
    .to("jms:queue:high-value-orders");

3-3. Message Translator

Converts between different data formats.

// Apache Camel - XML to JSON transformation
from("jms:queue:orders-xml")
    .unmarshal().jacksonXml(Order.class)
    .marshal().json(JsonLibrary.Jackson)
    .to("jms:queue:orders-json");

3-4. Splitter and Aggregator

Splitter: Breaks a single message into multiple messages.

// Apache Camel - Splitter
from("jms:queue:batch-orders")
    .split(xpath("/orders/order"))
    .to("jms:queue:single-order");

Aggregator: Combines multiple messages into one.

// Apache Camel - Aggregator
from("jms:queue:single-order-result")
    .aggregate(header("batchId"), new OrderAggregationStrategy())
    .completionSize(10)
    .completionTimeout(5000)
    .to("jms:queue:batch-result");

3-5. Dead Letter Channel

Stores failed messages separately for later processing.

// Apache Camel - Dead Letter Channel
errorHandler(deadLetterChannel("jms:queue:dead-letters")
    .maximumRedeliveries(3)
    .redeliveryDelay(1000)
    .retryAttemptedLogLevel(LoggingLevel.WARN));

from("jms:queue:orders")
    .process(exchange -> {
        // Processing logic - automatically sent to DLC on failure
        Order order = exchange.getIn().getBody(Order.class);
        orderService.process(order);
    })
    .to("jms:queue:processed-orders");

3-6. Idempotent Consumer

Ensures identical results even when the same message is received multiple times. Prevents duplicate processing during network retransmissions or system restarts.

// Apache Camel - Idempotent Consumer (memory-based)
from("jms:queue:orders")
    .idempotentConsumer(
        header("orderId"),
        MemoryIdempotentRepository.memoryIdempotentRepository(200)
    )
    .to("jms:queue:unique-orders");

// Redis-based idempotency (recommended for production)
from("jms:queue:orders")
    .idempotentConsumer(
        header("orderId"),
        new RedisIdempotentRepository(redisTemplate, "processed-orders")
    )
    .to("jms:queue:unique-orders");

3-7. Wire Tap

Copies messages to a separate destination without interfering with the main message flow. Used for logging, auditing, and monitoring.

// Apache Camel - Wire Tap
from("jms:queue:orders")
    .wireTap("jms:queue:order-audit")    // Audit copy
    .to("jms:queue:order-processing");   // Main flow continues

3-8. EIP Pattern Summary

PatternPurposeUse Case
Content-Based RouterContent-based routingRoute orders by country
Message FilterConditional filteringProcess only high-value orders
SplitterMessage splittingBreak batch into individual items
AggregatorMessage aggregationCombine individual results into response
Dead Letter ChannelFailed message storageReprocessing/analysis
Idempotent ConsumerDuplicate preventionPrevent duplicate order processing
Wire TapNon-intrusive copyingAudit logging
Publish-Subscribe1:N deliveryEvent broadcasting
Message TranslatorFormat conversionXML to JSON
Routing SlipDynamic routingMulti-step processing by order type

4. Data Integration Patterns

4-1. Canonical Data Model (CDM)

When exchanging data between N systems, instead of each system knowing every other system's format, all systems convert to and from one standard format (CDM).

Without CDM (N:N mapping):
SAP (IDOC) <-> Salesforce (SOQL)
SAP (IDOC) <-> WMS (CSV)
Salesforce (SOQL) <-> WMS (CSV)
= 3 mappings (for 3 systems)

With CDM (N:1 mapping):
SAP (IDOC) -> CDM (JSON) -> Salesforce
WMS (CSV) -> CDM (JSON) -> Salesforce
SAP (IDOC) -> CDM (JSON) -> WMS
= Only 1 mapping per system to/from CDM

CDM design principles:

  1. Neutrality: Schema not biased toward any specific system
  2. Extensibility: CDM can be extended when adding new systems
  3. Version management: Schema versioning is essential
  4. Documentation: Specify field meanings, data types, and constraints
{
  "canonicalOrder": {
    "orderId": "ORD-2026-001",
    "orderDate": "2026-03-23T10:30:00Z",
    "customer": {
      "customerId": "CUST-001",
      "name": "John Smith",
      "email": "john@example.com"
    },
    "items": [
      {
        "productId": "PROD-100",
        "productName": "Laptop",
        "quantity": 2,
        "unitPrice": 1200.0,
        "currency": "USD"
      }
    ],
    "totalAmount": 2400.0,
    "status": "CREATED"
  }
}

4-2. Data Format Comparison

FormatUse CaseAdvantagesDisadvantages
XMLEnterprise (SOAP, ESB)Schema validation (XSD), mature ecosystemVerbose, slow parsing
JSONREST API, WebLightweight, readable, fast parsingWeak schema validation
CSVBatch data, reportsSimple, universalStructural limits, no types
EDIB2B e-commerceIndustry standard (EDIFACT, X12)Complex, legacy
ProtobufgRPC, high-performanceVery small and fast, enforced schemaNot human-readable
AvroKafka, big dataSchema evolution, Kafka-optimizedLimited ecosystem

4-3. Data Mapping Tools

XSLT (XML Transformation)

<!-- XSLT to transform SAP IDOC to CDM -->
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="/ORDERS05">
    <canonicalOrder>
      <orderId><xsl:value-of select="IDOC/E1EDK01/BELNR"/></orderId>
      <orderDate><xsl:value-of select="IDOC/E1EDK01/DATUM"/></orderDate>
      <customer>
        <customerId><xsl:value-of select="IDOC/E1EDKA1/PARVW"/></customerId>
        <name><xsl:value-of select="IDOC/E1EDKA1/NAME1"/></name>
      </customer>
    </canonicalOrder>
  </xsl:template>
</xsl:stylesheet>

DataWeave (MuleSoft)

%dw 2.0
output application/json
---
{
  canonicalOrder: {
    orderId: payload.ORDERS05.IDOC.E1EDK01.BELNR,
    orderDate: payload.ORDERS05.IDOC.E1EDK01.DATUM as Date,
    customer: {
      customerId: payload.ORDERS05.IDOC.E1EDKA1.PARVW,
      name: payload.ORDERS05.IDOC.E1EDKA1.NAME1
    },
    items: payload.ORDERS05.IDOC.E1EDP01 map ((item) -> {
      productId: item.MATNR,
      quantity: item.MENGE as Number,
      unitPrice: item.NETPR as Number
    })
  }
}

JSONata (Lightweight JSON Transformation)

{
  "canonicalOrder": {
    "orderId": sapOrder.BELNR,
    "orderDate": sapOrder.DATUM,
    "customer": {
      "customerId": sapOrder.PARVW,
      "name": sapOrder.NAME1
    },
    "totalAmount": $sum(sapOrder.items.(MENGE * NETPR))
  }
}

4-4. Master Data Management (MDM)

MDM is a strategy for maintaining a Single Source of Truth for core data (customers, products, organizations) across the entire enterprise.

Why MDM matters for EAI:

4-5. CDC (Change Data Capture) - Debezium

CDC detects database changes in real-time and propagates them to other systems. Debezium is a leading open-source CDC solution.

# Debezium connector configuration (MySQL)
name: mysql-connector
config:
  connector.class: io.debezium.connector.mysql.MySqlConnector
  database.hostname: mysql-server
  database.port: 3306
  database.user: debezium
  database.password: secret
  database.server.id: 1
  topic.prefix: myapp
  database.include.list: ecommerce
  table.include.list: ecommerce.orders,ecommerce.customers
  schema.history.internal.kafka.bootstrap.servers: kafka:9092
  schema.history.internal.kafka.topic: schema-changes

[MySQL DB] -> [Debezium Connector] -> [Kafka Topic] -> [Consumer App]
                                                      -> [Elasticsearch]
                                                      -> [Data Warehouse]

CDC advantages:

5. EAI Platform Comparison (2025)

5-1. MuleSoft Anypoint Platform

The undisputed enterprise integration leader, owned by Salesforce.

Core components:

Advantages:

Disadvantages:

5-2. Apache Camel + Spring Boot

The gold standard of open-source integration frameworks. Fully implements Gregor Hohpe's EIP in code.

// Spring Boot + Apache Camel example
@Component
public class OrderIntegrationRoute extends RouteBuilder {

    @Override
    public void configure() throws Exception {
        // Error handling
        errorHandler(deadLetterChannel("kafka:dead-letters")
            .maximumRedeliveries(3)
            .redeliveryDelay(2000));

        // Receive orders from SAP -> transform -> send to CRM
        from("sap-idoc:ORDERS05")
            .routeId("sap-to-crm-orders")
            .log("SAP order received: orderId=${header.orderId}")
            .unmarshal().jacksonXml(SapOrder.class)
            .bean(OrderTransformer.class, "toCanonical")
            .marshal().json(JsonLibrary.Jackson)
            .choice()
                .when(simple("${body[totalAmount]} > 100000"))
                    .to("kafka:high-value-orders")
                .otherwise()
                    .to("kafka:standard-orders")
            .end()
            .to("salesforce:upsert:Order__c?sObjectIdName=SAP_Order_Id__c");
    }
}

Key features:

Advantages:

Disadvantages:

5-3. Dell Boomi

A pioneer of cloud-native iPaaS.

Key features:

Advantages:

Disadvantages:

5-4. Workato / Tray.io

Business-user-friendly iPaaS.

Key features:

Advantages:

Disadvantages:

Platform Comparison Table

AspectMuleSoftApache CamelDell BoomiWorkato
TypeiPaaS + On-PremOpen-source frameworkiPaaSiPaaS
CostVery high (50K−50K-500K+/yr)Free (infra cost only)High ($50K+/yr)Medium ($10K+/yr)
Learning curveMedium-HighHigh (developers)LowVery low
ScalabilityVery highVery highHighMedium
CloudHybridAllCloud-firstCloud-only
CommunityLargeVery largeMediumMedium
Legacy integrationStrongVery strongMediumWeak
SaaS integrationStrongMediumStrongVery strong
Target usersDevelopers + ArchitectsDevelopersDevelopers + Non-devsNon-devs + Developers

6. Hands-On Project: ERP-CRM-WMS Integration

6-1. Scenario

A mid-size e-commerce company wants to integrate these three systems:

Integration requirements:

  1. When an order is created on the website, register it in SAP ERP
  2. After SAP confirms inventory, send shipment instruction to WMS
  3. When WMS starts shipping, update status in Salesforce
  4. All processes must be asynchronous, real-time, and fault-tolerant

6-2. Architecture Design

[Website] -> REST API -> [API Gateway]
                            │
                     [Apache Camel Hub]
                     ┌──────┼──────────┐
                     │      │          │
                  [Kafka]  [Kafka]   [Kafka]
                  orders   inventory  shipping
                     │      │          │
                [SAP ERP] [WMS]  [Salesforce CRM]
                     │      │          │
                     └──────┼──────────┘
                            │
                     [Monitoring]
                  Prometheus + Grafana

6-3. Camel Route Code (Java DSL)

@Component
public class EcommerceIntegrationRoutes extends RouteBuilder {

    @Override
    public void configure() throws Exception {

        // ===== Global Error Handling =====
        errorHandler(deadLetterChannel("kafka:dead-letter-queue")
            .maximumRedeliveries(3)
            .redeliveryDelay(2000)
            .backOffMultiplier(2)
            .useExponentialBackOff()
            .retryAttemptedLogLevel(LoggingLevel.WARN)
            .logRetryStackTrace(true));

        // ===== Step 1: Order Intake -> SAP ERP Registration =====
        from("rest:post:/api/orders")
            .routeId("order-intake")
            .log("New order received: ${body}")
            .unmarshal().json(JsonLibrary.Jackson, OrderRequest.class)
            .bean(OrderValidator.class, "validate")
            .bean(OrderTransformer.class, "toCanonical")
            .marshal().json(JsonLibrary.Jackson)
            .to("kafka:orders?brokers=localhost:9092")
            .setBody(simple("Order accepted. Order ID: ${header.orderId}"));

        // SAP ERP Order Registration
        from("kafka:orders?brokers=localhost:9092&groupId=sap-consumer")
            .routeId("sap-order-registration")
            .idempotentConsumer(
                header("orderId"),
                new RedisIdempotentRepository(redisTemplate, "sap-orders")
            )
            .unmarshal().json(JsonLibrary.Jackson, CanonicalOrder.class)
            .bean(SapOrderTransformer.class, "toSapIdoc")
            .to("sap-idoc:ORDERS05")
            .log("SAP order registration complete: ${header.orderId}")
            .to("kafka:inventory-check?brokers=localhost:9092");

        // ===== Step 2: Inventory Check -> WMS Shipment =====
        from("kafka:inventory-check?brokers=localhost:9092&groupId=wms-consumer")
            .routeId("inventory-check-and-ship")
            .unmarshal().json(JsonLibrary.Jackson, CanonicalOrder.class)
            .bean(InventoryService.class, "checkAvailability")
            .choice()
                .when(simple("${header.inventoryAvailable} == true"))
                    .log("Inventory available: ${header.orderId}")
                    .bean(WmsTransformer.class, "toShipmentRequest")
                    .to("http://wms-api.internal:8080/api/shipments")
                    .to("kafka:shipping-started?brokers=localhost:9092")
                .otherwise()
                    .log("Inventory shortage: ${header.orderId}")
                    .to("kafka:backorder-queue?brokers=localhost:9092")
            .end();

        // ===== Step 3: Shipping Started -> Salesforce Status Update =====
        from("kafka:shipping-started?brokers=localhost:9092&groupId=crm-consumer")
            .routeId("crm-status-update")
            .unmarshal().json(JsonLibrary.Jackson, ShipmentEvent.class)
            .bean(SalesforceTransformer.class, "toOpportunityUpdate")
            .to("salesforce:upsert:Opportunity?sObjectIdName=Order_Id__c")
            .log("Salesforce status update complete: ${header.orderId}");

        // ===== Circuit Breaker =====
        from("kafka:critical-orders?brokers=localhost:9092")
            .routeId("circuit-breaker-route")
            .circuitBreaker()
                .resilience4jConfiguration()
                    .failureRateThreshold(50)
                    .waitDurationInOpenState(30000)
                    .slidingWindowSize(10)
                .end()
                .to("http://payment-service:8080/api/process")
            .onFallback()
                .log("Payment service failure - executing fallback")
                .to("kafka:payment-retry-queue?brokers=localhost:9092")
            .end();
    }
}

6-4. Monitoring Setup

# docker-compose-monitoring.yml
version: '3.8'
services:
  prometheus:
    image: prom/prometheus:latest
    ports:
      - '9090:9090'
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

  grafana:
    image: grafana/grafana:latest
    ports:
      - '3000:3000'
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin

  # Camel metrics exposure
  camel-app:
    build: .
    ports:
      - '8080:8080'
      - '8081:8081' # Actuator/Prometheus metrics
    environment:
      - MANAGEMENT_ENDPOINTS_WEB_EXPOSURE_INCLUDE=health,prometheus
      - MANAGEMENT_METRICS_EXPORT_PROMETHEUS_ENABLED=true

Key monitoring metrics:

7. EAI and Modern Architecture Convergence

7-1. EAI + Microservices

EAI does not disappear in a microservices environment. Rather, it evolves into Service Mesh and Event Mesh.

[Microservice A] ──── API Gateway (Sync) ──── [Microservice B]
        │                                              │
        └──── Event Mesh (Kafka/EventBridge) ──────────┘
                          │
                   [Legacy ERP]  <- Apache Camel Adapter

Key patterns:

7-2. EAI + Cloud

In cloud environments, EAI evolves into iPaaS and serverless.

On-Premise EAICloud EAI
ESB server managementiPaaS (managed)
Self-managed message queuesAmazon SQS / Azure Service Bus
Self-managed monitoringCloudWatch / Datadog
Manual scalingAuto-scaling
CAPEX-centricOPEX (pay-as-you-go)

AWS-based Serverless EAI Architecture:

[External System] -> API Gateway -> Lambda (Transform) -> EventBridge -> Step Functions
                                                                           │
                                                                ┌──────────┼──────────┐
                                                             Lambda A   Lambda B   Lambda C
                                                             (SAP)     (SF)       (WMS)
                                                                │         │         │
                                                                └─────────┼─────────┘
                                                                          │
                                                                    DynamoDB (State)
                                                                          │
                                                                CloudWatch (Monitoring)

7-3. EAI + AI

Innovations AI brings to EAI:

  1. Automatic data mapping: AI suggests source-to-target field mappings automatically
  2. Anomaly detection: Automatically detects abnormal patterns in integration pipelines
  3. Self-healing: AI executes automatic recovery strategies when failures occur
  4. Natural language integration: Say "Sync SAP orders to Salesforce" and pipelines are generated automatically

7-4. EAI + MCP (Model Context Protocol)

MCP, which emerged in 2025, is a protocol that enables AI agents to communicate with external tools in a standardized way. When EAI and MCP combine, AI agents can directly orchestrate EAI pipelines.

[AI Agent (Claude, GPT)]
        │
    MCP Protocol
        │
[MCP Server: EAI Orchestrator]
    ├── Tool: createIntegrationFlow
    ├── Tool: monitorPipeline
    ├── Tool: triggerDataSync
    └── Tool: debugFailedMessages
        │
[Apache Camel / MuleSoft / AWS Step Functions]

Future scenario:

8. EAI in Korean Enterprises

8-1. Major Korean EAI Solutions

Korean enterprises use a mix of global and domestic solutions.

SolutionDeveloperMajor ClientsFeatures
NexledgerSamsung SDSSamsung GroupBlockchain integration, Samsung ecosystem optimization
LG CNS EAILG CNSLG GroupLG Group internal standard
SK C&C EAISK C&CSK GroupSK Group infrastructure integration
X-PlatformTOBESOFTFinance, Public sectorUI/UX strength, legacy connectivity
AnyLinkBizFlowFinance, ManufacturingHigh market share in Korean finance

8-2. eGovFrame and ESB

Korean public institutions build systems based on the eGovFrame (Electronic Government Framework).

8-3. Financial Sector EAI

Korean financial sector EAI has a unique structure:

[Internet Banking] ──┐
[Mobile Banking]  ───┤── MCI ── EAI ── Core Banking
[ATM]             ───┤                   │
[Teller System]   ───┘              ├── CRM
                                    ├── Risk
                                    └── FEP -> KFTC/Card Companies/Insurers

Financial EAI special requirements:

8-4. Public Institution Integration

Practice Quiz

Q1. Point-to-Point Connection Count

How many connections are needed to connect 10 systems using Point-to-Point?

View Answer

45 connections

Formula: N _ (N-1) / 2 = 10 _ 9 / 2 = 45

This is exactly why Point-to-Point is unsuitable for large-scale systems. Hub-and-Spoke would need only 10 connections.

Q2. Why ESB Is Declining

What is the most fundamental reason ESB (Enterprise Service Bus) is declining in modern architecture?

View Answer

The ESB itself becomes a monolithic bottleneck.

As all integration logic concentrates in the ESB, it becomes a massive monolith. Changing one integration flow can affect others, and deployment becomes difficult. This directly conflicts with the microservices philosophy of independent deployment and distributed autonomy.

The modern alternative is the API-Led Connectivity + Event Mesh combination.

Q3. Idempotent Consumer Pattern

When the same order message is delivered 3 times from a message broker, what EIP pattern prevents duplicate processing, and what is the key implementation detail?

View Answer

Idempotent Consumer pattern

Key implementation:

  1. Check whether a message has already been processed based on a unique identifier (e.g., orderId)
  2. Store processed message IDs in a repository (Redis, DB, memory)
  3. Skip messages with duplicate IDs

In Apache Camel, this is simply implemented using the idempotentConsumer() DSL. For production, use Redis or DB-based repositories to handle distributed environments.

Q4. CDM (Canonical Data Model) Advantage

Compare the number of mappings needed with and without CDM when exchanging data between 5 systems.

View Answer

Without CDM: Each system must know every other system's format, requiring N _ (N-1) = 5 _ 4 = 20 mappings (bidirectional)

With CDM: Each system only converts to/from CDM, requiring N _ 2 = 5 _ 2 = 10 mappings (system-to-CDM, CDM-to-system)

With CDM, adding a new system only requires 2 additional mappings (to CDM and from CDM).

Q5. MuleSoft vs Apache Camel

A startup (3 developers, limited budget) needs to integrate SAP with Shopify. Would you recommend MuleSoft or Apache Camel?

View Answer

Apache Camel + Spring Boot is recommended.

Reasons:

  1. Cost: MuleSoft costs $50K+ annually. Excessive for a startup. Apache Camel is free
  2. Developer-friendly: With 3 developers, code-based Camel enables faster learning and implementation
  3. Connectors: Camel has SAP component (camel-sap) and Shopify REST API integration
  4. Scalability: As systems grow, just add more Camel Routes
  5. Cloud: Easy Kubernetes deployment with Camel K

However, if non-developers need to manage integrations or the Salesforce ecosystem is central, MuleSoft may be more suitable.

References

Books

Official Documentation

EIP Reference

Cloud Integration

Market Analysis

Korean EAI

Community

Read the original: https://www.youngju.dev/blog/culture/2026-03-23-eai-enterprise-application-integration-complete-guide.en

Comments

No comments yet.

Sign in to leave a comment