[Design Patterns] 23. 패턴을 활용한 코드 리뷰와 설계 리뷰 — 실습

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# Observer 패턴 코드 리뷰 체크리스트

## 패턴 적용 적절성
- [ ] 일대다 의존 관계가 실제로 필요한가?
- [ ] 상태 변화 알림이 핵심 요구사항인가?
- [ ] Observer 수가 동적으로 변할 가능성이 있는가?
- [ ] 더 간단한 콜백이나 리스너로 해결 가능하지 않은가?

## 구현 완전성
- [ ] Subject 인터페이스가 명확히 정의되었나?
- [ ] Observer 등록/해제 메서드가 구현되었나?
- [ ] notifyObservers() 메서드가 적절히 호출되는가?
- [ ] Observer 인터페이스가 일관된 시그니처를 가지는가?

## 주요 위험 요소
- [ ] 메모리 누수 방지책이 있는가? (WeakReference 고려)
- [ ] Observer 실행 중 예외가 전체에 영향을 주지 않는가?
- [ ] 순환 참조 위험은 없는가?
- [ ] 동시성 이슈에 대한 고려가 있는가?

## 성능 고려사항
- [ ] Observer 수가 많을 때 성능 영향을 고려했는가?
- [ ] 비동기 알림이 필요한 경우를 판단했는가?
- [ ] 알림 필터링이나 우선순위가 필요한가?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

import java.util.ArrayList;
import java.util.List;

// 11장에서 정의한 최소 인터페이스 (동일 시그니처)
interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers();
}

interface Observer {
    void update(Subject subject);
}

// TODO: 다음 Observer 구현을 체크리스트로 검토하세요
public class StockPrice implements Subject {
    private String symbol;
    private double price;
    private List<Observer> observers = new ArrayList<>();
    
    public void attach(Observer observer) {
        observers.add(observer);
    }
    
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(this);
        }
    }
    
    public void setPrice(double price) {
        this.price = price;
        notifyObservers();
    }
}

// 리뷰 포인트들:
// 1. 동시성 안전성 - ArrayList는 thread-safe하지 않음
// 2. 예외 안전성 - Observer 예외가 전파될 수 있음
// 3. 메모리 누수 - Strong reference로 인한 위험
// 4. 성능 - 동기식 알림으로 인한 블로킹 위험

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

import java.util.ArrayList;
import java.util.List;

// TODO: Strategy 패턴 검증 규칙 구현
public class StrategyPatternValidator {
    
    public ValidationResult validate(Class<?> contextClass) {
        ValidationResult result = new ValidationResult();
        
        // 1. Strategy 인터페이스 존재 확인
        if (!hasStrategyInterface(contextClass)) {
            result.addError("No strategy interface found");
        }
        
        // 2. Context가 Strategy를 의존하는지 확인
        if (!hasStrategyDependency(contextClass)) {
            result.addError("Context doesn't depend on strategy interface");
        }
        
        // 3. 최소 2개 이상의 구현체 확인
        List<Class<?>> implementations = findStrategyImplementations(contextClass);
        if (implementations.size() < 2) {
            result.addWarning("Less than 2 strategy implementations found");
        }
        
        // 4. Strategy 교체 메커니즘 확인
        if (!hasStrategySetterOrConstructor(contextClass)) {
            result.addError("No strategy injection mechanism found");
        }
        
        return result;
    }
    
    // 이 메서드가 필요한 이유: Strategy 패턴이라고 부르려면 최소한 "교체 가능한 알고리즘"을 표현하는
    // 인터페이스가 있어야 합니다. 이 확인이 없으면 아래 hasStrategyDependency() 이하의 검증들이
    // 애초에 무엇을 기준으로 "Strategy"인지 판단할 근거를 잃습니다.
    private boolean hasStrategyInterface(Class<?> contextClass) {
        // TODO: 리플렉션으로 Strategy 인터페이스 탐지
        return false;
    }
    
    // 이 메서드가 필요한 이유: 인터페이스가 존재해도 Context가 그것을 실제로 의존(필드/생성자 파라미터)하지
    // 않는다면 패턴이 아니라 단순히 같은 패키지에 있는 무관한 타입일 수 있습니다.
    private boolean hasStrategyDependency(Class<?> contextClass) {
        // TODO: 필드나 생성자에서 Strategy 의존성 확인
        return false;
    }
    
    // 이 메서드가 필요한 이유: 구현체가 1개뿐이면 "교체 가능성"이라는 Strategy의 핵심 의도가 실현되지
    // 않은 것이므로, 굳이 인터페이스로 추상화할 필요가 없었다는 신호(과설계 의심)로 활용됩니다.
    private List<Class<?>> findStrategyImplementations(Class<?> contextClass) {
        // TODO: 클래스패스에서 Strategy 구현체들 찾기
        return new ArrayList<>();
    }
    
    // 이 메서드가 필요한 이유: 인터페이스와 구현체가 있어도 런타임에 전략을 바꿔 끼울 통로(setter,
    // 생성자 주입 등)가 없으면 사실상 하드코딩된 것과 같아 Strategy 패턴의 목적을 달성하지 못합니다.
    private boolean hasStrategySetterOrConstructor(Class<?> contextClass) {
        // TODO: Strategy 설정 메커니즘 확인
        return false;
    }
}

// 검증 결과를 담는 값 객체. 오류(error)는 패턴 위반, 경고(warning)는 설계 재검토 신호로 구분한다.
class ValidationResult {
    private final List<String> errors = new ArrayList<>();
    private final List<String> warnings = new ArrayList<>();

    public void addError(String message) {
        errors.add(message);
    }

    public void addWarning(String message) {
        warnings.add(message);
    }

    public List<String> getErrors() { return errors; }
    public List<String> getWarnings() { return warnings; }
    public boolean isValid() { return errors.isEmpty(); }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import net.sourceforge.pmd.lang.java.ast.ASTClassOrInterfaceDeclaration;
import net.sourceforge.pmd.lang.java.rule.AbstractJavaRule;

// TODO: PMD/SpotBugs 스타일의 규칙 작성
public class StrategyPatternRule extends AbstractJavaRule {
    
    @Override
    public Object visit(ASTClassOrInterfaceDeclaration node, Object data) {
        if (isPotentialStrategyContext(node)) {
            validateStrategyPattern(node, data);
        }
        return super.visit(node, data);
    }
    
    private boolean isPotentialStrategyContext(ASTClassOrInterfaceDeclaration node) {
        // TODO: Strategy Context 후보 클래스 식별
        // 1. 특정 네이밍 패턴 (xxxContext, xxxManager)
        // 2. 인터페이스 타입 필드 존재
        // 3. 조건부 로직 존재
        return false;
    }
    
    private void validateStrategyPattern(ASTClassOrInterfaceDeclaration node, Object data) {
        // TODO: AST 기반 패턴 검증
        // 1. if-else/switch 문이 Strategy로 대체 가능한지 확인
        // 2. Strategy 인터페이스 설계 품질 검증
        // 3. 누락된 Strategy 구현체 제안
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106

import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class AutomatedPatternReviewService {

    private final PatternDetector patternDetector;
    private final PatternValidator strategyValidator;
    private final PatternValidator observerValidator;
    private final PatternValidator factoryValidator;

    public AutomatedPatternReviewService(PatternDetector patternDetector,
                                          PatternValidator strategyValidator,
                                          PatternValidator observerValidator,
                                          PatternValidator factoryValidator) {
        this.patternDetector = patternDetector;
        this.strategyValidator = strategyValidator;
        this.observerValidator = observerValidator;
        this.factoryValidator = factoryValidator;
    }

    public ReviewReport conductPatternReview(CodeSubmission submission) {
        ReviewReport report = new ReviewReport();
        
        // 1. 패턴 탐지
        List<DetectedPattern> patterns = patternDetector.analyze(submission.files());
        
        // 2. 각 패턴별 검증
        for (DetectedPattern pattern : patterns) {
            PatternValidationResult result = validatePattern(pattern);
            report.addValidationResult(result);
        }
        
        // 3. 개선 제안 생성
        List<ImprovementSuggestion> suggestions = generateSuggestions(patterns);
        report.setSuggestions(suggestions);
        
        // 4. 점수 계산
        double score = calculatePatternScore(report);
        report.setScore(score);
        
        return report;
    }
    
    private PatternValidationResult validatePattern(DetectedPattern pattern) {
        switch (pattern.type()) {
            case STRATEGY:
                return strategyValidator.validate(pattern);
            case OBSERVER:
                return observerValidator.validate(pattern);
            case FACTORY:
                return factoryValidator.validate(pattern);
            default:
                return PatternValidationResult.skip();
        }
    }

    // TODO: 검증 결과를 근거로 구체적 개선 제안(리팩토링 방향 등) 생성
    private List<ImprovementSuggestion> generateSuggestions(List<DetectedPattern> patterns) {
        return new ArrayList<>();
    }

    // TODO: 오류/경고 개수와 심각도를 반영해 0.0~100.0 점수로 환산
    private double calculatePatternScore(ReviewReport report) {
        return 0.0;
    }
}

// --- 이 서비스가 참조하는 보조 타입 ---

enum PatternType { STRATEGY, OBSERVER, FACTORY }

interface PatternDetector {
    List<DetectedPattern> analyze(List<String> sourceFiles);
}

interface PatternValidator {
    PatternValidationResult validate(DetectedPattern pattern);
}

record CodeSubmission(List<String> files) {}
record DetectedPattern(PatternType type) {}
record ImprovementSuggestion(String description) {}

record PatternValidationResult(boolean skipped, List<String> issues) {
    static PatternValidationResult skip() {
        return new PatternValidationResult(true, List.of());
    }

    static PatternValidationResult of(List<String> issues) {
        return new PatternValidationResult(false, issues);
    }
}

class ReviewReport {
    private final List<PatternValidationResult> validationResults = new ArrayList<>();
    private List<ImprovementSuggestion> suggestions = new ArrayList<>();
    private double score;

    void addValidationResult(PatternValidationResult result) { validationResults.add(result); }
    void setSuggestions(List<ImprovementSuggestion> suggestions) { this.suggestions = suggestions; }
    void setScore(double score) { this.score = score; }
    double getScore() { return score; }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;

// TODO: 팀 리뷰 현황 분석 도구
public class ReviewProcessAnalyzer {
    
    public ReviewProcessReport analyzeTeamReviewProcess(Team team, Period period) {
        ReviewProcessReport report = new ReviewProcessReport();
        
        // 1. 리뷰 참여도 분석
        ReviewParticipationMetrics participation = calculateParticipation(team, period);
        report.setParticipation(participation);
        
        // 2. 패턴 관련 리뷰 비율
        double patternReviewRatio = calculatePatternReviewRatio(team, period);
        report.setPatternReviewRatio(patternReviewRatio);
        
        // 3. 리뷰 효과성 측정
        ReviewEffectiveness effectiveness = measureEffectiveness(team, period);
        report.setEffectiveness(effectiveness);
        
        // 4. 개선 영역 식별
        List<ImprovementArea> areas = identifyImprovementAreas(report);
        report.setImprovementAreas(areas);
        
        return report;
    }
    
    private ReviewParticipationMetrics calculateParticipation(Team team, Period period) {
        // TODO: 리뷰 참여 통계 계산 (평균 리뷰어 수, 리뷰 완료율, 응답 시간)
        return new ReviewParticipationMetrics(0.0, 0.0, 0.0);
    }
    
    private double calculatePatternReviewRatio(Team team, Period period) {
        // TODO: 패턴 관련 코멘트 비율 계산
        return 0.0;
    }

    // TODO: 결함 발견율·오탐률 등으로 리뷰 효과성 측정
    private ReviewEffectiveness measureEffectiveness(Team team, Period period) {
        return new ReviewEffectiveness(0.0, 0.0);
    }

    // TODO: 낮은 지표(참여도/효과성)를 근거로 개선 영역 식별
    private List<ImprovementArea> identifyImprovementAreas(ReviewProcessReport report) {
        return new ArrayList<>();
    }
}

// --- 과제 3 전체(현재 상태 분석 · 개선 계획 · 대시보드)가 공유하는 보조 타입 ---

record Team(String id, List<String> memberIds) {}
record Period(LocalDate start, LocalDate end) {}
record ReviewParticipationMetrics(double averageReviewersPerPr, double completionRate, double averageResponseHours) {}
record ReviewEffectiveness(double defectDetectionRate, double falsePositiveRate) {}
record ImprovementArea(String name, String reason) {}

class ReviewProcessReport {
    private ReviewParticipationMetrics participation;
    private double patternReviewRatio;
    private ReviewEffectiveness effectiveness;
    private List<ImprovementArea> improvementAreas = new ArrayList<>();

    // 아래 세 진단 점수는 "개선 계획 수립" 절에서 사용한다. 실제 구현에서는
    // participation·effectiveness 값을 가중합해 계산한 뒤 채워 넣는다.
    private double patternKnowledgeScore;
    private double automationLevel;
    private double reviewEfficiency;

    void setParticipation(ReviewParticipationMetrics v) { this.participation = v; }
    void setPatternReviewRatio(double v) { this.patternReviewRatio = v; }
    void setEffectiveness(ReviewEffectiveness v) { this.effectiveness = v; }
    void setImprovementAreas(List<ImprovementArea> v) { this.improvementAreas = v; }

    double getPatternKnowledgeScore() { return patternKnowledgeScore; }
    void setPatternKnowledgeScore(double v) { this.patternKnowledgeScore = v; }
    double getAutomationLevel() { return automationLevel; }
    void setAutomationLevel(double v) { this.automationLevel = v; }
    double getReviewEfficiency() { return reviewEfficiency; }
    void setReviewEfficiency(double v) { this.reviewEfficiency = v; }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;

// TODO: 팀별 맞춤 개선 계획
public class ReviewProcessImprovementPlan {
    
    public ImprovementPlan createImprovementPlan(Team team, ReviewProcessReport currentState) {
        ImprovementPlan plan = new ImprovementPlan();
        
        // 1. 교육 계획
        if (currentState.getPatternKnowledgeScore() < 70) {
            plan.addAction(new PatternEducationAction(
                "Design Pattern Workshop",
                Duration.ofDays(30),
                Priority.HIGH
            ));
        }
        
        // 2. 도구 도입
        if (currentState.getAutomationLevel() < 50) {
            plan.addAction(new ToolIntegrationAction(
                "Automated Pattern Checker Integration",
                Duration.ofDays(14),
                Priority.MEDIUM
            ));
        }
        
        // 3. 프로세스 개선
        if (currentState.getReviewEfficiency() < 80) {
            plan.addAction(new ProcessOptimizationAction(
                "Review Checklist Standardization",
                Duration.ofDays(7),
                Priority.HIGH
            ));
        }
        
        return plan;
    }
}

// --- 개선 액션 타입 계층 ---

enum Priority { HIGH, MEDIUM, LOW }

abstract class ImprovementAction {
    private final String title;
    private final Duration estimatedDuration;
    private final Priority priority;

    protected ImprovementAction(String title, Duration estimatedDuration, Priority priority) {
        this.title = title;
        this.estimatedDuration = estimatedDuration;
        this.priority = priority;
    }

    public String getTitle() { return title; }
    public Duration getEstimatedDuration() { return estimatedDuration; }
    public Priority getPriority() { return priority; }
}

class PatternEducationAction extends ImprovementAction {
    public PatternEducationAction(String title, Duration estimatedDuration, Priority priority) {
        super(title, estimatedDuration, priority);
    }
}

class ToolIntegrationAction extends ImprovementAction {
    public ToolIntegrationAction(String title, Duration estimatedDuration, Priority priority) {
        super(title, estimatedDuration, priority);
    }
}

class ProcessOptimizationAction extends ImprovementAction {
    public ProcessOptimizationAction(String title, Duration estimatedDuration, Priority priority) {
        super(title, estimatedDuration, priority);
    }
}

class ImprovementPlan {
    private final List<ImprovementAction> actions = new ArrayList<>();

    public void addAction(ImprovementAction action) { actions.add(action); }
    public List<ImprovementAction> getActions() { return actions; }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// TODO: 리뷰 품질 대시보드
public class ReviewQualityDashboard {
    
    public DashboardData generateDashboard(Team team) {
        // 네 지표를 먼저 로컬 변수로 모두 계산한 뒤, 마지막에 한 번의 생성자 호출로 조립한다.
        double patternQualityScore = calculatePatternQualityScore(team);
        List<ParticipationTrend> trends = calculateParticipationTrends(team);
        Map<PatternType, ReviewStats> patternStats = calculatePatternStats(team);
        ImprovementMetrics improvements = measureImprovements(team);

        return new DashboardData(patternQualityScore, trends, patternStats, improvements);
    }

    // TODO: 패턴 적용 품질을 0~100 점수로 환산
    private double calculatePatternQualityScore(Team team) {
        return 0.0;
    }

    // TODO: 기간별 참여도 추이 계산
    private List<ParticipationTrend> calculateParticipationTrends(Team team) {
        return new ArrayList<>();
    }

    // TODO: 패턴 타입별 리뷰 코멘트/위반 통계 집계
    private Map<PatternType, ReviewStats> calculatePatternStats(Team team) {
        return new HashMap<>();
    }

    // TODO: 개선 계획 실행 전후 지표 비교
    private ImprovementMetrics measureImprovements(Team team) {
        return new ImprovementMetrics(0.0, 0.0);
    }
}

// --- 대시보드가 참조하는 보조 타입 ---

record ParticipationTrend(String weekLabel, double participationRate) {}
record ReviewStats(int totalReviews, int violationsFound) {}
record ImprovementMetrics(double beforeScore, double afterScore) {}

record DashboardData(double patternQualityScore,
                      List<ParticipationTrend> participationTrends,
                      Map<PatternType, ReviewStats> patternStats,
                      ImprovementMetrics improvements) {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# .github/workflows/pattern-review.yml
name: Pattern Quality Check
on: [pull_request]
jobs:
  pattern-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run Pattern Validator
        run: |
          java -jar pattern-validator.jar --src src/main/java
      - name: Post Review Comments
        uses: ./.github/actions/post-pattern-review

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import org.sonar.check.Rule;
import org.sonar.plugins.java.api.IssuableSubscriptionVisitor;
import org.sonar.plugins.java.api.tree.ClassTree;
import org.sonar.plugins.java.api.tree.Tree;

import java.util.Collections;
import java.util.List;

@Rule(key = "strategy-pattern-violation")
public class StrategyPatternViolationRule extends IssuableSubscriptionVisitor {

    @Override
    public List<Tree.Kind> nodesToVisit() {
        return Collections.singletonList(Tree.Kind.CLASS);
    }

    @Override
    public void visitNode(Tree tree) {
        ClassTree classTree = (ClassTree) tree;
        // TODO: 1. 클래스 이름이 xxxContext/xxxStrategy 패턴이거나 인터페이스 타입 필드를 가지는지 확인
        //       2. 심볼 테이블에서 그 인터페이스의 구현체 수를 조회해 1개뿐이면 과설계 의심으로 판정
        //          (과제 2 findStrategyImplementations()와 동일한 판단 기준)
        //       3. 위반이면 reportIssue(classTree, "Strategy 구현체가 1개뿐입니다: 인터페이스 추상화가
        //          필요한지 재검토하세요")로 이슈를 등록
    }
}