Unit 2.4 — JAR vs WAR

F-LAB JAVA · 6주차 · Phase 2 · 웹 인프라 기초
🏆 Phase 2 완주 + Part A 완주 — 배포 패키징의 선택

---

📌 학습 목표

이 Unit을 끝내면 다음을 답할 수 있어야 한다.

• JAR (Java Archive) 란?
• WAR (Web Application Archive) 란?
• JAR vs WAR 의 차이 (포함/실행 환경/실행/구조) 는?
• Spring Boot 가 JAR 를 선택한 이유는?
• Spring Boot JAR 가 내장 톰캣을 가지는 방식은?
• BOOT-INF/lib 구조는?
• WAR 가 필요한 경우 는?
• 마이크로서비스에서 JAR 선호 이유는?
• Part A 전체 의 종합은?

---

🎯 핵심 한 문장

JAR 는 Class·라이브러리를 담아 JRE 만으로 java -jar 로 실행하고, WAR 는 거기에 JSP·Servlet·WEB-INF 를 더해 외부 WAS 에 배포하며, Spring Boot 는 WAS(Tomcat)를 내장한 JAR 를 선택해 배포·실행을 간단하게 만들었다.
JAR (Java Archive) 는 Class 파일과 라이브러리를 담은 압축 파일로, JRE 만 있으면 java -jar app.jar 로 실행되며 구조가 자유롭다.
WAR (Web Application Archive) 는 JAR 에 JSP·Servlet·WEB-INF·META-INF 를 더한 것으로, 외부 WAS (Tomcat 등) 에 배포해야 실행되며 사전 정의된 디렉터리 구조를 따른다.
Spring Boot 는 JAR 를 선택 했는데, WAS (Tomcat) 를 내장하여 별도 WAS 운영이 불필요해 배포·실행이 간단하고 DevOps 부담이 줄기 때문이다.
Spring Boot JAR 는 BOOT-INF/lib 에 내장 톰캣을 포함한 의존성을 담고 BOOT-INF/classes 에 애플리케이션 코드를 담아 실행 가능한 fat JAR 가 되며, JSP 레거시나 외장 WAS 정책이 있을 때만 WAR 를 쓴다.

비유 — 완제품 vs 조립 부품

JAR vs WAR = 완제품 가전 vs 조립 부품:

JAR (Spring Boot, 완제품):
  - 전원 코드 내장 (톰캣 내장)
  - 콘센트만 꽂으면 (JRE)
  - 바로 작동 (java -jar)
  - 별도 설치 불필요

WAR (조립 부품):
  - 본체만 (서블릿/JSP)
  - 전원 장치 별도 (외부 WAS)
  - WAS 에 설치해야 작동
  - 정해진 규격 (디렉터리 구조)

Spring Boot 선택 (JAR):
  - WAS 내장 (전원 내장)
  - 배포 간단 (jar 하나)
  - DevOps 부담 ↓

BOOT-INF/lib:
  - 내장 톰캣 부품 보관함
  - 의존성 + 톰캣

WAR 필요 (예외):
  - JSP 레거시
  - 외장 WAS 정책
  - 공용 톰캣 사용 환경

→ JAR(JRE만, java -jar) vs WAR(외부 WAS), Spring Boot=JAR(톰캣 내장, 간단).

---

🧭 9개 섹션 로드맵

1. JAR란
2. WAR란
3. JAR vs WAR 차이
4. Spring Boot의 JAR 선택
5. 내장 톰캣 방식
6. BOOT-INF/lib 구조
7. WAR가 필요한 경우
8. Part A 완주 정리
9. 면접 + 자기 점검

---

1️⃣ JAR란

1.1 JAR

JAR (Java Archive):

  자바 아카이브:
    - Class 파일
    - 라이브러리
    - 리소스
    - 압축 (zip 기반)

1.2 포함 내용

JAR 포함:

  - .class 파일
  - 라이브러리 (의존성)
  - META-INF/MANIFEST.MF
  - 리소스 (설정, 이미지)

1.3 실행

JAR 실행:

  java -jar app.jar:
    - JRE 만 있으면
    - Main-Class 실행
    - 외부 WAS 불필요

1.4 자유 구조

자유 구조:

  JAR 내부:
    - 사전 정의 X
    - 패키지 구조
    - 자유

1.5 ILIC 의 맥락

JAR (ILIC):

  ilic-backend.jar:
    - Spring Boot 코드 (.class)
    - 모든 의존성 (라이브러리)
    - 내장 Tomcat
    - 설정 (application.yml)

  실행:
    java -jar ilic-backend.jar
    → 별도 Tomcat 설치 X
    → 즉시 실행 (431 API)

1.6 자기 점검 답변

JAR (Java Archive) 란?

답:
1. JAR:

• Class + 라이브러리 압축

2. 포함:

   • .class, 의존성, MANIFEST

3. 실행:

   • java -jar (JRE)

4. 구조:

   • 자유

---

2️⃣ WAR란

2.1 WAR

WAR (Web Application Archive):

  웹 애플리케이션 아카이브:
    - JAR + 웹 자원
    - JSP, Servlet
    - WEB-INF, META-INF

2.2 포함 내용

WAR 포함:

  - Class 파일
  - 라이브러리
  - JSP 파일
  - WEB-INF/web.xml
  - 정적 자원

2.3 디렉터리 구조

WAR 디렉터리 (사전 정의):

  /
  ├── WEB-INF/
  │   ├── web.xml
  │   ├── classes/
  │   └── lib/
  ├── *.jsp
  └── 정적 자원

→ 정해진 구조

2.4 실행

WAR 실행:

  외부 WAS 필요:
    - Tomcat 에 배포
    - webapps/ 에 넣음
    - WAS 가 실행

2.5 ILIC 의 맥락

WAR (개념, ILIC 는 JAR):

  ilic.war (만약 WAR 였다면):
    /
    ├── WEB-INF/
    │   ├── web.xml
    │   ├── classes/ (코드)
    │   └── lib/ (의존성)
    ├── *.jsp (JSP 페이지)
    └── 정적

  배포:
    - Tomcat webapps/ 에 복사
    - Tomcat 이 실행

  → ILIC 는 JAR 선택 (다음 섹션)

2.6 자기 점검 답변

WAR (Web Application Archive) 란?

답:
1. WAR:

• JAR + 웹 자원

2. 포함:

   • JSP, WEB-INF

3. 구조:

   • 사전 정의

4. 실행:

   • 외부 WAS

---

3️⃣ JAR vs WAR 차이

3.1 비교 표

항목	JAR	WAR
정식 명칭	Java Archive	Web Application Archive
포함	Class, 라이브러리	+ JSP, Servlet, WEB-INF
실행 환경	JRE	외부 WAS
실행	java -jar	WAS 배포
구조	자유	사전 정의

3.2 포함 차이

포함 차이:

JAR:
  - Class + 라이브러리

WAR:
  - + JSP, Servlet
  - + WEB-INF
  - 웹 전용

3.3 실행 환경 차이

실행 환경:

JAR:
  - JRE 만
  - 독립 실행

WAR:
  - 외부 WAS
  - WAS 위에서

3.4 실행 방법

실행 방법:

JAR:
  java -jar app.jar

WAR:
  Tomcat webapps/ 배포
  또는 deploy

3.5 ILIC 의 맥락

JAR vs WAR (ILIC 선택)

ILIC = JAR:
  - java -jar ilic-backend.jar
  - 내장 Tomcat
  - JRE 만
  - Docker 컨테이너 간단

만약 WAR 였다면:
  - 별도 Tomcat 설치
  - webapps/ 배포
  - Tomcat 운영 부담

→ JAR 가 컨테이너/배포에 유리

3.6 자기 점검 답변

JAR vs WAR 의 차이는?

답:
1. 포함:

• JAR: Class+라이브러리
• WAR: +JSP/WEB-INF

2. 실행 환경:

   • JRE vs 외부 WAS

3. 실행:

   • java -jar vs 배포

4. 구조:

   • 자유 vs 정의

---

4️⃣ Spring Boot의 JAR 선택

4.1 JAR 선택

Spring Boot = JAR:

  내장 WAS (Tomcat):
    - jar 안에 톰캣
    - 별도 설치 X
    - java -jar 실행

4.2 이유

JAR 선택 이유:

  - 배포 간단 (jar 하나)
  - 실행 간단 (java -jar)
  - WAS 운영 불필요
  - DevOps 부담 ↓

4.3 fat JAR

fat JAR (uber JAR):

  모든 것 포함:
    - 앱 코드
    - 모든 의존성
    - 내장 톰캣

  → 단일 실행 파일

4.4 자기 완결성

자기 완결성:

  Spring Boot JAR:
    - 독립 실행
    - 외부 의존 최소 (JRE)
    - 어디서든 동일

→ 이식성

4.5 ILIC 의 맥락

Spring Boot JAR (ILIC)

ILIC backend:
  - Spring Boot 3
  - ./gradlew bootJar
  - ilic-backend.jar 생성

  실행:
    java -jar ilic-backend.jar
    → 내장 Tomcat 시작
    → 431 API 서빙

  Docker:
    FROM eclipse-temurin:17-jre
    COPY ilic-backend.jar app.jar
    ENTRYPOINT ["java", "-jar", "app.jar"]
    → 간단한 컨테이너

  → WAS 설치 단계 없음 (JAR 덕분)

4.6 자기 점검 답변

Spring Boot가 JAR를 선택한 이유는?

답:
1. JAR 선택:

• 내장 Tomcat

2. 이유:

   • 배포/실행 간단
   • DevOps ↓

3. fat JAR:

   • 모든 것 포함

4. 완결성:

   • 독립 실행

---

5️⃣ 내장 톰캣 방식

5.1 내장 톰캣

내장 톰캣:

  Spring Boot JAR:
    - 톰캣을 라이브러리로 포함
    - spring-boot-starter-web
    - jar 안에 톰캣

5.2 시작 흐름

시작 흐름:

  java -jar app.jar
    → main() 실행
    → SpringApplication.run
    → 내장 톰캣 시작
    → 포트 바인딩 (8080)
    → 요청 대기

5.3 임베디드 서버

임베디드 서버:

  내장 (embedded):
    - 애플리케이션에 포함
    - 코드로 시작
    - 설정 (application.yml)

  vs 외장:
    - 별도 설치/운영

5.4 서버 교체

// 내장 서버 교체 (선택)
// 기본: Tomcat
// Jetty 로:
// spring-boot-starter-web 에서
// tomcat 제외 + jetty 추가

// build.gradle (개념)
// implementation('org.springframework.boot:spring-boot-starter-web') {
//     exclude module: 'spring-boot-starter-tomcat'
// }
// implementation 'org.springframework.boot:spring-boot-starter-jetty'

5.5 ILIC 의 맥락

내장 톰캣 (ILIC)

ilic-backend.jar 실행:
  1. java -jar ilic-backend.jar
  2. IlicApplication.main()
  3. SpringApplication.run(IlicApplication.class)
  4. 내장 Tomcat 시작
  5. 포트 8080 바인딩
  6. DispatcherServlet 등록
  7. 431 API 매핑
  8. 요청 대기

application.yml:
  server:
    port: 8080
  → 톰캣 설정 (코드로)

→ 별도 Tomcat 설치/설정 X

5.6 자기 점검 답변

Spring Boot JAR가 내장 톰캣을 가지는 방식은?

답:
1. 내장 톰캣:

• 라이브러리로 포함

2. 시작:

   • main → run → 톰캣 시작

3. 임베디드:

   • 코드로 시작

4. 교체:

   • Jetty/Undertow

---

6️⃣ BOOT-INF/lib 구조

6.1 fat JAR 구조

Spring Boot fat JAR 구조:

  app.jar
  ├── META-INF/
  │   └── MANIFEST.MF
  ├── org/springframework/boot/loader/
  │   └── (부트 로더)
  ├── BOOT-INF/
  │   ├── classes/  ← 앱 코드
  │   └── lib/      ← 의존성 + 톰캣
  └── ...

6.2 BOOT-INF/classes

BOOT-INF/classes:

  애플리케이션 코드:
    - 내 .class 파일
    - 리소스 (application.yml)

→ 내가 작성한 코드

6.3 BOOT-INF/lib

BOOT-INF/lib:

  의존성 JAR:
    - 내장 톰캣 (tomcat-embed-*.jar)
    - Spring (spring-*.jar)
    - 기타 라이브러리

→ 모든 의존성

6.4 부트 로더

부트 로더:

  org.springframework.boot.loader:
    - JAR 안의 JAR 로딩
    - 중첩 JAR 처리
    - 특수 클래스 로더

→ fat JAR 실행 가능하게

6.5 ILIC 의 맥락

ILIC fat JAR 구조

ilic-backend.jar
├── META-INF/MANIFEST.MF
│   (Main-Class: ...JarLauncher)
├── org/springframework/boot/loader/
│   (부트 로더)
├── BOOT-INF/
│   ├── classes/
│   │   ├── com/ilic/ (431 API 코드)
│   │   └── application.yml
│   └── lib/
│       ├── tomcat-embed-core-*.jar (내장 톰캣!)
│       ├── spring-boot-*.jar
│       ├── spring-webmvc-*.jar
│       ├── mysql-connector-*.jar
│       └── ... (모든 의존성)
└── ...

→ BOOT-INF/lib 에 톰캣 + 의존성
→ classes 에 ILIC 코드
→ 부트 로더가 실행

6.6 자기 점검 답변

BOOT-INF/lib 구조는?

답:
1. fat JAR:

• classes + lib

2. classes:

   • 앱 코드

3. lib:

   • 의존성 + 톰캣

4. 부트 로더:

   • 중첩 JAR 실행

---

7️⃣ WAR가 필요한 경우

7.1 WAR 필요 상황

WAR 필요:

  - JSP 레거시 (반드시 JSP)
  - 외장 WAS 정책
  - 공용 톰캣 환경
  - 기존 인프라

7.2 JSP 레거시

JSP 레거시:

  JSP 사용 시:
    - 내장 톰캣 JSP 제약
    - WAR 권장

→ 레거시 JSP 프로젝트

7.3 외장 WAS 정책

외장 WAS 정책:

  기업 정책:
    - 표준 WAS 운영
    - 공용 톰캣
    - WAR 배포

→ 인프라 정책

7.4 Spring Boot WAR

// Spring Boot 도 WAR 가능
// 1. SpringBootServletInitializer 상속
@SpringBootApplication
public class IlicApplication extends SpringBootServletInitializer {
    @Override
    protected SpringApplicationBuilder configure(
            SpringApplicationBuilder builder) {
        return builder.sources(IlicApplication.class);
    }
}
// 2. build.gradle: war + providedRuntime tomcat
// → 외장 WAS 배포 가능

7.5 ILIC 의 맥락

WAR 판단 (ILIC)

ILIC = JAR 선택:
  - JSP 안 씀 (Vue SPA)
  - 외장 WAS 정책 없음
  - Docker 컨테이너 배포
  - 마이크로서비스 지향

  → WAR 불필요, JAR 적합

만약 WAR 필요했다면:
  - 회사 표준 외장 Tomcat 운영
  - 또는 JSP 레거시 통합
  → SpringBootServletInitializer

→ ILIC 환경엔 JAR 가 최적

7.6 자기 점검 답변

WAR가 필요한 경우는?

답:
1. 필요 상황:

• JSP 레거시
• 외장 WAS 정책

2. JSP:

   • 내장 제약

3. 정책:

   • 공용 톰캣

4. Spring Boot WAR:

   • ServletInitializer

---

8️⃣ Part A 완주 정리

8.1 Part A 학습 종합

Part A — 학습 도구와 환경

Phase 1 — JUnit 테스트 (5 Unit):
  - 단위 테스트, assertThat
  - 실행 방식, 새 인스턴스
  - 픽스처

Phase 2 — 웹 인프라 (4 Unit):
  - 웹서버 vs WAS
  - 서블릿/JSP
  - SSR vs CSR
  - JAR vs WAR

8.2 핵심 메시지

Part A 핵심 메시지:

  "5주차 IoC/DI 코드를
   테스트로 검증하고 (Phase 1),
   웹 백엔드 인프라를
   이해한다 (Phase 2).
   → Spring MVC 학습 준비 완료"

8.3 마이크로서비스 연결

마이크로서비스 JAR:

  JAR 선호:
    - 독립 실행 (서비스별)
    - 컨테이너 친화
    - 배포 간단
    - 확장 쉬움

→ MSA 표준

8.4 다음 — Part B

Part A → Part B:
  - 환경 → DB 접근

Part B — DB 접근의 진화 (정점):
  Phase 3 — JDBC
  Phase 4 — Connection Pool
  Phase 5 — DataSource
  Phase 6 — 트랜잭션 ACID
  Phase 7 — JdbcTemplate

8.5 자기 점검 답변

Part A의 종합은?

답:
1. Phase 1:

• JUnit 테스트

2. Phase 2:

   • 웹 인프라

3. 메시지:

   • 검증 + 환경

4. 다음:

   • DB 접근 진화

---

9️⃣ 면접 + 자기 점검

9.1 면접 단골 질문 매핑

Q	핵심 답변
JAR?	Class+라이브러리, JRE
WAR?	+JSP/WEB-INF, 외부 WAS
차이 3가지?	포함/실행환경/실행
Spring Boot JAR?	내장 톰캣, 간단
내장 톰캣?	라이브러리 포함
BOOT-INF/lib?	의존성+톰캣
WAR 필요?	JSP/외장 정책
MSA JAR?	독립/컨테이너
fat JAR?	모든 것 포함
부트 로더?	중첩 JAR 실행

9.2 자기 점검 체크리스트

JAR

• 정의

WAR

• 정의

차이

• 3가지

Spring Boot JAR

• 이유

내장 톰캣

• 방식

BOOT-INF/lib

• 구조

WAR 필요

• 경우

Part A

• 종합

9.3 추가 심화 질문

Q1: fat JAR vs thin JAR?

답:

• fat: 모든 의존성 포함
• thin: 의존성 분리 (외부)
• Spring Boot 기본 fat
• thin 은 레이어 캐싱

Q2: 레이어드 JAR?

답:

• Docker 레이어 최적화
• 의존성/코드 분리
• 캐싱 효율
• spring-boot:build-image

Q3: GraalVM Native Image?

답:

• AOT 컴파일
• 네이티브 실행 파일
• 빠른 시작, 적은 메모리
• Spring Boot 3 지원

Q4: JAR 실행 메모리?

답:

• -Xmx, -Xms 설정
• 컨테이너 인식 (JDK 10+)
• -XX:MaxRAMPercentage
• 메모리 제한

Q5: MANIFEST.MF?

답:

• JAR 메타데이터
• Main-Class 지정
• Spring Boot: JarLauncher
• Class-Path

---

🎯 핵심 요약 — 3줄 정리

1. JAR vs WAR

• JAR: Class+라이브러리, JRE 로 java -jar (자유 구조)
• WAR: +JSP/Servlet/WEB-INF, 외부 WAS 배포 (정의 구조)

2. Spring Boot의 JAR

• WAS(Tomcat) 내장 → 배포·실행 간단, DevOps 부담 ↓
• BOOT-INF/lib 에 톰캣+의존성, BOOT-INF/classes 에 코드 (fat JAR)

3. WAR 필요 + MSA

• WAR: JSP 레거시, 외장 WAS 정책일 때만
• 마이크로서비스는 JAR 선호 (독립 실행, 컨테이너 친화)

---

🏆 Phase 2 완주 + Part A 완주

🌐 Phase 2 — 웹 인프라 기초
  ✅ Unit 2.1 웹서버 vs WAS
  ✅ Unit 2.2 서블릿과 JSP
  ✅ Unit 2.3 SSR vs CSR
  ✅ Unit 2.4 JAR vs WAR ← 여기, Phase 2 완주

🧪 Part A — 학습 도구와 환경 완주!
  ✅ Phase 1 — JUnit 테스트 (5 Unit)
  ✅ Phase 2 — 웹 인프라 기초 (4 Unit)

---

📚 다음으로...

Part B — DB 접근의 진화 (6주차의 정점)

💾 Part B — DB 접근의 진화
  Phase 3 — JDBC 표준화 (3 Unit)
  Phase 4 — Connection Pool (4 Unit, 4.2 ★깊이)
  Phase 5 — DataSource (4 Unit, 5.3 ★깊이)
  Phase 6 — 트랜잭션 ACID (6 Unit, 6.2~6.6 ★깊이)
  Phase 7 — JdbcTemplate (5 Unit, 7.2 ★깊이)

6주차 누적 진행

🧪 Part A — 학습 도구와 환경 (9 Unit) ← 완주
  ✅ Phase 1 — JUnit 테스트 (5)
  ✅ Phase 2 — 웹 인프라 기초 (4)

💾 Part B — DB 접근의 진화
  ⏭ Phase 3~7 (19 Unit)

총: 9/28 Unit

---

🏆 Phase 2 완주 + Part A 완주