close
프로필 배경
프로필 로고

ha-vlog

정보처리기사/서버 프로그램 구현 · 2024. 10. 18. fullscreen 넓게보기

모듈의 결합도와 응집도

반응형
SMALL

모듈

  • 모듈은 모듈화를 통해 분리된 시스템의 각 기능으로, 서브 루틴, 서브 시스템, 소프트웨어 내의 프로그램, 작업 단위 등을 의미한다.
  • 모듈의 기능적 독립성은 소프트웨어를 구성하는 각 모듈의 기능이 서로 독립됨을 의미한다.
  • 하나 또는 몇 개의 논리적인 기능을 수행하기 위한 명령어들의 집합이라고도 할 수 있다.
  • 모듈의 독립성은 결합도와 응집도에 의해 측정된다.

결합도

  • 결합도는 모듈 간에 상호 의존하는 정도 또는 두 모듈 사이의 연관 관계이다.
  • 결합도가 약할수록 품질이 높고, 강할수록 품질이 낮다.
  • 결합도의 종류와 강도
  • 내용 결합도>>공통 결합도>> 외부 결합도>> 제어 결합도>> 스템프 결합도>> 자료 결합도
  • 내가 공짜로 외제차 스탬프 찍고 자료 받는다.

결합도의 종류

  • 내용 결합도
    • 한 모듈이 다른 모듈의 내부 기능 및 그 내부 자료를 직접 참조하거나 수정할 때의 결합도이다.
    // A 모듈
class ModuleA {
    public int data = 42;
}

// B 모듈 (내용 결합도: A 모듈의 내부 데이터에 직접 접근)
class ModuleB {
    public void modifyAData(ModuleA moduleA) {
        moduleA.data = 99;  // A 모듈의 내부 데이터를 직접 수정
    }
}

public class Main {
    public static void main(String[] args) {
        ModuleA moduleA = new ModuleA();
        ModuleB moduleB = new ModuleB();
        
        System.out.println("Before modification: " + moduleA.data);  // 42 출력
        moduleB.modifyAData(moduleA);
        System.out.println("After modification: " + moduleA.data);   // 99 출력
    }
}
  • 공통 결합도
    • 공유되는 공통 데이터 영역을 여러 모듈이 사용할 때의 결합도이다.
    • 파라미터가 아닌 모듈 밖에 선언된 전역 변수를 사용하여 전역 변수를 갱신하는 방식으로 상호작용하는 때의 결합도이다.
    // 전역 변수 (공통 결합도)
public class SharedData {
    public static int sharedData = 0;
}

// A 모듈
class ModuleA {
    public void modifySharedData() {
        SharedData.sharedData = 10;  // 전역 변수 수정
    }
}

// B 모듈
class ModuleB {
    public void printSharedData() {
        System.out.println("Shared Data: " + SharedData.sharedData);  // 전역 변수 참조
    }
}

public class Main {
    public static void main(String[] args) {
        ModuleA moduleA = new ModuleA();
        ModuleB moduleB = new ModuleB();
        
        moduleA.modifySharedData();  // 전역 변수 수정
        moduleB.printSharedData();   // 전역 변수 출력
    }
}


    Shared Data: 10
  • 외부 결합도
    • 어떤 모듈에서 선언한 데이터(변수)를 외부의 다른 모듈에서 참조할 때의 결합도이다.
    // A 모듈에서 변수 선언
public class ModuleA {
    public static int externalData = 5;
}

// B 모듈 (외부 결합도: A 모듈에서 선언한 변수를 참조)
class ModuleB {
    public void useExternalData() {
        System.out.println("External Data: " + ModuleA.externalData);  // 외부에서 선언된 변수를 참조
    }
}

public class Main {
    public static void main(String[] args) {
        ModuleB moduleB = new ModuleB();
        moduleB.useExternalData();  // 외부 변수를 참조하여 출력
    }
}


    External Data: 5
  • 제어 결합도
    • 어떤 모듈이 다른 모듈 내부의 논리적인 흐름을 제어하기 위해 제어 신호나 제어 요소를 전달하는 결합도이다.
    // A 모듈
class ModuleA {
    public void controlFunction(String controlSignal) {
        if ("START".equals(controlSignal)) {
            System.out.println("Start operation");
        } else if ("STOP".equals(controlSignal)) {
            System.out.println("Stop operation");
        }
    }
}

// B 모듈 (제어 결합도: A 모듈에 제어 신호 전달)
class ModuleB {
    public void sendControlSignal() {
        ModuleA moduleA = new ModuleA();
        moduleA.controlFunction("START");  // 제어 신호 전달
        moduleA.controlFunction("STOP");   // 제어 신호 전달
    }
}

public class Main {
    public static void main(String[] args) {
        ModuleB moduleB = new ModuleB();
        moduleB.sendControlSignal();  // 신호에 따른 동작 출력
    }
}


    Start operation
Stop operation
    • 하위 모듈에서 상위 모듈로 제어 신호가 이동하여 하위 모듈이 상위 모듈에게 처리 명령을 내리는 권리 전도 현상이 발생하게 된다.
  • 스템프(검인) 결합도
    • 모듈 간의 인터페이스로 배열이나 레코드 등의 자료 구조가 전달될 때의 결합도이다.
    // 데이터 구조 (예: HashMap)
import java.util.HashMap;
import java.util.Map;

// A 모듈
class ModuleA {
    public void processData(Map<String, Object> info) {
        System.out.println("Name: " + info.get("name") + ", Age: " + info.get("age"));
    }
}

// B 모듈 (스템프 결합도: 자료 구조를 전달)
class ModuleB {
    public void sendData() {
        Map<String, Object> dataStructure = new HashMap<>();
        dataStructure.put("name", "Alice");
        dataStructure.put("age", 30);
        
        ModuleA moduleA = new ModuleA();
        moduleA.processData(dataStructure);  // B 모듈에서 자료 구조 전달
    }
}

public class Main {
    public static void main(String[] args) {
        ModuleB moduleB = new ModuleB();
        moduleB.sendData();  // 전달된 자료 출력
    }
}


    Name: Alice, Age: 30
  • 자료 결합도
    • 모듈 간의 인터페이스가 자료 요소로만 구성될 때의 결합도이다.
    // A 모듈
class ModuleA {
    public void processValue(int value) {
        System.out.println("Value: " + value);
    }
}

// B 모듈 (자료 결합도: 단순 데이터 전달)
class ModuleB {
    public void sendValue() {
        ModuleA moduleA = new ModuleA();
        moduleA.processValue(42);  // B 모듈에서 단일 데이터 전달
    }
}

public class Main {
    public static void main(String[] args) {
        ModuleB moduleB = new ModuleB();
        moduleB.sendValue();  // 단일 값 출력
    }
}


    Value: 42

응집도

  • 응집도는 모듈의 내부 요소들이 서로 관련되어 있는 정도이다.
  • 응집도가 강할 수록 품질이 높고, 약할 수록 품질이 낮다.
  • 기능적 응집도>> 순차적 응집도>> 교환적 응집도>> 절차적 응집도>> 시간적 응집도>> 논리적 응집도>> 우연적 응집도
  • 기능을 순서대로 교환하고 절대적으로 시간의 논리를 우려한다

응집도의 종류

  • 기능적 응집도
    • 모듈 내부의 모든 기능 요소들이 단일 문제와 연관되어 수행될 경우의 응집도이다.
    // A 모듈: 기능적 응집도 (로그인 관련 모든 기능을 포함)
class UserAuthentication {
    public void login(String username, String password) {
        if (authenticate(username, password)) {
            System.out.println("Login successful!");
        } else {
            System.out.println("Login failed.");
        }
    }

    private boolean authenticate(String username, String password) {
        // 간단한 인증 로직
        return "user".equals(username) && "password".equals(password);
    }
}

public class Main {
    public static void main(String[] args) {
        UserAuthentication auth = new UserAuthentication();
        auth.login("user", "password");
    }
}
    Login successful!
  • 순차적 응집도
    • 모듈 내 하나의 활동으로부터 나온 출력 데이터를 그 다음 활동의 입력 데이터로 사용할 경우의 응집도이다.
    // A 모듈: 순차적 응집도 (텍스트 처리 후 저장)
class TextProcessor {
    public void process(String input) {
        String cleaned = clean(input);
        String formatted = format(cleaned);
        save(formatted);
    }

    private String clean(String text) {
        return text.trim();  // 공백 제거
    }

    private String format(String text) {
        return text.toUpperCase();  // 대문자로 변환
    }

    private void save(String text) {
        System.out.println("Saved: " + text);
    }
}

public class Main {
    public static void main(String[] args) {
        TextProcessor processor = new TextProcessor();
        processor.process("  Hello World  ");
    }
}


    Saved: HELLO WORLD
  • 교환[통신]적 응집도
    • 동일한 입력과 출력을 사용하여 서로 다른 기능을 수행하는 구성 요소들이 모였을 경우의 응집도이다.
    // A 모듈: 교환적 응집도 (같은 데이터를 사용하여 서로 다른 처리)
class DataHandler {
    public void printData(String data) {
        System.out.println("Printing: " + data);
    }

    public void saveData(String data) {
        System.out.println("Saving: " + data);
    }
}

public class Main {
    public static void main(String[] args) {
        DataHandler handler = new DataHandler();
        String data = "Report";

        handler.printData(data);  // 데이터 출력
        handler.saveData(data);   // 데이터 저장
    }
}


    Printing: Report
Saving: Report
  • 절차적 응집도
    • 모듈이 다수의 관련 기능을 가질 때 모듈 안의 구성 요소들이 그 기능을 순차적으로 수행할 경우의 응집도이다.
    // A 모듈: 절차적 응집도 (회원 가입 절차)
class UserRegistration {
    public void register(String username, String password, String email) {
        validate(username, password, email);
        createAccount(username, password, email);
        sendConfirmationEmail(email);
    }

    private void validate(String username, String password, String email) {
        System.out.println("Validating user information...");
    }

    private void createAccount(String username, String password, String email) {
        System.out.println("Creating user account...");
    }

    private void sendConfirmationEmail(String email) {
        System.out.println("Sending confirmation email to " + email);
    }
}

public class Main {
    public static void main(String[] args) {
        UserRegistration registration = new UserRegistration();
        registration.register("user123", "password", "user@example.com");
    }
}


    Validating user information...
Creating user account...
Sending confirmation email to user@example.com
  • 시간적 응집도
    • 특정 시간에 처리되는 몇 개의 기능을 모아 하나의 모듈로 작성할 경우의 응집도이다.
    // A 모듈: 시간적 응집도 (프로그램 초기화 시 필요한 작업)
class Initialization {
    public void initialize() {
        loadConfiguration();
        connectToDatabase();
        initializeCache();
    }

    private void loadConfiguration() {
        System.out.println("Loading configuration...");
    }

    private void connectToDatabase() {
        System.out.println("Connecting to database...");
    }

    private void initializeCache() {
        System.out.println("Initializing cache...");
    }
}

public class Main {
    public static void main(String[] args) {
        Initialization init = new Initialization();
        init.initialize();
    }
}


    Loading configuration...
Connecting to database...
Initializing cache...
  • 논리적 응집도
    • 유사한 성격을 갖거나 특정 형태로 분류되는 처리 요소들로 하나의 모듈이 형성되는 경우의 응집도이다.
    // A 모듈: 논리적 응집도 (다양한 에러 처리를 위한 모듈)
class ErrorHandler {
    public void handleError(int errorCode) {
        if (errorCode == 404) {
            handleNotFound();
        } else if (errorCode == 500) {
            handleServerError();
        } else {
            handleUnknownError();
        }
    }

    private void handleNotFound() {
        System.out.println("Handling 404 Not Found error...");
    }

    private void handleServerError() {
        System.out.println("Handling 500 Server error...");
    }

    private void handleUnknownError() {
        System.out.println("Handling unknown error...");
    }
}

public class Main {
    public static void main(String[] args) {
        ErrorHandler errorHandler = new ErrorHandler();
        errorHandler.handleError(404);  // 404 에러 처리
        errorHandler.handleError(500);  // 500 에러 처리
    }
}


    Handling 404 Not Found error...
Handling 500 Server error...
  • 우연적 응집도
    • 모듈 내부의 각 구성 요소들이 서로 관련 없는 요소로만 구성된 경우의 응집도이다.
    // A 모듈: 우연적 응집도 (서로 관련 없는 기능들이 모여 있는 모듈)
class MiscellaneousTasks {
    public void openFile() {
        System.out.println("Opening file...");
    }

    public void connectToNetwork() {
        System.out.println("Connecting to network...");
    }

    public void logMessage(String message) {
        System.out.println("Logging: " + message);
    }
}

public class Main {
    public static void main(String[] args) {
        MiscellaneousTasks tasks = new MiscellaneousTasks();
        tasks.openFile();             // 파일 열기
        tasks.connectToNetwork();     // 네트워크 연결
        tasks.logMessage("Hello!");   // 메시지 기록
    }
}


    Opening file...
Connecting to network...
Logging: Hello!
    팬인/팬아웃
  • 팬인은 어떤 모듈을 제어하는 모듈의 수
  • 팬아웃은 어떤 모듈에 의해 제어되는 모듈의 수
반응형
LIST

'정보처리기사 > 서버 프로그램 구현' 카테고리의 다른 글

IPC(INTER-PROCESS COMMUNICATION)  (0) 2024.10.18
N-S차트  (0) 2024.10.18
객체 지향 분석의 방법론  (1) 2024.10.17
객체지향 설계의 핵심 원리-클래스,메시지,캡슐화  (3) 2024.10.17
소프트웨어 설계 패턴  (12) 2024.10.17
정보처리기사/서버 프로그램 구현 관련 글
더 보기

티스토리툴바