[Java] 객체 생성하는 3가지 방법

Constructor, Builder Pattern, Static Factory Method

Java에서 객체를 생성하는 세가지 주요 방법에 대해 알아보고자 한다.

• 생성자(Constructor)
• 빌더 패턴(Builder Pattern)
• 정적 팩토리 메서드(Static Factory Method)

생성자(Constructor): 기본적인 객체 생성 방법

1. @NoArgsConstructor + @Setter

• 기본 생성자를 통해 빈 객체를 생성한 뒤, Setter를 사용해 필요한 필드값을 설정한다.

Human emptyHuman = new Human();
emptyHuman.setName("CheonSang")
emptyHuman.setAge(12);

class Human {
	private String name;
    private int age;
    
    // No args Counstructor
    public Human() {}
}

 

2. Custom Constructor: 필요한 필드만 주입하는 생성자

• 특정 필드만 초기화하는 커스텀 생성자를 만들 수 있다.

Human customHuman = new Human("CheonSang");

Class Human {
	private String name;
    private int age;
    
    // Custom Constructor
    public Human(String name) {
    	this.name = name;
    }
}

 

3. DTO(Data Transfor Object) 생성자: DTO를 통해 객체를 생성하는 방식도 있다.

HumanCreateRequestDto dto = new HumanCreateRequestDto();
Human humanFromDto = new Human(dto);

Class Human {
	private String name;
    private int age;
    
    // DTO를 사용한 Custom Constructor
    public Human(HumanCreateRequestDto dto) {
    	this.name = dto.getName();
        this.age = dto.getAge();
    }
}

 

4. @AllArgsConstructor

• 모든 필드를 초기화하는 생성자. 객체 생성 시 필요한 모든 필드를 한꺼번에 설정할 수 있다.

Human fullHuman = new Human("CheonSang", 12);

class Human {
	private Stirng name;
    private int age;
    
    // All Args Constructor
    public Human(String name, int age) {
    	this.name = name;
        this.age = age;
    }
}

객체 불변성(Immutability)과 완전성(Completeness)의 관점에서의 객체 초기화

 

1. 불변성(Immutability)

• 불변성이란, 객체가 초기화된 이후 그 내부의 필드 값이 절대로 변경되지 않는 특성을 의미한다. 이는 데이터의 안정성을 보장하고, 객체가 외부에 의해 예기치 않게 변경될 위험을 방지한다.
• Immutable 객체는 멀티스레드 환경에서도 안전하게 사용할 수 있으며, 예측 가능한 상태를 유지한다.

2. 완전성(Completeness)

• 완전성이란, 객체가 생성될 때 필요한 모든 필드 값이 반드시 초기화되어, 생성된 객체가 완전한 상태를 이루도록 하는 특성이다. 객체가 완전하게 생성되어야 이후 호출되는 모든 메서드가 의도한 대로 동작할 수 있다.

불변성과 완전성의 조합

• 불변성과 완전성을 조합하면 객체는 한 번의 생성자 호출로 완전하고, 불변한 상태가 된다. 이 말은 객체가 생성된 후에는 그 상태가 절대 변경되지 않으며, 객체의 모든 메서드는 초기 상태의 값에 기반해 안정적으로 동작할 수 있다는 의미이다.
• 이러한 객체는 변경 불가능한 데이터 구조로, 유지보수성, 가독성, 안전성이 높아진다.

3. 불변성과 완전성을 보장하기 위한 문법

• `fianl`키워드: 필드에 `final`을 붙이면 그 필드는 한 번 값이 설정되면 더 이상 값을 변경할 수 없다. 이는 필드가 불변성을 유지할 수 있도록 강제한다.
• `@RequiredArgsConstructor`: 이 어노테이션은 `final`이나 `@NonNull` 필드에 대해 필수적인 초기화가 필요함을 보장하는 생성자를 자동으로 생성해준다. 이를 통해 객체의 완전성을 보장할 수 있다.

빌더 패턴(Builder Pattern)

빌더 패턴은 객체 생성 시 유연성을 제공하여 생성자보다 더 명시적이고 가독성이 좋다.

 

1. 빌더 패턴의 장점

• 객체 생성 시 필드 순서에 상관없이 원하는 필드만 초기화할 수 있다.
• 복잡한 객체 생성 로직을 간결하게 표현할 수 있다.

RequestDto dto = RequestDto.builder()
                .hello("A")
                .world("B")
                .build();

RequestDto dto = RequestDto.builder()
                .world("B")
                .hello("A")
                .build();

 

2. 빌더 패턴 사용 시 필드 설정을 자유롭게 분리 가능

RequestDto.RequestDtoBuilder isBuildingSetHello = RequestDto.builder()
		.hello("A");

RequestDto.RequestDtoBuilder isBuildingSetWorld = isBuildingSetHello
    .world("B");

RequestDto initialized = isBuildingSetWorld.build();

 

3. 빌더에 제약을 추가

• `@Builder.Default`로 기본값을 설정할 수 있으며, `@Singular`는 컬렉션 필드에 대해 개별 아이템을 추가하는 기능을 제공한다.

4. Custom Builder와 Validation

빌더 패턴에 유효성 검사를 추가하여 특정 필드에 대한 제약을 설정할 수 있다.

@Getter
@Builder
public class RequestDto {
    private String hello;
    private String world;

    public static class RequestDtoBuilder {
        public RequestDtoBuilder hello(String value) {
            if (value.equals("BYE")) {
                throw new RuntimeException("Unacceptable Word");
            }
            this.hello = value;
            return this;
        }
    }
}

 

이해를 돕기위한 영상

https://www.youtube.com/watch?v=s-xY1QPCjF8

빌더(Bulider)패턴 (Youtue. 얄팍한 코딩사전)

정적 팩토리 메서드(Static Factory Method): 객체 생성 방식을 정의하는 패턴

정적 팩토리 메서드는 객체 생성을 위한 정확한 제어를 제공하며, 생성자 대신 정적 메서드로 객체를 생성한다.

 

정적 팩토리 메서드의 장점:

1. 메서드 이름을 가질 수 있다: 메서드 이름을 통해 객체 생성 방식의 의미를 명확히 전달할 수 있다.
2. 호출할 때마다 새로운 객체를 생성할 필요가 없다: 싱글턴 패턴처럼 객체 수를 제한할 수 있다.
3. 하위 자료형 객체를 반환할 수 있다: 상속 관계에서 하위 클래스의 인스턴스를 반환할 수 있다.
4. 객체 생성을 캡슐화할 수 있다: 객체 생성 로직을 숨길 수 있어 코드의 유연성과 유지 보수성이 높아진다.

예시 코드:

ParsedRequestDto newlycreated = ParsedRequestDto.of(dto);

@Getter
class ParsedRequestDto {
    private final String hello;
    private final String world;

    // Private 생성자
    private ParsedRequestDto(String hello, String world) {
        this.hello = hello;
        this.world = world;
    }

    // 정적 팩토리 메서드
    public static ParsedRequestDto of(RequestDto requestDto) {
        return new ParsedRequestDto(
            requestDto.getHello(),
            requestDto.getWorld()
        );
    }
}

 

객체 생성 방법 비교

1. 생성자(Constructor):

• 장점: 명확한 객체 초기화, 필드 값의 일관성 유지 가능.
• 단점: 필드가 많아지면 생성자 오버로딩으로 인해 복잡해질 수 있음.

2. 빌더 패턴(Builder Pattern):

• 장점: 유연한 필드 설정, 가독성 향상, 필드 주입 순서에 구애받지 않음.
• 단점: 객체 생성 시 조 금 더 많은 코드가 필요할 수 있음.

3. 정적 팩토리 메서드(Static Factory Method):

• 장점: 객체 생성 방식을 완전히 캡슐화하고 제어할 수 있음. 메서드 이름을 가질 수 있어 가독성 향상
• 단점: 생성자가 아닌 메서드로 객체를 생성하기 때문에 복잡할 수있음.

 

---

ℹ️참고

[ASAC 6기 강의자료]

https://www.youtube.com/watch?v=s-xY1QPCjF8