OOP: 소프트웨어 유지보수성

쩌리Dev 2025. 3. 12. 20:23

소프트웨어는 개발 후에도 지속적인 업데이트, 버그 수정, 기능 추가가 필요합니다. 이러한 변화에 효과적으로 대응하기 위해서는 시스템의 유지보수성이 매우 중요합니다. OOP는 복잡한 소프트웨어를 모듈화하고, 각 구성 요소의 독립성을 확보하여 유지보수를 용이하게 만드는 핵심 설계 패러다임으로 자리잡았습니다.

그렇다면, 소프트웨어 개발이 있어서 유지보수가 중요한 이유는 무엇일까요?

소프트웨어 유지보수성이 중요한 이유

1. 변화하는 요구사항에 대응

• 요구사항의 변화: 비즈니스 환경이나 사용자의 요구는 시간이 지남에 따라 변화합니다. 초기 설계 시 예측하기 어려운 변경 사항들이 발생할 수 있으므로, 시스템이 유연하게 대응할 수 있어야 합니다.

• 확장 및 기능 추가: 새로운 기능을 추가하거나 기존 기능을 개선할 때, 시스템 전체에 미치는 영향을 최소화하고 빠르게 수정할 수 있는 구조가 필요합니다.

2. 오류 수정 및 개선의 효율성

• 문제 격리: 유지보수성이 높은 시스템은 문제가 발생했을 때 해당 모듈이나 컴포넌트를 빠르게 식별하고 수정할 수 있도록 돕습니다.

• 단위 테스트와 디버깅: 모듈 단위로 구성된 시스템은 개별 컴포넌트에 대한 단위 테스트가 용이하여, 오류 발생 시 빠른 진단과 해결이 가능합니다.

3. 협업과 코드 관리

• 팀 단위 개발: 대규모 프로젝트에서는 여러 개발자가 동시에 작업하는 경우가 많습니다. 모듈화된 구조는 팀원 간의 역할 분담과 코드 충돌을 최소화하여 협업을 원활하게 합니다.

• 버전 관리: 모듈별로 변경 내역을 추적할 수 있어, 롤백이나 버전 관리가 효율적으로 이루어집니다.

결론적으로는 소프트웨어의 규모는 요구사항, 개선등 확장하고 소프트웨어가 확장되어감에 따라 구조도 복잡해지고 협업하는 팀원들도 증가하여서 요구사항, 개선, 협업등을 할 수 있어야 한다라고 볼 수 있겠습니다.

그렇다면, 한번 더 고민하여서 유지보수성이 좋다라고 판단하기 위해 어떤 개념들을 이해하고 있으면 좋을까요?

의존성, 결합도, 응집도: 유지보수성을 좌우하는 핵심 개념

1 의존성(Dependency)

• 정의: 한 모듈이나 클래스가 다른 모듈이나 클래스에 의존하는 정도를 의미합니다.

• 유지보수성 관점: 의존성이 낮을수록 한 모듈의 변경이 다른 모듈에 미치는 영향을 줄여 유지보수를 쉽게 만듭니다.

2 결합도(Coupling)

• 정의: 모듈 간의 연결 정도를 나타내며, 한 모듈이 다른 모듈의 내부 구조나 구현에 얼마나 의존하는지를 의미합니다.

• 유지보수성 관점: 낮은 결합도는 모듈을 독립적으로 수정할 수 있게 해주어, 변경 시 다른 부분에 미치는 영향을 최소화합니다.

3 응집도(Cohesion)

• 정의: 모듈 내의 구성 요소들이 얼마나 밀접하게 관련되어 있는지를 나타냅니다.

• 유지보수성 관점: 높은 응집도는 모듈 내의 기능이 하나의 목적에 집중되어 있음을 의미하며, 이는 코드의 가독성과 재사용성을 높입니다.

결론적으로는 의존성, 결합도, 응집도는 모듈간에 얼마나 관련이 있고 유지보수시에 영향을 미치는지 판단하는 개념이 되어집니다. 소프트웨어의 유지보수를 잘하기 위해서는 의존성과 결합도는 낮추며 응집도를 높이는 개발을 할 수 있도록 해야합니다.

각 개념들을 이해하기 쉬게 코드로 한번 보도록 하겠습니다.

높은 의존성 (High Dependency)

높은 의존성은 한 모듈이나 클래스가 다른 모듈의 구체적인 구현에 직접 의존할 때 발생합니다. 이렇게 되면, 의존하는 모듈의 구현이 변경될 경우 이를 사용하는 모듈도 함께 수정해야 하므로 유지보수가 어려워집니다.

// 구체적인 결제 게이트웨이 클래스
public class StripePaymentGateway {
    public void processPayment(double amount) {
        System.out.println("Stripe로 $" + amount + " 결제 처리");
    }
}

// 의존성이 높은 PaymentProcessor 클래스: 인터페이스가 아닌 구체 클래스에 직접 의존
public class PaymentProcessor {
    private StripePaymentGateway gateway;

    public PaymentProcessor() {
        // 직접 객체 생성하여 구체 클래스에 의존
        gateway = new StripePaymentGateway();
    }

    public void process(double amount) {
        gateway.processPayment(amount);
    }
}

PaymentProcessor 클래스는 StripePaymentGateway라는 구체 클래스에 직접 의존하고 있습니다. 만약 다른 결제 게이트웨이(예: PayPal)를 사용해야 한다면, PaymentProcessor의 코드를 변경해야 하므로 유지보수성이 낮아집니다.

높은 결합도 (High Coupling)

높은 결합도는 모듈 간에 서로 밀접하게 연결되어 있는 경우를 의미합니다. 한 모듈의 변경이 다른 모듈에도 영향을 미치기 때문에 독립적인 수정이 어려워집니다.

// InventoryService: 재고 확인을 위한 클래스
public class InventoryService {
    public int checkStock(String item) {
        // 단순 예시: 실제 로직은 복잡할 수 있음
        return 10;  // 항상 10개 재고 있다고 가정
    }
}

// OrderService: 주문 처리를 위한 클래스
public class OrderService {
    // OrderService는 InventoryService에 직접 의존하여 객체를 생성
    private InventoryService inventoryService;

    public OrderService() {
        // 내부에서 직접 인스턴스 생성 => 높은 결합도
        inventoryService = new InventoryService();
    }

    public void placeOrder(String item, int quantity) {
        int stock = inventoryService.checkStock(item);
        if (stock < quantity) {
            throw new RuntimeException("재고 부족: " + item);
        }
        // 주문 처리 로직 진행
        System.out.println(item + " 주문 완료, 수량: " + quantity);
    }
}

OrderService는 InventoryService에 직접적으로 의존하고 있어, 만약 재고 확인 로직이나 InventoryService의 인터페이스가 변경되면 OrderService도 함께 수정해야 합니다. 이렇게 모듈 간 결합도가 높으면 유지보수가 어려워집니다.

높은 응집도 (High Cohesion)

높은 응집도는 하나의 모듈이나 클래스가 단일 책임에 집중하여 관련된 기능만을 수행할 때 발생합니다. 이렇게 되면 모듈이 명확한 역할을 가지게 되어 이해하기 쉽고, 재사용 및 테스트도 용이해집니다.

// ReportGenerator: 보고서를 생성하는 역할만 수행
public class ReportGenerator {
    public String generateReport(String data) {
        // 데이터 처리 및 보고서 생성 로직
        return "보고서: " + data;
    }
}

// ReportPrinter: 보고서를 출력하는 역할만 수행
public class ReportPrinter {
    public void printReport(String report) {
        System.out.println(report);
    }
}

// 클라이언트 코드: 두 클래스의 책임이 명확히 분리됨
public class ReportManager {
    private ReportGenerator generator;
    private ReportPrinter printer;

    public ReportManager() {
        generator = new ReportGenerator();
        printer = new ReportPrinter();
    }

    public void processReport(String data) {
        String report = generator.generateReport(data);
        printer.printReport(report);
    }
}

ReportGenerator와 ReportPrinter는 각각 보고서 생성과 출력이라는 단일 책임만 수행하므로 응집도가 높습니다. 이 경우, 각 클래스가 하나의 역할에 집중되어 있어 변경이나 재사용, 테스트 시 유지보수성이 크게 향상됩니다.

이와 같이 의존성, 결합도, 응집도는 소프트웨어 유지보수성을 결정하는 중요한 요소입니다.높은 의존성과 높은 결합도는 변경 시 연쇄적으로 영향을 미쳐 유지보수 비용을 증가시키지만,높은 응집도는 모듈이 명확한 책임을 가지고 독립적으로 관리될 수 있어 유지보수를 용이하게 만듭니다.이러한 원칙을 고려하여 OOP를 설계하면, 보다 견고하고 변화에 유연한 시스템을 구축할 수 있습니다.