Spring Integration의 기본 개념

1. Spring Integration 소개
1.1 Spring Integration의 배경과 필요성
1.2 Spring Integration의 탄생과 역사
1.3 Spring Integration의 주요 특징
1.4 Spring Integration의 기본 개념

Spring Integration for Backend Developers

 

메시지(Message): 데이터의 캡슐화

Spring Integration의 핵심 개념 중 하나는 메시지(Message)입니다. 메시지는 데이터를 캡슐화한 객체로, 시스템 간의 데이터를 안전하고 효율적으로 전달하기 위해 사용됩니다. 메시지는 단순한 데이터 전달 수단 이상으로, 통합 시스템의 모든 데이터 흐름을 구조화하는 중요한 구성 요소입니다.

1. 메시지의 정의

Spring Integration에서 메시지(Message)는 데이터의 캡슐화와 시스템 간 통신의 기본 단위를 제공합니다. Payload와 Headers로 구성된 메시지는 통합 시스템의 모든 데이터 흐름을 처리하며, 개발자가 복잡한 통합 시나리오를 효율적으로 관리할 수 있도록 지원합니다. 이를 통해 Spring Integration은 메시지 중심 아키텍처에서의 표준적인 데이터 전달 방식을 구현합니다.

 

메시지는 Spring Integration에서 데이터(payload)와 메타데이터(header)를 함께 포함하는 구조화된 객체입니다. 이를 통해 데이터 전송에 필요한 모든 정보를 하나의 객체로 처리할 수 있습니다.

Message 구조

구조

1. Payload: 메시지 본문으로, 전송하고자 하는 실제 데이터입니다.
   • 예: 문자열, JSON, XML, 객체 등 다양한 형식 지원.
2. Headers: 메시지의 부가 정보를 담는 메타데이터.
   • 예: 메시지 ID, 타임스탬프, 사용자 정의 속성.

Spring Integration에서의 메시지 인터페이스

Spring Integration의 메시지는 org.springframework.messaging.Message<T> 인터페이스를 사용하여 정의됩니다.

2. 메시지의 특징

1. 불변성
   메시지는 생성된 이후 변경할 수 없습니다. 데이터의 무결성과 안정성을 보장하기 위해 불변 객체로 설계되었습니다.
2. 유연한 데이터 구조
   다양한 형식의 데이터를 Payload에 저장할 수 있으며, Headers를 통해 부가 정보를 추가적으로 전달할 수 있습니다.
3. 독립성
   메시지는 송신자와 수신자의 구현에 의존하지 않으며, 시스템 간의 느슨한 결합(loose coupling)을 유지합니다.

3. 메시지 생성

Spring Integration에서 메시지를 생성하려면 MessageBuilder를 사용합니다. 이를 통해 메시지의 Payload와 Headers를 간편하게 설정할 수 있습니다.

 

예시: 메시지 생성

import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;

public class MessageExample {
    public static void main(String[] args) {
        // 메시지 생성
        Message<String> message = MessageBuilder.withPayload("Hello, Spring Integration!")
                .setHeader("author", "Andrew") // 사용자 정의 헤더 추가
                .setHeader("priority", "high")
                .build();

        // 메시지 출력
        System.out.println("Payload: " + message.getPayload());
        System.out.println("Headers: " + message.getHeaders());
    }
}

 

출력 결과:

Payload: Hello, Spring Integration!
Headers: {id=..., timestamp=..., author=Andrew, priority=high}

• withPayload(): 메시지 본문을 설정.
• setHeader(): 메시지 헤더에 사용자 정의 속성을 추가.

4. 메시지 처리 흐름

메시지는 Spring Integration의 메시지 채널(Message Channel)을 통해 이동하며, 다양한 엔드포인트(Endpoint)에서 처리됩니다.

 

기본 메시지 흐름

1. 생성: 송신자가 MessageBuilder로 메시지를 생성합니다.
2. 전송: 메시지는 메시지 채널을 통해 엔드포인트로 전송됩니다.
3. 처리: 엔드포인트는 메시지의 Payload를 사용하여 비즈니스 로직을 처리합니다.
4. 결과 전송: 처리 결과를 새로운 메시지로 캡슐화하여 다음 채널로 전달합니다.

예시: 간단한 메시지 흐름

@Configuration
@EnableIntegration
public class MessageFlowConfig {

    @Bean
    public MessageChannel inputChannel() {
        return new DirectChannel();
    }

    @Bean
    public MessageChannel outputChannel() {
        return new DirectChannel();
    }

    @Bean
    public IntegrationFlow messageFlow() {
        return IntegrationFlows.from("inputChannel")
                .handle(message -> System.out.println("Processing: " + message.getPayload()))
                .channel("outputChannel")
                .get();
    }
}

• 설명:
  • 메시지가 inputChannel로 전달되며, handle에서 처리된 후 outputChannel로 전달됩니다.

5. 메시지 헤더 활용

메시지 헤더는 메시지의 추가적인 정보를 저장하며, 메시지의 라우팅, 필터링, 트랜스포머 등 다양한 작업에서 활용됩니다.

헤더 활용 예시

@Bean
public IntegrationFlow headerExampleFlow() {
    return IntegrationFlows.from("inputChannel")
            .filter(message -> "high".equals(message.getHeaders().get("priority")))
            .handle(message -> System.out.println("High Priority Message: " + message.getPayload()))
            .get();
}

• 설명:
  • 메시지 헤더에 priority가 "high"인 경우에만 처리됩니다.

6. 메시지 변환(Transformation)

메시지는 전송 중에 변환될 수 있습니다. MessageTransformer 또는 SpEL(Expression Language)을 사용하여 Payload 또는 Headers를 변환할 수 있습니다.

 

예시: 메시지 변환

@Bean
public IntegrationFlow transformFlow() {
    return IntegrationFlows.from("inputChannel")
            .transform(String::toUpperCase) // 메시지 본문을 대문자로 변환
            .handle(message -> System.out.println("Transformed: " + message.getPayload()))
            .get();
}

• 설명:
  • 메시지 본문(Payload)이 대문자로 변환된 후 처리됩니다.

7. 메시지의 이점

1. 캡슐화된 데이터 구조
   데이터와 메타데이터를 하나의 객체로 관리할 수 있어 통합 작업이 간단해집니다.
2. 느슨한 결합 유지
   송신자와 수신자는 메시지를 통해 간접적으로 연결되므로 시스템 간 의존성이 줄어듭니다.
3. 유연한 데이터 처리
   다양한 형식의 데이터를 처리할 수 있으며, 필요에 따라 변환, 라우팅, 필터링이 가능합니다.
4. 확장 가능성
   메시지 구조를 변경하지 않고도 헤더를 활용하여 추가적인 기능을 구현할 수 있습니다.

728x90

메시지 채널(Message Channel): 데이터 흐름의 경로

메시지 채널(Message Channel)은 Spring Integration에서 메시지(Message)가 흐르는 경로를 의미합니다. 메시지 채널을 통해 송신자(Sender, Producer)와 수신자(Receiver, Consumer)가 분리된 상태에서 데이터를 주고받을 수 있으며, 이는 시스템 간의 느슨한 결합(loose coupling)을 유지하는 핵심 요소입니다.

---

1. 메시지 채널의 정의

메시지 채널은 Spring Integration에서 데이터 흐름의 논리적 경로를 제공하는 인터페이스입니다. 송신자는 메시지를 채널로 보내고, 수신자는 채널에서 메시지를 받습니다.

• Spring Integration은 MessageChannel 인터페이스를 기반으로 다양한 채널 구현체를 제공합니다.

---

이 이미지는 Spring Integration 또는 메시지 기반 시스템에서 Message Channel의 동작 원리를 시각적으로 표현하고 있습니다. 다음과 같은 요소가 포함되어 있습니다:

1. Producer (생산자)

• 의미: 메시지를 생성하고 채널로 보내는 주체입니다.
• 작업: send(Message) 메서드를 호출하여 메시지를 Message Channel에 전달합니다.

2. Message Channel (메시지 채널)

• 의미: 생산자(Producer)가 보낸 메시지를 소비자(Consumer)에게 전달하는 데이터 흐름 경로입니다.
• 특징:
  • 메시지 채널은 메시지를 중간에 저장하거나 전달합니다.
  • 내부적으로 큐(Queue) 또는 직접 전달을 통해 메시지를 관리합니다.
• 구조:
  • 이미지 속의 녹색 사각형은 메시지들을 나타냅니다.
  • 채널에 여러 메시지가 순차적으로 저장되어 대기 상태에 있습니다.

3. Consumer (소비자)

• 의미: 메시지 채널로부터 메시지를 가져와 처리하는 주체입니다.
• 작업: receive() 메서드를 호출하여 채널에 있는 메시지를 가져옵니다.

메시지 흐름

1. Producer가 send() 메서드를 통해 메시지를 생성하고 Message Channel에 전달합니다.
2. 메시지는 Message Channel 내부에 저장되거나 대기 상태가 됩니다.
3. Consumer가 receive() 메서드를 통해 Message Channel에서 메시지를 가져와 처리합니다.

---

2. 메시지 채널의 역할

1. 송신자와 수신자 간의 분리
   메시지 채널은 송신자와 수신자를 분리하여 서로 독립적으로 동작할 수 있게 합니다.
2. 데이터 흐름 제어
   메시지가 어디로 이동하고 어떻게 처리될지를 제어하는 중요한 역할을 수행합니다.
3. 확장성
   채널을 통해 여러 수신자에게 메시지를 동시에 전달하거나, 특정 조건에 따라 메시지를 라우팅할 수 있습니다.
4. 동기/비동기 처리 지원
   메시지 채널은 동기적 또는 비동기적 방식으로 메시지를 전달할 수 있습니다.

3. 메시지 채널의 종류

Spring Integration은 다양한 메시지 채널을 제공하며, 사용자의 요구사항에 맞게 선택할 수 있습니다.

1) DirectChannel (동기적 채널)

DirectChannel은 메시지를 동기적으로 처리하는 채널입니다. 메시지가 채널에 도착하면 즉시 연결된 수신자에게 전달됩니다.

 

특징:

• 단일 수신자만 지원 (Point-to-Point).
• 성능이 빠르지만, 수신자가 메시지를 즉시 처리해야 합니다.

예시 코드: DirectChannel 설정

@Configuration
@EnableIntegration
public class DirectChannelConfig {

    @Bean
    public MessageChannel directChannel() {
        return new DirectChannel();
    }

    @Bean
    public IntegrationFlow directFlow() {
        return IntegrationFlows.from("directChannel")
                .handle(message -> System.out.println("Received Message: " + message.getPayload()))
                .get();
    }
}

 

설명:

• DirectChannel을 생성하고, 메시지를 수신하면 즉시 핸들러에서 처리합니다.

2) QueueChannel (비동기적 채널)

QueueChannel은 메시지를 비동기적으로 전달하며, 내부에 큐(Queue)를 사용하여 메시지를 저장합니다.

 

특징:

• 메시지가 채널에 쌓이고, 수신자가 나중에 메시지를 가져와 처리합니다.
• 메시지 손실 없이 안정적인 비동기 메시징이 가능합니다.

예시 코드: QueueChannel 설정

@Configuration
@EnableIntegration
public class QueueChannelConfig {

    @Bean
    public MessageChannel queueChannel() {
        return new QueueChannel();
    }

    @Bean
    public IntegrationFlow queueFlow() {
        return IntegrationFlows.from("queueChannel")
                .handle(message -> System.out.println("Processed Queue Message: " + message.getPayload()))
                .get();
    }
}

3) PublishSubscribeChannel (브로드캐스트 채널)

PublishSubscribeChannel은 하나의 메시지를 여러 수신자에게 동시에 전달하는 채널입니다.

 

특징:

• 메시지를 복제하여 모든 수신자에게 전달합니다.
• 수신자 간 동기적 또는 비동기적으로 동작할 수 있습니다.

예시 코드: PublishSubscribeChannel 설정

@Configuration
@EnableIntegration
public class PublishSubscribeConfig {

    @Bean
    public MessageChannel publishSubscribeChannel() {
        return new PublishSubscribeChannel();
    }

    @Bean
    public IntegrationFlow publishSubscribeFlow() {
        return IntegrationFlows.from("publishSubscribeChannel")
                .handle(message -> System.out.println("Handler 1: " + message.getPayload()))
                .handle(message -> System.out.println("Handler 2: " + message.getPayload()))
                .get();
    }
}

 

설명:

• 하나의 메시지가 두 개의 핸들러로 동시에 전달됩니다.

4) ExecutorChannel (비동기적 실행 채널)

ExecutorChannel은 스레드 풀(Executor Service)을 사용하여 메시지를 비동기적으로 처리하는 채널입니다.

 

특징:

• 비동기 메시지 처리를 위해 별도의 스레드 풀을 사용합니다.
• 고성능 메시징 시 유용합니다.

예시 코드: ExecutorChannel 설정

@Configuration
@EnableIntegration
public class ExecutorChannelConfig {

    @Bean
    public MessageChannel executorChannel() {
        return new ExecutorChannel(Executors.newFixedThreadPool(5));
    }

    @Bean
    public IntegrationFlow executorFlow() {
        return IntegrationFlows.from("executorChannel")
                .handle(message -> System.out.println("Processed asynchronously: " + message.getPayload()))
                .get();
    }
}

엔드포인트(Endpoint): 데이터 처리의 핵심

Spring Integration에서 엔드포인트(Endpoint)는 메시지를 처리하거나 라우팅하는 핵심 구성 요소입니다. 메시지 채널을 통해 전달된 메시지는 엔드포인트에 도달하고, 엔드포인트에서 정의된 비즈니스 로직 또는 작업이 실행됩니다.

1. 엔드포인트의 정의

• 메시지 처리기(Message Handler): 메시지의 Payload와 Headers를 사용해 로직을 실행합니다.
• 중간 역할: 엔드포인트는 메시지를 변환, 라우팅, 필터링하거나 비즈니스 로직에 전달합니다.
• 구성 위치: 메시지 채널의 시작점 또는 끝점에 위치합니다.

2. 엔드포인트의 주요 역할

Spring Integration의 엔드포인트는 다음과 같은 작업을 수행합니다:

1. 메시지 수신
   채널에서 메시지를 가져옵니다.
2. 비즈니스 로직 실행
   메시지의 내용을 기반으로 정의된 로직을 실행합니다.
3. 메시지 변환 및 가공
   메시지를 다른 형식으로 변환하거나 수정합니다.
4. 메시지 라우팅
   메시지를 조건에 따라 다른 채널로 보냅니다.
5. 결과 반환
   처리된 메시지를 새로운 메시지로 만들어 다른 채널에 전달합니다.

3. 엔드포인트의 종류

Spring Integration은 다양한 엔드포인트 유형을 제공하며, 각 엔드포인트는 특정 작업을 수행합니다.

1) Service Activator (서비스 액티베이터)

POJO(Plain Old Java Object)의 메서드를 호출하여 메시지를 처리합니다. 비즈니스 로직 실행에 사용됩니다.

 

예시: Service Activator 설정

@Configuration
@EnableIntegration
public class ServiceActivatorConfig {

    @Bean
    public MessageChannel inputChannel() {
        return new DirectChannel();
    }

    @Bean
    @ServiceActivator(inputChannel = "inputChannel")
    public MessageHandler messageHandler() {
        return message -> System.out.println("Processing: " + message.getPayload());
    }
}

• 설명: ServiceActivator는 inputChannel에서 메시지를 가져와 핸들러에서 처리합니다.

2) Filter (필터)

메시지의 조건을 검사하여 필터링합니다. 조건에 맞는 메시지만 다음 채널로 전달합니다.

 

예시: Filter 설정

@Bean
public IntegrationFlow filterFlow() {
    return IntegrationFlows.from("inputChannel")
            .filter((String payload) -> payload.contains("Spring")) // 조건 설정
            .handle(message -> System.out.println("Filtered: " + message.getPayload()))
            .get();
}

• 설명: payload에 "Spring"이 포함된 메시지만 처리됩니다.

3) Transformer (변환기)

메시지를 다른 형식으로 변환합니다.

 

예시: Transformer 설정

@Bean
public IntegrationFlow transformerFlow() {
    return IntegrationFlows.from("inputChannel")
            .transform(String::toUpperCase) // 메시지를 대문자로 변환
            .handle(message -> System.out.println("Transformed: " + message.getPayload()))
            .get();
}

• 설명: 메시지의 본문(Payload)을 대문자로 변환합니다.

4) Router (라우터)

메시지를 조건에 따라 다른 채널로 라우팅합니다.

 

예시: Router 설정

@Bean
public IntegrationFlow routerFlow() {
    return IntegrationFlows.from("inputChannel")
            .<String, Boolean>route(payload -> payload.startsWith("High"),
                    mapping -> mapping
                            .subFlowMapping(true, sf -> sf.channel(c -> c.queue("highPriorityChannel")))
                            .subFlowMapping(false, sf -> sf.channel(c -> c.queue("normalPriorityChannel"))))
            .get();
}

• 설명: 메시지가 "High"로 시작하면 highPriorityChannel로, 그렇지 않으면 normalPriorityChannel로 라우팅됩니다.

5) Splitter (분할기)와 Aggregator (집계기)

• Splitter: 하나의 메시지를 여러 개의 메시지로 분할합니다.
• Aggregator: 여러 메시지를 다시 하나로 결합합니다.

예시: Splitter와 Aggregator 설정

@Bean
public IntegrationFlow splitAggregateFlow() {
    return IntegrationFlows.from("inputChannel")
            .split() // 메시지를 분할
            .transform(String::toUpperCase)
            .aggregate() // 메시지를 다시 결합
            .handle(message -> System.out.println("Aggregated: " + message.getPayload()))
            .get();
}

4. 엔드포인트의 동작 흐름

1. 메시지 수신: 메시지 채널을 통해 메시지를 수신합니다.
2. 데이터 처리: 엔드포인트에서 메시지 변환, 필터링, 비즈니스 로직 실행 등 다양한 작업을 수행합니다.
3. 메시지 반환: 결과 메시지를 다음 채널로 전송하거나 최종 수신자에게 전달합니다.

인바운드와 아웃바운드 어댑터(Inbound/Outbound Adapter)

Spring Integration에서 인바운드 어댑터(Inbound Adapter)와 아웃바운드 어댑터(Outbound Adapter)는 외부 시스템과의 통신을 담당하는 주요 구성 요소입니다. 이를 통해 파일, 데이터베이스, 메시지 브로커, HTTP 등 다양한 외부 리소스와 데이터를 주고받을 수 있습니다.

1. 어댑터(Adapter)란?

어댑터는 Spring Integration과 외부 시스템 간의 인터페이스 역할을 수행하며, 다음과 같이 두 가지 유형으로 구분됩니다:

• 인바운드 어댑터: 외부 시스템 → Spring Integration으로 데이터를 가져옵니다.
• 아웃바운드 어댑터: Spring Integration → 외부 시스템으로 데이터를 보냅니다.

2. 인바운드 어댑터(Inbound Adapter)

인바운드 어댑터는 외부 시스템에서 데이터를 읽어와 Spring Integration의 메시지 채널로 전달합니다. 이때 메시지는 Message 객체로 변환되어 통합 시스템에 전달됩니다.

파일(File) 인바운드 어댑터

특정 디렉터리에서 파일을 읽어와 메시지로 변환합니다.

@Configuration
@EnableIntegration
public class FileInboundAdapterConfig {

    @Bean
    public IntegrationFlow fileInboundFlow() {
        return IntegrationFlows
                .from(Files.inboundAdapter(new File("/input-directory"))
                        .patternFilter("*.txt")) // 특정 패턴 파일만 읽기
                .transform(Transformers.fileToString()) // 파일 내용을 문자열로 변환
                .handle(message -> System.out.println("File Content: " + message.getPayload()))
                .get();
    }
}

• 설명:
  • /input-directory에서 .txt 파일을 읽어옵니다.
  • 파일의 내용을 String으로 변환하여 처리합니다.

JMS 인바운드 어댑터

JMS 큐에서 메시지를 수신합니다.

@Bean
public IntegrationFlow jmsInboundFlow(ConnectionFactory connectionFactory) {
    return IntegrationFlows.from(Jms.messageDrivenChannelAdapter(connectionFactory)
                        .destination("queue.orders")) // JMS 큐 이름
                .handle(message -> System.out.println("Received JMS Message: " + message.getPayload()))
                .get();
}

• 설명: JMS 큐인 queue.orders에서 메시지를 가져옵니다.

HTTP 인바운드 어댑터

HTTP 요청을 받아 메시지로 변환합니다.

@Bean
public IntegrationFlow httpInboundFlow() {
    return IntegrationFlows.from(Http.inboundGateway("/receive"))
                .handle(message -> System.out.println("Received HTTP Message: " + message.getPayload()))
                .get();
}

• 설명: /receive 엔드포인트로 들어오는 HTTP 요청을 처리합니다.

3. 아웃바운드 어댑터(Outbound Adapter)

아웃바운드 어댑터는 Spring Integration의 메시지를 외부 시스템으로 전달합니다.
즉, 메시지 채널 → 외부 시스템의 데이터 흐름을 담당합니다.

파일(File) 아웃바운드 어댑터

메시지의 내용을 파일로 저장합니다.

@Bean
public IntegrationFlow fileOutboundFlow() {
    return IntegrationFlows.from("inputChannel")
            .handle(Files.outboundAdapter(new File("/output-directory"))
                    .fileNameGenerator(message -> "output.txt")
                    .append(true)) // 기존 파일에 추가
            .get();
}

• 설명:
  • inputChannel에서 메시지를 받아 /output-directory/output.txt 파일로 저장합니다.
  • append(true): 기존 파일에 데이터를 추가합니다.

JMS 아웃바운드 어댑터

메시지를 JMS 큐로 보냅니다.

@Bean
public IntegrationFlow jmsOutboundFlow(ConnectionFactory connectionFactory) {
    return IntegrationFlows.from("inputChannel")
            .handle(Jms.outboundAdapter(connectionFactory)
                    .destination("queue.orders")) // JMS 큐 이름
            .get();
}

• 설명: 메시지를 JMS 큐 queue.orders로 전송합니다.

HTTP 아웃바운드 어댑터

메시지를 HTTP 엔드포인트로 전송합니다.

@Bean
public IntegrationFlow httpOutboundFlow() {
    return IntegrationFlows.from("inputChannel")
            .handle(Http.outboundGateway("http://example.com/endpoint")
                    .httpMethod(HttpMethod.POST)
                    .expectedResponseType(String.class))
            .handle(message -> System.out.println("Response: " + message.getPayload()))
            .get();
}

• 설명:
  • HTTP POST 요청을 http://example.com/endpoint로 보냅니다.
  • 응답 메시지를 처리합니다.

---

Adapter와 Gateway 비교

Spring Integration에서 Adapter와 Gateway는 외부 시스템과 통합할 때 사용하는 중요한 컴포넌트이지만, 그 목적과 사용 방식에서 차이가 있습니다. 이를 명확하게 비교해 보겠습니다.

1. Adapter란?

Adapter는 외부 시스템과 메시지 채널 간의 인터페이스 역할을 합니다.

• 외부 시스템의 데이터를 메시지로 변환하거나, 메시지를 외부 시스템으로 전달합니다.
• 인바운드(Inbound)와 아웃바운드(Outbound) 두 가지 유형이 있습니다.

특징

• 단방향 통신: 데이터를 수신하거나 전송하는 단순한 메시지 통신만 지원합니다.
• Spring Integration의 채널과 결합되어 작동합니다.
• 메시지 핸들러나 채널을 통해 메시지를 처리합니다.

2. Gateway란?

Gateway는 메시지의 송신과 수신을 동시에 처리할 수 있는 양방향 통합을 지원합니다.

• 인터페이스 기반의 추상화된 접근 방식을 제공합니다.
• 외부 시스템과의 통신을 메서드 호출처럼 보이도록 추상화합니다.
• 개발자가 직접 메시지 채널과 메시지를 다룰 필요 없이 간단한 메서드 호출을 통해 통합을 구현할 수 있습니다.

특징

• 양방향 통신: 요청(Request)과 응답(Response)을 동시에 처리합니다.
• 개발자 입장에서 일반적인 메서드 호출처럼 사용됩니다.
• 메시지 채널과의 통합이 자동화되며, 내부적으로 메시지를 송수신합니다.

3. Adapter와 Gateway 비교표

구분 Adapter Gateway

통신 방식	단방향 (Inbound 또는 Outbound)	양방향 (Request/Response)
역할	외부 시스템과 메시지 채널 간 데이터 송수신	메서드 호출을 통해 메시지를 송수신
데이터 흐름	송신자 → 채널 → 어댑터 → 외부 시스템 (단순 전송)	송신자 ↔ 채널 ↔ 게이트웨이 ↔ 외부 시스템 (양방향)
개발 방식	메시지 핸들러와 채널 설정 필요	인터페이스 기반, 메서드 호출로 구현 가능
사용 사례	파일 저장, HTTP 요청 전송, JMS 메시지 수신 등	REST API 호출, RPC 통신, 클라이언트-서버 간 통신
복잡도	상대적으로 간단함	상대적으로 추상화되어 있지만 내부 로직은 복잡함

4. Adapter와 Gateway의 사용 예시

Adapter 사용 예시 (단방향)

파일 시스템에 메시지를 저장하는 Outbound Adapter 예시입니다.

@Bean
public IntegrationFlow fileOutboundFlow() {
    return IntegrationFlows.from("inputChannel")
            .handle(Files.outboundAdapter(new File("/output-directory"))
                    .fileNameGenerator(message -> "output.txt")
                    .append(true)) // 기존 파일에 데이터 추가
            .get();
}

• 설명: 메시지를 inputChannel에서 받아 파일로 저장합니다.
• 단방향: 메시지는 파일로만 출력됩니다.

Gateway 사용 예시 (양방향)

인터페이스를 이용하여 HTTP 요청을 보내고 응답을 받는 Gateway 예시입니다.

 

1. 인터페이스 정의

@MessagingGateway
public interface HttpGateway {
    @Gateway(requestChannel = "httpOutboundChannel")
    String sendRequest(String payload);
}

 

2. Gateway 설정

@Bean
public IntegrationFlow httpOutboundFlow() {
    return IntegrationFlows.from("httpOutboundChannel")
            .handle(Http.outboundGateway("http://example.com/endpoint")
                    .httpMethod(HttpMethod.POST)
                    .expectedResponseType(String.class))
            .get();
}

 

3. Gateway 호출

@Autowired
private HttpGateway httpGateway;

public void testGateway() {
    String response = httpGateway.sendRequest("Hello, Spring Integration!");
    System.out.println("Response: " + response);
}

• 설명:
  • HttpGateway는 메서드 호출을 통해 HTTP 요청을 보냅니다.
  • 응답이 메서드 반환값으로 제공됩니다.
• 양방향: 요청(Request)을 보내고 응답(Response)을 받습니다.

---