빌더 패턴

빌더 패턴? 

추상 팩토리 패턴을 확장하여 복잡한 생성 절차를 가지는 복합 객체 생성을 위한 생성 패턴입니다.

기존 팩토리, 팩토리 메서드, 추상 팩토리 패턴으로는 단일 객체는 생성 가능하지만, 복합 객체는 생성 불가능 

 

복합 객체? 단일 객체? 

단일 객체란 하나의 클래스로 생성된 객체를 의미하고,

반대로 복합 객체란 여러 클래스로 구성된 객체를 의미합니다.

 

단일 객체의 확장은 주로 상속인데,

강력한 상하 결합 관계와 불필요한 행위가 포함되는 단점이 있습니다..

객체 지향에서는 이러한 단점 개선을 위해 의존성 주입을 사용하여 복합 객체 사용을 권장합니다.

 

빌더 패턴 장점

• 객체 생성 단계 설정 가능
• 코드 재사용성 증가
• 단일 책임 원칙

 

빌더 패턴 단점 

• 여러 클래스를 생성해야 하므로 복잡성 증가

 

빌더 패턴 구현

public abstract class ComputerBuilder {

    protected ComputerAlgorithm computerAlgorithm;

    public Computer getInstance() {
        return computerAlgorithm.getInstance();
    }

    public abstract ComputerBuilder setAlgorithm(ComputerAlgorithm computerAlgorithm);

    public abstract ComputerBuilder build();
}

public class ComputerFactory extends ComputerBuilder {
    @Override
    public ComputerFactory setAlgorithm(ComputerAlgorithm computerAlgorithm) {
        this.computerAlgorithm = computerAlgorithm;
        return this;
    }

    @Override
    public ComputerBuilder build() {
        computerAlgorithm.setCpu("cpu");
        computerAlgorithm.setRam("ram");
        computerAlgorithm.setStorage("storage");
        return this;
    }
}

// 객체 생성 절차 
public abstract class ComputerAlgorithm {
    protected Computer computer;

    public abstract void setCpu(String cpu);
    public abstract void setRam(String ram);
    public abstract void setStorage(String storage);

    public Computer getInstance() {
        return computer;
    }
}

public class KoreaComputerAlgorithm extends ComputerAlgorithm{

    KoreaComputerAlgorithm(){
        this.computer = new Computer();
    }

    @Override
    public void setCpu(String cpu) {
        computer.setCpu( "korea " + cpu );
    }

    @Override
    public void setRam(String ram) {
        computer.setRam( "korea " + ram );
    }

    @Override
    public void setStorage(String storage) {
        computer.setStorage( "korea " + storage );
    }
}


// 사용 예시
public static void main(String[] args) {
    Computer c = new ComputerFactory()
                    .setAlgorithm(new KoreaComputerAlgorithm()) // 생성 알고리즘 설정
                    .build()        // 빌드
                    .getInstance(); // 결과 인스턴스 반환
}

 

Spring 에서의 빌더 패턴 

1. 직접 구현 

public class Computer {
    private String cpu;
    private String ram;
    private String storage;

    public Computer() {
    }

    public static class Builder{
        private String cpu;
        private String ram;
        private String storage;

        public Builder() {
        }

        public String getCpu() {
            return cpu;
        }

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

        public String getRam() {
            return ram;
        }

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

        public String getStorage() {
            return storage;
        }

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

        public Computer build() {
            Computer computer = new Computer();
            computer.cpu = cpu;
            computer.ram = ram;
            computer.storage = storage;
            return computer;
        }
    }
}

// 사용 예시
public static void main(String[] args) {
    Computer computer = new Computer
                        .Builder()
                        .setRam("ram")
                        .setCpu("cpu")
                        .setStorage("storage")
                        .build();
}

 

2. Lombok 사용 

@Getter
@Builder
public class Computer {
    private String cpu;
    private String ram;
    private String storage;
}

// 사용 예시
public static void main(String[] args) {
    Computer computer = Computer.builder()
                        .ram("ram")
                        .cpu("cpu")
                        .storage("storage")
                        .build();
}

 

 

언제 사용해야 할까?

• 복합 객체 생성 패턴이 필요 할 때
• 생성자 생성을 강제 하고 싶은데, 파라미터가 너무 많이 필요한 경우

 

---

참조

https://refactoring.guru/ko/design-patterns/builder