SOLID 원칙: 소프트웨어 개발을 위한 핵심 원칙 5가지 with Java

date

Jun 5, 2023

slug

java-solid

author

status

Public

tags

Blog

Java

summary

SOLID 원칙을 이해하고, 잘 적용하는 방법 탐구해보기

type

Post

thumbnail

category

💻 Backend

updatedAt

Jun 6, 2023 09:32 PM

SOLID 원칙이란?

1. 유지보수성과 확장성 향상
• SOLID 원칙을 준수하는 코드는 변경에 유연하고 확장이 쉽습니다. 코드의 한 부분을 수정하거나 새로운 기능을 추가할 때, 다른 부분에 미치는 영향을 최소화하면서 변경이나 확장을 수행할 수 있습니다.

2. 재사용성 증대
• SOLID 원칙을 잘 지킨 코드는 재사용성이 높아집니다. 단일 책임 원칙을 준수하고 인터페이스 분리 원칙을 적용한 코드는 모듈이나 클래스를 다른 프로젝트나 시스템에서 재사용할 수 있습니다.

3. 가독성과 이해도 향상
• SOLID 원칙을 준수하는 코드는 응집성이 높아지고 의존성이 명확해집니다. 이로 인해 코드의 가독성과 이해도가 향상되어 다른 개발자들이 코드를 쉽게 이해하고 유지보수할 수 있습니다.

4. 유연한 아키텍처 구축
• SOLID 원칙은 좋은 소프트웨어 아키텍처를 구축하는 기반이 됩니다. 단일 책임 원칙과 인터페이스 분리 원칙은 모듈 간의 결합도를 낮추고 응집도를 높여 모듈화된 아키텍처를 설계하는 데 도움을 줍니다.

5. 테스트 용이성
• SOLID 원칙을 준수하는 코드는 테스트하기 쉽습니다. 단일 책임 원칙과 의존 역전 원칙은 의존성 주입(Dependency Injection)과 같은 테스트 용이한 패턴을 적용하기 쉽게 해줍니다.

단일 책임 원칙(Single Responsibility Principle, SRP)

public class PaymentService {
	public void processPayment(PaymentInfo paymentInfo) {
		// 결제 처리 로직
	}
}
public class NotificationService {
	public void sendNotification(String message) {
		// 알림 전송 로직
	}
}

개방-폐쇄 원칙(Open-Closed Principle, OCP)

public class PaymentRequest {
    // 결제 요청 정보 필드들...
}

public interface RequestBuilder {
    PaymentRequest build(PaymentInfo paymentInfo);
}

public class CreditCardRequestBuilder implements RequestBuilder {
    public PaymentRequest build(PaymentInfo paymentInfo) {
        // 신용카드 결제 요청 정보 구성
        // ...
        return paymentRequest;
    }
}

public class PayPalRequestBuilder implements RequestBuilder {
    public PaymentRequest build(PaymentInfo paymentInfo) {
        // PayPal 결제 요청 정보 구성
        // ...
        return paymentRequest;
    }
}

public class ExternalPaymentApi {
    private final Map<PaymentType, RequestBuilder> requestBuilders;

    public ExternalPaymentApi() {
        requestBuilders = new HashMap<>();
        requestBuilders.put(PaymentType.CREDIT_CARD, new CreditCardRequestBuilder());
        requestBuilders.put(PaymentType.PAYPAL, new PayPalRequestBuilder());
        // 다른 결제 타입에 대한 RequestBuilder 추가
    }

    public void processPayment(PaymentType paymentType, PaymentInfo paymentInfo) {
        RequestBuilder requestBuilder = requestBuilders.get(paymentType);
        if (requestBuilder != null) {
            PaymentRequest paymentRequest = requestBuilder.build(paymentInfo);
            // 외부 결제 API 호출 로직
        } else {
            // 처리할 수 없는 결제 타입에 대한 예외 처리 또는 기본 처리 로직
        }
    }
}

리스코프 치환 원칙(Liskov Substitution Principle, LSP)

1. 대체 가능성 유지
• 자식 클래스는 부모 클래스의 역할을 대체할 수 있습니다. 이는 클라이언트 코드에서 부모 클래스 타입으로 자식 클래스 객체를 사용하여도 문제없이 동작함을 의미합니다.

2. 모듈성과 유연성
• 새로운 자식 클래스를 추가하거나 기존의 자식 클래스를 변경할 때, 기존의 코드를 수정하지 않고도 대체할 수 있습니다. 이는 소프트웨어 시스템을 확장하고 유지보수하는 데 유리한 구조를 제공합니다.

3. 다형성과 확장성
• 리스코프 치환 원칙을 준수하면 다형성을 활용할 수 있습니다. 클라이언트 코드는 부모 클래스 타입을 사용하여 여러 종류의 자식 클래스를 다룰 수 있으며, 새로운 자식 클래스를 추가하여 시스템의 기능을 확장할 수 있습니다.

인터페이스 분리 원칙 (Interface Segregation Principle, ISP)

// Payment 인터페이스
public interface Payment {
    void processPayment();
}

// Refundable 인터페이스
public interface Refundable {
    void processRefund();
}

// 신용카드 결제 클래스
public class CreditCardPayment implements Payment {
    public void processPayment() {
        // 신용카드 결제 처리 로직
    }
}

// 환불 처리 클래스
public class RefundProcessor implements Refundable {
    public void processRefund() {
        // 환불 처리 로직
    }
}

의존 역전 원칙 (Dependency Inversion Principle, DIP)

public enum PaymentType {
    CREDIT_CARD,
    PAYPAL,
    // 다른 결제 타입들...
}

public class PaymentInfo {
    private PaymentType paymentType;
    // 결제 정보 관련 필드들...
}

public interface PaymentProcessor {
    void processPayment(PaymentInfo paymentInfo);
}

public class CreditCardPaymentProcessor implements PaymentProcessor {
    public void processPayment(PaymentInfo paymentInfo) {
        // 신용카드 결제 처리 로직
    }
}

public class PayPalPaymentProcessor implements PaymentProcessor {
    public void processPayment(PaymentInfo paymentInfo) {
        // PayPal 결제 처리 로직
    }
}

public class PaymentService {
    private final Map<PaymentType, PaymentProcessor> paymentProcessors;

    public PaymentService() {
        paymentProcessors = new HashMap<>();
        paymentProcessors.put(PaymentType.CREDIT_CARD, new CreditCardPaymentProcessor());
        paymentProcessors.put(PaymentType.PAYPAL, new PayPalPaymentProcessor());
        // 다른 결제 타입에 대한 처리 클래스들 추가
    }

    public void processPayment(PaymentInfo paymentInfo) {
        PaymentProcessor paymentProcessor = paymentProcessors.get(paymentInfo.getPaymentType());
        if (paymentProcessor != null) {
            paymentProcessor.processPayment(paymentInfo);
        } else {
            // 처리할 수 없는 결제 타입에 대한 예외 처리 또는 기본 처리 로직
        }
    }
}