Java Builder Pattern 완벽 이해하기

Java Builder Pattern 완벽 이해하기

Java 실무에서 객체 생성 시 정말 많이 사용하는 패턴이 바로:

Builder Pattern

입니다.

특히:

• Spring
• JPA
• DTO 설계
• Immutable Object
• 테스트 코드

등 거의 모든 Java 백엔드 프로젝트에서 자주 등장합니다.

초보 시절에는 보통:

 

new User(...)

 

방식만 사용하다가:

 

User.builder()

 

구조를 처음 보면 어렵게 느껴질 수 있습니다.

하지만 실제 Builder Pattern은:

• 가독성 향상
• 객체 생성 안정성
• immutable 객체 생성
• 생성자 폭발 해결

을 위한 매우 중요한 설계 패턴입니다.

이번 글에서는:

• Builder Pattern이 왜 필요한가
• 기존 생성자 방식 문제
• Builder 내부 구조
• Lombok Builder
• 실무 활용 전략

까지 정리해보겠습니다.

---

1. Builder Pattern이란?

Builder Pattern은:

객체 생성 과정을 단계적으로 구성하는 생성 패턴(Creational Pattern)

입니다.

즉:

복잡한 객체 생성
↓
읽기 쉽고 안전하게 처리

 

하기 위한 패턴.

---

2. 왜 Builder Pattern이 필요할까?

예를 들어 User 객체가 있다고 가정.

 

public class User {

    private String name;
    private int age;
    private String email;
    private String phone;
    private String address;
}

 

---

3. 생성자 방식 문제

 

User user = new User(
    "Kim",
    20,
    "test@test.com",
    "010-1111-2222",
    "Seoul"
);

 

문제:

값 순서 파악 어려움

 

---

4. 매개변수 많아질수록 심각

예시:

 

new User(
    "Kim",
    20,
    null,
    null,
    "Seoul",
    true,
    false,
    ...
)

 

가독성 매우 나빠짐.

---

5. Setter 방식 문제

 

User user = new User();

user.setName("Kim");
user.setAge(20);

 

문제:

• 객체 생성 중간 상태 존재
• immutable 불가능
• Thread-safe 약화

---

6. Builder Pattern 등장 목적

핵심 목적:

목적설명

가독성 향상	의미 명확
생성 안정성	완전한 객체 생성
immutable 지원	setter 제거 가능
선택적 파라미터 처리	유연성 증가

---

7. 기본 Builder Pattern 구조

 

public class User {

    private final String name;
    private final int age;

    private User(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
    }

    public static class Builder {

        private String name;
        private int age;

        public Builder name(String name) {
            this.name = name;
            return this;
        }

        public Builder age(int age) {
            this.age = age;
            return this;
        }

        public User build() {
            return new User(this);
        }
    }
}

 

---

8. 사용 방법

 

User user = new User.Builder()
    .name("Kim")
    .age(20)
    .build();

 

---

9. Builder 핵심 구조

핵심은:

메서드 체이닝(Method Chaining)

 

입니다.

즉:

 

return this;

 

를 계속 반환.

---

10. 메서드 체이닝이 가능한 이유

 

public Builder name(String name) {
    this.name = name;
    return this;
}

 

즉 자기 자신 반환.

---

11. Builder Pattern 장점

장점설명

가독성	매우 좋음
순서 의존 감소	안전
선택적 값 처리	쉬움
immutable 지원	가능
유지보수성	좋음

---

12. Immutable Object와 Builder

실무에서 가장 중요한 조합.

예시:

 

private final String name;

 

setter 없이:

 

Builder

 

를 통해 객체 생성.

즉:

불변 객체 생성 편의성 확보

 

가능.

---

13. Lombok @Builder

실무에서 정말 많이 사용.

 

@Builder
@Getter
public class User {

    private String name;
    private int age;
}

 

---

14. 사용 방식

 

User user = User.builder()
    .name("Kim")
    .age(20)
    .build();

 

Lombok이 Builder 코드 자동 생성.

---

15. Lombok Builder 장점

장점설명

코드 감소	매우 큼
가독성	향상
유지보수	편리
실무 생산성	높음

---

16. 왜 실무에서 Builder를 많이 쓸까?

대표 이유:

DTO 필드 많음

 

예:

 

UserResponse
OrderResponse
ProductDto

 

필드 수십 개 가능.

생성자만으로 관리 어려움.

---

17. Builder와 선택적 파라미터

예시:

 

User.builder()
    .name("Kim")
    .build();

 

일부 값만 설정 가능.

생성자 오버로딩 지옥 방지.

---

18. 생성자 오버로딩 문제

안 좋은 예:

 

User()
User(String name)
User(String name, int age)
User(String name, int age, String email)

 

매우 복잡해짐.

---

19. Builder Pattern은 생성자 폭발 해결

즉:

Telescoping Constructor Problem

 

해결 목적.

---

20. Builder와 검증 로직

build() 시점에 검증 가능.

 

public User build() {

    if (name == null) {
        throw new IllegalArgumentException();
    }

    return new User(this);
}

 

---

21. Builder와 캡슐화

좋은 설계:

 

private 생성자

 

사용.

즉:

Builder를 통해서만 객체 생성

 

가능.

---

22. Builder와 JPA Entity

주의 필요.

JPA는:

• 기본 생성자 필요
• 프록시 객체 생성

등 특수 구조 존재.

그래서 보통:

 

@NoArgsConstructor
@Builder

 

함께 사용.

---

23. Builder와 테스트 코드

실무 테스트에서 매우 유용.

 

User user = User.builder()
    .name("test")
    .age(20)
    .build();

 

가독성 매우 좋음.

---

24. Builder와 DTO 설계

대표 사례:

영역활용

API Response	매우 많음
테스트 객체 생성	매우 많음
Immutable DTO	핵심
Config 객체	자주 사용

---

25. Builder 남용 문제

모든 객체에 Builder 사용하는 건 아님.

예:

 

Point(x, y)

 

처럼 단순 객체는 생성자가 더 단순.

---

26. 성능 문제는 없을까?

Builder는 객체 하나 더 생성 가능.

즉:

Builder 객체 생성 비용

 

존재.

하지만 대부분 실무에서는:

가독성/유지보수 이점이 훨씬 큼

 

---

27. Builder와 Thread-safe

Builder 자체는 mutable.

즉:

Thread-safe 아님

 

하지만:

생성 결과 객체를 immutable

 

하게 만드는 데 의미가 있음.

---

28. Builder Pattern과 디자인 패턴

Builder는 GoF 디자인 패턴 중:

생성 패턴(Creational Pattern)

 

에 속함.

---

29. 실무에서 자주 하는 실수

1) Builder 남용

단순 객체까지 Builder 적용.

---

2) mutable 객체에 Builder만 적용

진짜 immutable 아님.

---

3) 검증 없는 Builder

잘못된 객체 생성 가능.

---

30. Builder Pattern의 진짜 목적

Builder의 핵심 목적은:

읽기 쉽고 안전한 객체 생성

 

입니다.

즉:

• 유지보수성 향상
• immutable 객체 생성
• 생성 안정성 확보

를 위한 설계 패턴.

---

31. 정리

Builder Pattern은 단순 문법이 아니라:

• 객체 생성 전략
• immutable 객체 설계
• DTO 설계
• 유지보수성
• 실무 생산성

과 깊게 연결되는 매우 중요한 패턴입니다.

특히 실무에서는:

• Lombok @Builder
• immutable DTO
• 메서드 체이닝
• 생성자 폭발 해결

을 이해하는 것이 매우 중요합니다.

다음 글에서는:

전략 패턴(Strategy Pattern)

을 Spring DI, 결제 시스템, 실무 객체 설계 관점까지 포함해서 정리해보겠습니다.