본문으로 바로가기

Spring

엔터프라이즈 컴포넌트 모델과 객체지향 설계의 차이

L.logit 2026. 11. 17.

Spring의 등장 배경을 살펴본 지난 편에 이어, 이번 글에서는 Java EE 플랫폼과 EJB 컴포넌트 모델이 무엇을 제공했고, POJO 중심 설계가 무엇을 달리 제안했는지 살펴본다. 중요한 질문은 단순히 EJB가 무겁고 POJO가 가볍다가 아니다. 비즈니스 객체가 실행 환경의 서비스와 어느 정도로 결합해야 하는가, 그리고 인프라 책임은 누가 맡아야 하는가?라는 설계 문제를 이해하는 것이다.

이번 글의 학습 목표
  • Java EE/J2EE, EJB, EJB Container, POJO가 서로 다른 층위의 개념임을 설명한다.
  • EJB 2.x와 EJB 3.x의 차이를 역사적으로 구분한다.
  • 객체지향 설계 원칙과 컨테이너의 실행 서비스가 경쟁 개념이 아님을 이해한다.
  • 간단한 Java 코드에서 프레임워크 종속성과 의존관계 분리를 확인한다.

1. Java EE는 프레임워크 하나가 아니라 엔터프라이즈 플랫폼이다

Java SE는 언어와 핵심 런타임 API의 기반이고, 당시 J2EE(Java 2 Platform, Enterprise Edition), 이후 Java EE는 서버 측 애플리케이션 개발에 필요한 규약들을 묶은 플랫폼이었다. 웹 요청 처리용 Servlet, 영속성, 메시징, 트랜잭션, 컴포넌트 관리 등을 포괄한다. 오늘날 계보는 Jakarta EE로 이어진다. 따라서 Java EE = EJB라고 보는 것은 정확하지 않다. EJB는 여러 엔터프라이즈 기술 중 비즈니스 컴포넌트를 정의하고 실행하는 하나의 기술이다.

개발자가 보통 사용하는 것은 규약에 맞는 API와 애플리케이션 코드이며, 애플리케이션 서버와 컨테이너가 해당 규약의 실행 서비스를 제공한다. 모든 Java EE 애플리케이션에 EJB 컴포넌트가 반드시 필요한 것은 아니다.

1.1 플랫폼, 컴포넌트, 컨테이너를 구분하기

용어핵심 책임서로 다른 이유
Java EE/J2EE엔터프라이즈 API·규약의 집합특정 컴포넌트 한 종류가 아님
EJB(Enterprise JavaBeans)서버 측 업무 컴포넌트 모델비즈니스 메서드와 컨테이너 서비스 간 계약 정의
EJB ContainerEJB 컴포넌트의 생명주기·트랜잭션·보안 등 관리EJB 컴포넌트를 실행하는 환경
POJO특수한 프레임워크 상속·구현 의무가 없는 일반 Java 객체 중심 접근플랫폼이나 컨테이너 제품명이 아님
Spring IoC ContainerSpring Bean의 생성·조립·설정·관리EJB Container와 별개지만 목표가 일부 겹침

2. EJB는 왜 필요했는가? 기능적 가치부터 이해하기

엔터프라이즈 서비스는 단지 메서드를 실행하는 것에 그치지 않는다. 데이터 변경 중 오류가 발생하면 롤백해야 하고, 호출자의 권한을 검사해야 하며, 동시 요청과 컴포넌트 수명, 원격 호출 등을 일관성 있게 제어해야 한다. 각 개발팀이 이를 직접 재구현하면 중복과 오류가 늘어난다. EJB는 이런 공통 책임을 컴포넌트 외부의 컨테이너에 맡기는 모델을 제공했다.

2.1 컨테이너가 제공하는 서비스

  • 트랜잭션: 업무 메서드의 경계에서 시작·커밋·롤백을 관리한다.
  • 보안: 호출자의 권한과 역할을 기반으로 접근을 제어한다.
  • 생명주기: 컴포넌트 인스턴스의 생성·관리·제거를 지원한다.
  • 동시성 및 확장: 구성요소 유형에 따라 호출 및 상태 관리를 지원한다.
  • 원격 접근: 필요할 때 클라이언트가 다른 JVM의 업무 컴포넌트를 호출하도록 규약을 제공한다.

여기서 원격 접근은 EJB의 가능한 기능이지, 모든 EJB 호출이 네트워크를 통과한다는 뜻은 아니다. EJB에는 로컬 비즈니스 뷰도 존재한다. 시스템 서비스가 제공된다는 점은 당시 EJB가 갖던 실질적인 강점이었다.

3. EJB 2.x의 컴포넌트 계약과 복잡성

초기 EJB, 특히 EJB 2.x의 세션 빈에서는 비즈니스 구현체만으로 구성이 끝나지 않는 경우가 많았다. 로컬/원격 컴포넌트 인터페이스, Home 인터페이스, 생명주기 콜백, 배포 디스크립터가 결합되어 있었다. 이 구조는 원격 객체와 배포·생명주기 계약을 명시적으로 통제하는 장점이 있었지만, 단순한 업무 규칙에도 다수의 부수 요소가 필요할 수 있었다.

3.1 구형 EJB 세션 빈의 구조

구성 요소EJB 2.x에서의 역할
Home interface컴포넌트 생성과 획득을 위한 계약
Local/Remote component interface클라이언트가 호출할 비즈니스 메서드 선언
Bean implementation실제 업무 처리 및 컨테이너 콜백 구현
Deployment descriptor배포, 트랜잭션, 인터페이스 등 메타데이터 설정

이것은 EJB 2.x의 전형적인 모델을 설명한다. 이를 현대의 모든 EJB에 적용하는 것은 오류다. 2006년 전후 EJB 3.0에서 어노테이션과 단순화된 빈 모델이 도입되며 Home 인터페이스와 특수 컴포넌트 인터페이스 요구가 대폭 줄어들었다.

3.2 복잡성의 본질은 단지 XML이 많아서가 아니다

설정 파일 수는 결과적인 현상이다. 보다 본질적인 문제는 업무 로직을 표현하는 객체가 배포·호출·생명주기 계약을 충족하기 위해 불필요하게 복잡한 구조를 갖게 되는지였다. 반대로 원격 호출이나 트랜잭션을 개발자가 모두 직접 작성해야 한다면 그 역시 복잡성이다. 중요한 것은 서비스의 존재 자체가 아니라 서비스와 업무 객체의 결합 방식이다.

4. POJO는 무엇이며, 무엇이 아닌가?

POJO(Plain Old Java Object)는 특별한 컴포넌트 상속·프레임워크 인터페이스에 과도하게 종속되지 않는 평범한 Java 객체를 가리키는 설계 용어다. POJO라는 말은 특정 어노테이션 사용 여부나 기본 생성자 유무로 결정되는 엄격한 언어 규격이 아니다.

4.1 POJO와 JavaBeans와 Spring Bean은 다른 개념

개념판별 기준오해 주의
POJO특별한 프레임워크 계약 없이 표현한 일반 Java 객체반드시 getter/setter가 있어야 하는 것은 아님
JavaBeans속성 접근·생성 등 JavaBeans 관례를 따르는 컴포넌트 스타일Spring이 관리해야만 성립하는 것은 아님
Spring BeanSpring IoC Container가 관리하는 객체POJO가 Spring Bean으로 관리될 수 있음
EJB 세션 빈EJB 컨테이너의 컴포넌트 규약에 따라 관리되는 객체EJB 3.x 구현도 단순한 Java 클래스와 어노테이션을 활용할 수 있음

POJO는 컨테이너가 없다는 뜻이 아니라, 업무 모델이 불필요한 컨테이너 구현 세부사항에 묶이지 않도록 설계할 수 있다는 뜻에 가깝다. EJB 3.x와 Jakarta EE의 CDI 역시 단순한 관리 객체와 의존성 주입을 지원하므로, POJO를 Spring만의 발명이나 독점적 특징으로 설명하면 안 된다.

4.2 도메인 모델과 인프라의 경계

업무 객체는 “무엇을 계산하고 어떤 규칙을 보장해야 하는가?”에 집중한다. 반면 트랜잭션, 인증, 네트워크 접근, 저장소 연결은 실행환경 및 인프라 관심사다. 관심사를 분리하면 같은 핵심 규칙을 배치 처리, 테스트, 웹 요청 등 여러 경로에서 재사용하기 쉬워진다. 하지만 운영상의 편의와 명시적인 제어가 충돌할 때 추상화의 비용도 생길 수 있다.

5. Spring은 EJB와 무엇이 달랐는가?

Spring은 POJO 기반 구성 요소를 IoC/DI로 조립하고, JDBC·트랜잭션·AOP 등 공통 기능을 지원하는 방식을 발전시켰다. Spring IoC Container가 의존 객체를 구성하고 Bean을 관리하므로, 개발자는 비즈니스 로직에 필요한 의존성을 외부에서 전달받도록 설계할 수 있다.

두 기술은 서로 무조건 배타적이지 않다. Spring은 Java EE/Jakarta EE의 Servlet 등 개별 사양을 함께 활용하며 과거에는 EJB 통합도 지원했다. 정확한 비교는 플랫폼 전체 대 프레임워크 전체가 아니라, 동일한 문제를 해결하는 각 메커니즘과 그 비용을 비교하는 것이다.

5.1 EJB와 Spring의 차이를 시대별로 비교

비교 축EJB 2.x의 전형EJB 3.x / Jakarta Enterprise BeansSpring Core
업무 객체 표현Home·컴포넌트 인터페이스 등 명시 계약어노테이션 기반 단순 세션 빈 가능일반 Java 객체를 Bean으로 등록
관리 주체EJB ContainerEJB ContainerSpring IoC Container
의존성 관리컨테이너 서비스·조회·주입 방식어노테이션·CDI 등과 통합생성자 주입·Bean 설정 등
트랜잭션컨테이너 관리 가능컨테이너 관리 가능TransactionManager·선언적 트랜잭션
기술 종속성초기 컴포넌트 계약이 비교적 큼API 의존은 있지만 간소화됨핵심 객체는 POJO로 유지 가능
핵심 트레이드오프풍부한 실행 서비스와 높은 계약 비용표준화된 EE 통합과 배포 모델유연한 조립과 설정·추상화 이해 비용

Spring이 모든 경우에 기능·성능·운영에서 우수하다는 뜻은 아니다. EJB 3.x 이후의 간소화와 Jakarta EE의 CDI를 함께 이해해야 공정한 설계 비교가 가능하다.

6. Java 코드로 검토하는 설계 의존성

다음 예제의 목표는 웹 서버를 띄우는 것이 아니다. 같은 비즈니스 규칙이 생성·조립 전략에서 얼마나 독립적일 수 있는지 확인하는 것이다. 아래 순수 Java 코드는 JDK만으로 구조를 이해할 수 있도록 작성했다.

6.1 도메인 인터페이스와 순수 Java 객체

// PaymentGateway.java
public interface PaymentGateway {
    String approve(String orderId, long amount);
}

// OrderService.java
public final class OrderService {
    private final PaymentGateway gateway;

    public OrderService(PaymentGateway gateway) {
        this.gateway = gateway;
    }

    public String pay(String orderId, long amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("amount must be positive");
        }
        return gateway.approve(orderId, amount);
    }
}

여기서 OrderService는 특정 PG사 구현체도 모르고, EJB/DI 컨테이너의 API도 import하지 않는다. 핵심 설계 포인트는 업무 객체가 자신에게 필요한 협력 객체의 추상적 계약만 알고 있다는 사실이다. 생성자 주입이라는 패턴은 Spring이 없어도 사용 가능하다.

6.2 외부 조립과 구현 교체

// FakePaymentGateway.java
public final class FakePaymentGateway implements PaymentGateway {
    @Override
    public String approve(String orderId, long amount) {
        return "APPROVED:" + orderId + ":" + amount;
    }
}

// Application.java
public final class Application {
    public static void main(String[] args) {
        PaymentGateway gateway = new FakePaymentGateway();
        OrderService service = new OrderService(gateway);
        System.out.println(service.pay("ORDER-100", 12000));
    }
}

위 코드는 파일명에 맞춰 각각 저장한 경우를 가정하며 예상 출력은 APPROVED:ORDER-100:12000이다. 이 문자열은 결제 승인에 대한 실제 외부기관 응답이 아니라 테스트용 구현이 반환한 값이다. OrderService 수정 없이 PaymentGateway 구현체를 바꿀 수 있다. 컴파일·실행 검증은 수행하지 않았다.

6.3 EJB 3.x 예제와 무엇을 비교해야 하는가?

// Jakarta Enterprise Beans 4.x 스타일의 개념 예제
import jakarta.ejb.Stateless;

@Stateless
public class PaymentApplicationBean {
    public String status(String orderId) {
        return "READY:" + orderId;
    }
}

이 코드는 Jakarta Enterprise Beans API와 호환되는 실행 환경이 필요하며, 단순히 new PaymentApplicationBean()을 호출한다고 EJB 컨테이너가 관리하는 트랜잭션·보안 서비스를 획득하는 것은 아니다. 반면 클래스 본문은 구형 EJB 2.x에 비해 훨씬 단순하다. 따라서 이 비교에서 얻어야 할 결론은 “EJB는 무조건 복잡하다”가 아니라 컨테이너 서비스의 획득 방식과 업무 코드의 종속성 수준이 시대에 따라 달라졌다는 점이다.

7. 장점과 한계: 무엇을 선택할 것인가?

  • 표준 기반 EJB/Jakarta EE의 장점: 정형화된 컴포넌트 계약과 트랜잭션·보안·메시징 등 EE 서비스의 통합, 이식성 목표.
  • 초기 EJB의 비용: 복잡한 계약과 배포 메타데이터, 단순 업무 모델에서도 커지는 기반 코드.
  • POJO 중심 설계의 장점: 테스트, 단독 재사용, 의존성 교체, 업무 규칙의 명료성.
  • POJO 중심 설계의 한계: 객체만 단순해져도 트랜잭션·보안·동시성 문제는 사라지지 않는다. 이를 해결할 실행 인프라 또는 명시 코드가 필요하다.
  • Spring의 장점과 비용: 유연한 조립·풍부한 생태계가 강점이지만 자동 설정, 프록시, Bean 생명주기 같은 추상화는 별도 학습이 필요하다.

8. 자주 발생하는 오해와 교정

오해정확한 설명
Java EE는 EJB와 같다EJB는 Java EE/Jakarta EE 플랫폼의 일부 기술이다.
EJB는 언제나 Home 인터페이스가 필요하다EJB 2.x의 전형적인 계약이며 EJB 3.x부터 크게 단순화되었다.
POJO에는 어노테이션을 붙일 수 없다POJO는 어노테이션 유무만으로 판별하지 않는다.
POJO라면 컨테이너에서 관리할 수 없다Spring Bean·CDI 관리 객체도 일반 Java 객체를 기반으로 할 수 있다.
Spring이 트랜잭션을 발명했다EJB 등 기존 엔터프라이즈 환경에도 컨테이너 트랜잭션 관리가 있었다.
Spring과 Jakarta EE는 완전히 배타적이다Spring은 Servlet 등 개별 Jakarta EE 기술을 활용한다.

9. 핵심 정리와 다음 학습 질문

Java EE는 공통 서버 기능의 표준화, EJB는 비즈니스 컴포넌트와 컨테이너의 계약, POJO는 도메인 객체를 불필요한 기술 계약에서 분리하려는 설계 접근을 나타낸다. Spring의 의미는 컨테이너를 없앤 것이 아니라, 일반 객체를 중심으로 의존성을 구성하고 인프라 서비스를 적용하는 방식을 더 유연하게 만든 데 있다.

  • POJO와 JavaBeans를 동일시하면 어떤 설명이 빠지는가?
  • 생성자 주입은 컨테이너 없이도 가능한데, Spring IoC가 추가하는 핵심은 무엇인가?
  • EJB 3.x와 Spring의 비교는 왜 EJB 2.x와의 비교와 달라지는가?
  • 트랜잭션 책임을 객체 밖으로 옮기면 어떤 이득과 제약이 생기는가?

다음 편: IoC와 DI — 제어는 무엇에서 무엇으로 역전되는가?

10. 참고 문헌 및 공식 자료