Spring Framework를 깊이 이해하는 첫 단계는 어노테이션 사용법이 아니라, 그것이 해결하려던 객체 관리와 엔터프라이즈 개발의 복잡성을 살펴보는 일이다. 오늘은 J2EE/EJB가 등장한 이유, 그 모델이 제공한 가치와 비용, 그리고 Spring이 어떤 설계 대안을 제시했는지 분석한다.
Spring은 무엇을 없앤 기술이 아니라, 어떤 책임을 분리하고 어떤 선택권을 개발자에게 돌려준 기술인가?1. Spring 이전: Java 엔터프라이즈 개발이 해결해야 했던 문제
1990년대 말부터 기업용 Java 애플리케이션은 단순한 객체 호출을 넘어 트랜잭션 경계, 인증·인가, 원격 호출, 리소스 접근, 커넥션 관리, 배포 및 운영 등 공통된 요구사항을 다뤄야 했다. 이런 문제를 매 애플리케이션이 독자적으로 해결하면 비즈니스 코드가 인프라 코드에 잠식된다.
J2EE(Java 2 Platform, Enterprise Edition)는 여러 엔터프라이즈 기술을 묶는 플랫폼으로 등장했다. Servlet/JSP는 웹 계층을, EJB는 엔터프라이즈 컴포넌트 모델을, JTA/JDBC 등의 표준은 트랜잭션과 데이터 접근을 지원했다. J2EE 전체와 EJB를 같은 것으로 취급하면 역사를 잘못 이해하게 된다. EJB는 J2EE 안의 여러 기술 중 하나다.
1.1 EJB가 제공한 실제 가치
Enterprise JavaBeans(EJB)는 업무 객체를 EJB 컨테이너 안에서 실행시키며 트랜잭션, 보안, 생명주기 및 자원 관리 같은 시스템 수준 서비스를 제공한다. 이 목표 자체는 합리적이었다. 개발자가 모든 비기능 요구를 직접 구현하지 않고 비즈니스 동작에 집중할 수 있기 때문이다. Oracle의 Java EE 문서 역시 EJB 컨테이너가 트랜잭션과 보안 서비스를 제공한다고 설명한다. 따라서
EJB는 단순히 실패한 기술이 아니라 당시 기업용 애플리케이션의 공통 문제를 해결하려는 컨테이너 모델로 이해해야 한다.
1.2 당시의 비용과 복잡성
- 초기 EJB의 여러 컴포넌트 모델과 계약에 맞춘 클래스·인터페이스·배포 서술자 작성 부담
- 애플리케이션 서버 및 컨테이너 서비스에 의존하는 테스트와 배포 절차
- 상대적으로 단순한 업무 객체에도 기술적 계약이 침투하기 쉬운 구조
- 지속성 및 원격 통신 등과 관련한 추상화의 복잡성과 설정 부담
이 항목들은 주로 초기 EJB 1.x/2.x 시기의 관행을 설명한다. 모든 EJB가 원격 호출을 요구한 것은 아니며, EJB 3.x 이후에는 어노테이션 및 단순화된 프로그래밍 모델로 상당한 개선이 이루어졌다. 시대와 버전을 섞어 “EJB는 무조건 무겁다”라고 일반화해서는 안 된다.

2. Spring은 어떻게 탄생했는가?
Rod Johnson은 2001년부터 관련 프레임워크 코드를 개발했고, 2002년 출간한 『Expert One-on-One J2EE Design and Development』에 약 3만 줄의 프레임워크 코드를 함께 제공했다. 이 코드에는 IoC 컨테이너, BeanFactory, ApplicationContext, JdbcTemplate, MVC 초기 구조 등이 이미 포함되어 있었다.
독자와 기여자의 논의를 거치며 프로젝트는 2003년 6월 공개되었다. 저자는 기존 J2EE 개발 방식에서 느꼈던 복잡성을 줄이는 것이 중요한 동기였다고 회고한다. 프로젝트명 Spring은 기존 J2EE의 “겨울” 이후 새로운 출발이라는 의미와 연결되었다.
| 시기 | 주요 사실 | 학습 관점 |
|---|---|---|
| 2001 | Rod Johnson의 프레임워크 코드 작성 시작 | 설계 아이디어의 출발 |
| 2002.11 | 저서와 프레임워크 코드 공개 | 실전 J2EE 문제의 대안 제시 |
| 2003.06 | 오픈소스 프로젝트 공개 | 개인 코드에서 협업 프레임워크로 발전 |
| 2004.03.24 | Spring Framework 1.0 | IoC, AOP, JDBC, 트랜잭션 등 제공 |
| 2013.08 | Spring Boot 첫 마일스톤 발표 | 설정·실행 경험 단순화 |
| 2014.04.01 | Spring Boot 1.0 GA | 독립 실행 및 배포 모델 확산 |

3. Spring의 핵심 철학: POJO 중심 설계와 관심사 분리
3.1 POJO는 단순한 클래스 문법이 아니다
POJO(Plain Old Java Object)는 프레임워크 전용 상속·인터페이스 같은 과도한 제약을 요구하지 않는 일반적인 Java 객체를 가리키는 표현이다. 단순히 new로 생성할 수 있다는 사실만으로 설계의 모든 장점이 확보되지는 않는다. 중요한 것은 핵심 업무 규칙을 기술 세부사항에서 최대한 독립적으로 유지하려는 방향이다.
예컨대 주문 금액 계산 규칙은 JNDI 조회, 서블릿 요청 객체, EJB 라이프사이클 같은 인프라 관심사 없이도 표현할 수 있다. Spring은 이러한 객체를 관리하면서 필요에 따라 트랜잭션, 데이터 접근, 보안 등의 기능을 통합하도록 설계되었다.
3.2 제어의 역전(IoC)과 의존성 주입(DI)
일반 Java에서는 협력 객체를 사용하는 클래스가 직접 new로 구성 객체를 생성하거나 전역 조회를 수행하기 쉽다. DI에서는 협력 관계를 외부 조립 코드나 컨테이너가 연결한다. Spring의 IoC 컨테이너는 이 역할을 일반화하여 Bean 정의와 생명주기를 관리한다.
IoC는 제어 책임의 이동을 설명하는 넓은 개념이며, DI는 필요한 의존 객체를 외부에서 제공하는 구체적인 방식이다.객체 간 의존관계를 외부에서 전달하는 설계는 Spring 없이도 구현할 수 있다. Spring의 가치는 DI 자체를 발명했다는 주장보다, 그 방법을 광범위한 엔터프라이즈 애플리케이션에서 반복 가능하게 지원하는 컨테이너와 추상화를 제공했다는 데 있다.

4. Spring이 실제로 바꾼 책임의 경계
| 관점 | 초기 EJB 중심 접근의 특징 | Spring이 제시한 접근 |
|---|---|---|
| 업무 객체 | 컨테이너 계약에 따르는 컴포넌트 모델 | 일반 Java 객체(POJO) 사용 지향 |
| 의존관계 | 컨테이너 서비스와 조회 메커니즘의 비중 | 외부 조립과 DI 지원 |
| 트랜잭션 | EJB 컨테이너 관리 트랜잭션 등 | 일반 업무 객체에도 적용 가능한 추상화 |
| 테스트 | 컨테이너 계약이 많은 코드의 테스트 부담 | 일반 Java 객체 단위 테스트 용이 |
| 구성 | 플랫폼·버전에 따른 배포 및 설정 | 독립적 모듈 도입과 유연한 설정 모델 |
위 비교는 특정 역사적 시기의 대표적 경향을 대비한 것이다. 현대 Jakarta EE와 Spring 양측의 개발 모델은 상당 부분 가까워졌고, 모두 컨테이너·DI·트랜잭션을 제공할 수 있다. Spring은 Servlet, JPA 등 Java/Jakarta EE 개별 표준을 널리 통합하므로 두 생태계가 항상 경쟁하거나 상호 배타적이라고 볼 수 없다.
4.1 경량(lightweight)이 뜻하는 바
초기 Spring에서 “경량”은 단순히 JAR 용량이나 메모리 사용량이 작다는 뜻만이 아니다. 컨테이너 API의 강제 침투를 줄이고 필요에 맞는 모듈을 선택해 일반 Java 객체를 관리할 수 있다는 설계적 의미가 중요했다. 규모가 커진 현대 Spring 애플리케이션의 모든 설정과 부팅 비용이 작다는 뜻은 아니다.
4.2 단점과 트레이드오프
- 객체 생성·주입이 컨테이너에서 일어나므로 단순 코드 추적만으로 전체 의존관계를 보기 어려울 수 있다.
- 자동 프록시와 어노테이션 기반 처리에서는 메서드 호출 경계, 적용 조건, 런타임 동작을 별도로 이해해야 한다.
- 프레임워크 추상화는 유연성을 주지만, 실제 오류 분석 시 여러 내부 계층을 따라가야 할 수 있다.
- Spring Boot의 자동 설정은 초기 비용을 낮추지만 어떤 조건에서 무엇이 등록되었는지를 조사해야 하는 상황이 생긴다.
5. Java 코드로 보는 설계 차이 — 컨테이너 없이 먼저 이해하기
다음 코드는 Spring 의존성이 없는 Java 17+의 개념 예제다. 원리는 버전에 크게 의존하지 않는다. Spring 실행 튜토리얼이 아니라 “객체를 누가 조립하는가”라는 문제를 관찰하기 위한 비교다. 각 코드 조각은 동일한 개념을 설명하는 독립 예제로 이해하면 된다.
5.1 직접 생성: 업무 객체가 구현체 선택까지 담당
interface PaymentGateway {
void pay(int amount);
}
class CardGateway implements PaymentGateway {
public void pay(int amount) {
System.out.println("CARD payment: " + amount);
}
}
class OrderService {
private final PaymentGateway gateway = new CardGateway();
public void order(int amount) {
gateway.pay(amount);
}
}
이 설계에서 OrderService는 PaymentGateway라는 추상 타입을 사용하지만, 실제 구현체 CardGateway를 직접 선택한다. 인터페이스를 사용했다는 사실만으로 구현체 결합이 사라지지는 않는다.
5.2 외부 조립: 생성자 DI로 선택 책임 분리
interface PaymentGateway {
void pay(int amount);
}
class CardGateway implements PaymentGateway {
public void pay(int amount) {
System.out.println("CARD payment: " + amount);
}
}
class OrderService {
private final PaymentGateway gateway;
OrderService(PaymentGateway gateway) {
this.gateway = gateway;
}
void order(int amount) {
gateway.pay(amount);
}
}
public class PureJavaDiMain {
public static void main(String[] args) {
PaymentGateway gateway = new CardGateway();
OrderService orders = new OrderService(gateway);
orders.order(1000);
}
}
기대 출력은 CARD payment: 1000이다. OrderService의 책임은 결제 요청 처리이며, 구현체 선택·객체 조립은 main 쪽으로 이동했다. 이는 Spring 없이도 가능한 DI다.
5.3 Spring은 무엇을 추가하는가?
// Spring context 의존성이 있는 별도의 개념 예제
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
class PaymentConfiguration {
@Bean
PaymentGateway paymentGateway() {
return new CardGateway();
}
@Bean
OrderService orderService(PaymentGateway gateway) {
return new OrderService(gateway);
}
}
Spring의 @Bean 메서드는 Bean 정의를 제공하고, 컨테이너는 필요한 의존성을 해결해 OrderService를 구성한다. 이 코드만으로 애플리케이션이 실행되는 것은 아니며 설정 클래스를 읽는 Spring ApplicationContext가 필요하다. 핵심은 객체를 직접 생성할 수 없게 만든 것이 아니라 객체 조립 규칙을 컨테이너로 이전했다는 점이다. 구체적인 BeanDefinition과 ApplicationContext 작동 원리는 후속 편에서 분석한다.

6. 그렇다면 Spring Boot는 왜 다시 등장했는가?
Spring Framework가 객체 관리와 엔터프라이즈 추상화를 제공한 이후에도 프로젝트별 설정, 의존성 버전 조합, 웹 서버 구성, 패키징·배포는 여전히 반복되는 문제였다. 2013년 Spring Boot는 개발자가 기본값을 활용하면서 필요할 때 재설정할 수 있는 방향을 제시했다. 2014년 Spring Boot 1.0은 이런 접근을 정식 제품으로 제공했다.
Spring Framework가 애플리케이션의 기반 프로그래밍 모델을 제공한다면, Spring Boot는 그 기반을 사용하는 애플리케이션을 구성·실행·운영하기 쉽게 만드는 계층이다.따라서 Spring Boot를 배우기 위해 Spring Core를 생략하면 @SpringBootApplication, Auto Configuration, Bean 등록 조건 등이 마술처럼 보일 수 있다. 본 시리즈는 Core의 객체 관리 원리를 먼저 분석한 후 Boot 내부 구조로 확장한다.
7. 자주 발생하는 오해와 교정
| 흔한 표현 | 보다 정확한 이해 |
|---|---|
| Spring이 DI를 발명했다. | DI라는 설계 접근을 Spring이 실용적 컨테이너 모델로 널리 지원했다. |
| Spring은 EJB를 전면 대체했다. | 당시 EJB 중심 개발의 대안을 제시했지만 EE 사양과도 통합한다. |
| EJB는 항상 원격 통신이다. | EJB 버전과 Bean 유형에 따라 로컬·원격 등 다양한 모델이 존재한다. |
| POJO는 @Component가 없는 객체다. | POJO는 프레임워크 계약에 과도하게 종속되지 않는 일반 Java 객체를 지칭한다. |
| Spring Bean은 특별한 Java 클래스다. | 클래스 문법보다 Spring 컨테이너의 관리 대상인지가 본질이다. |
| Spring Boot는 Spring의 새 버전이다. | Spring Framework 위에서 구동을 편리하게 하는 별도 프로젝트다. |
8. 핵심 정리와 다음 학습 질문
J2EE/EJB는 엔터프라이즈 개발에 필요한 인프라 서비스를 표준화했다. Spring은 이 서비스를 버린 것이 아니라, 일반 Java 객체 중심으로 개발하면서 선택적 추상화와 유연한 컨테이너 구성을 지원했다. 가장 중요한 변화는 객체 생성 자체의 제거가 아니라
업무 객체의 책임과 의존관계 조립의 책임을 분리한 것이다.
- J2EE 플랫폼과 EJB 컴포넌트 모델은 어떤 차이가 있는가?
- EJB 컨테이너와 Spring IoC 컨테이너는 각각 무엇을 관리하는가?
- 생성자 DI가 클래스 의존성과 객체 의존관계를 어떻게 바꾸는가?
- Spring 없이도 DI가 가능하다면 Spring Container는 무엇을 추가로 제공하는가?
- Spring Boot의 자동 설정은 왜 IoC Container의 이해를 전제로 하는가?
다음 편: Java EE, EJB, POJO — 엔터프라이즈 컴포넌트 모델과 객체지향 설계의 차이
참고 문헌 및 공식 자료
'Spring' 카테고리의 다른 글
| IoC와 DI — 제어는 무엇에서 무엇으로 역전되는가? (0) | 2026.11.17 |
|---|---|
| 엔터프라이즈 컴포넌트 모델과 객체지향 설계의 차이 (0) | 2026.11.17 |