[Design Patterns] 패턴을 활용한 코드 리뷰와 설계 리뷰

 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

/**
 * 코드 리뷰 체크리스트 - 패턴 적용 검증
 * 
 * □ 패턴 적용 적절성
 *   - 문제 상황과 패턴이 매치하는가?
 *   - 패턴의 Intent와 실제 사용 목적이 일치하는가?
 *   - 더 간단한 해결책은 없는가?
 * 
 * □ 패턴 구현 완전성
 *   - 패턴의 필수 구성 요소가 모두 구현되었는가?
 *   - 패턴의 협력 관계가 올바르게 표현되었는가?
 *   - 패턴의 변형이 적절하게 적용되었는가?
 * 
 * □ 코드 품질
 *   - 네이밍이 패턴의 의도를 명확히 드러내는가?
 *   - 추상화 수준이 일관되는가?
 *   - 단일 책임 원칙이 지켜졌는가?
 */

// 리뷰 예시 1: Observer 패턴 적용 검토
public class OrderService {
    private List<OrderObserver> observers = new ArrayList<>(); // 올바른 패턴 구현
    
    public void addObserver(OrderObserver observer) {
        observers.add(observer);
    }
    
    public void removeObserver(OrderObserver observer) {
        observers.remove(observer);
    }
    
    // 리뷰 포인트: notifyObservers가 private으로 숨겨져 있어 패턴 의도 불분명
    private void notifyObservers(Order order) {
        for (OrderObserver observer : observers) {
            observer.onOrderUpdated(order);
        }
    }
    
    public void confirmOrder(Order order) {
        order.setStatus(OrderStatus.CONFIRMED);
        orderRepository.save(order);
        
        // 올바른 알림 호출
        notifyObservers(order);
    }
}

// 리뷰 개선 제안
public class ImprovedOrderService {
    private final List<OrderObserver> observers = new ArrayList<>();
    
    public void addObserver(OrderObserver observer) {
        if (observer != null && !observers.contains(observer)) { // 중복 방지
            observers.add(observer);
        }
    }
    
    public void removeObserver(OrderObserver observer) {
        observers.remove(observer);
    }
    
    // protected로 변경하여 확장 가능성 열어둠
    protected void notifyObservers(Order order) {
        // 예외 안전성 추가
        for (OrderObserver observer : new ArrayList<>(observers)) {
            try {
                observer.onOrderUpdated(order);
            } catch (Exception e) {
                log.error("Observer notification failed", e);
                // 관찰자 오류가 전체 프로세스를 중단하지 않도록
            }
        }
    }
    
    @Transactional
    public void confirmOrder(Order order) {
        Order savedOrder = orderRepository.save(order.confirm());
        notifyObservers(savedOrder); // 저장 후 알림
    }
}

 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

// 리뷰 기법 1: 패턴 인식 및 명명
public class PatternRecognitionReview {
    
    // Before: 패턴이 숨겨진 코드
    public class FileProcessor {
        public void processFile(String filePath) {
            if (filePath.endsWith(".txt")) {
                // 텍스트 파일 처리
                readTextFile(filePath);
                parseTextContent();
                generateTextReport();
            } else if (filePath.endsWith(".csv")) {
                // CSV 파일 처리
                readCsvFile(filePath);
                parseCsvContent();
                generateCsvReport();
            } else if (filePath.endsWith(".json")) {
                // JSON 파일 처리
                readJsonFile(filePath);
                parseJsonContent();
                generateJsonReport();
            }
        }
    }
    
    // 리뷰 포인트: "이 코드에서 Strategy 패턴을 발견할 수 있습니다"
    // After: 패턴을 명시적으로 적용
    public interface FileProcessingStrategy {
        boolean supports(String filePath);
        void process(String filePath);
    }
    
    public class TextFileProcessingStrategy implements FileProcessingStrategy {
        @Override
        public boolean supports(String filePath) {
            return filePath.endsWith(".txt");
        }
        
        @Override  
        public void process(String filePath) {
            readTextFile(filePath);
            parseTextContent();
            generateTextReport();
        }
    }
    
    public class FileProcessor {
        private final List<FileProcessingStrategy> strategies;
        
        public FileProcessor(List<FileProcessingStrategy> strategies) {
            this.strategies = strategies;
        }
        
        public void processFile(String filePath) {
            FileProcessingStrategy strategy = strategies.stream()
                .filter(s -> s.supports(filePath))
                .findFirst()
                .orElseThrow(() -> new UnsupportedOperationException("Unsupported file type: " + filePath));
                
            strategy.process(filePath);
        }
    }
}

 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

// 커스텀 정적 분석 규칙
public class PatternValidationRules {
    
    /**
     * 규칙 1: Singleton 패턴 검증
     * - private 생성자 확인
     * - getInstance() 메서드 존재 확인
     * - 스레드 안전성 검증
     */
    @AnalysisRule
    public class SingletonPatternRule {
        
        public List<Issue> validate(ClassInfo classInfo) {
            List<Issue> issues = new ArrayList<>();
            
            if (isSingletonPattern(classInfo)) {
                // private 생성자 확인
                if (!hasPrivateConstructor(classInfo)) {
                    issues.add(Issue.error("Singleton must have private constructor"));
                }
                
                // getInstance 메서드 확인
                if (!hasGetInstanceMethod(classInfo)) {
                    issues.add(Issue.error("Singleton must have getInstance() method"));
                }
                
                // 스레드 안전성 확인
                if (!isThreadSafe(classInfo)) {
                    issues.add(Issue.warning("Singleton should be thread-safe"));
                }
            }
            
            return issues;
        }
        
        private boolean isSingletonPattern(ClassInfo classInfo) {
            return classInfo.hasStaticField("instance") && 
                   classInfo.hasMethod("getInstance");
        }
    }
}

// 리뷰 자동화 워크플로우
@Service
public class AutomatedReviewService {
    
    public ReviewReport conductAutomatedReview(CodeBase codeBase) {
        ReviewReport report = new ReviewReport();
        
        // 1. 패턴 적용 탐지
        List<DetectedPattern> patterns = patternDetector.detectPatterns(codeBase);
        report.addSection("Detected Patterns", patterns);
        
        // 2. 패턴 구현 검증
        List<PatternValidationResult> validations = patternValidator.validatePatterns(patterns);
        report.addSection("Pattern Validations", validations);
        
        // 3. 코드 품질 메트릭
        CodeQualityMetrics metrics = metricsCalculator.calculate(codeBase);
        report.addSection("Quality Metrics", metrics);
        
        // 4. 개선 제안 생성
        List<ImprovementSuggestion> suggestions = suggestionEngine.generateSuggestions(
            patterns, validations, metrics);
        report.addSection("Improvement Suggestions", suggestions);
        
        return report;
    }
}

 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

@Component
public class ReviewQualityAnalyzer {
    
    // 리뷰 효과성 측정
    public ReviewEffectivenessReport analyzeReviewEffectiveness(
            List<CodeReview> reviews, TimeRange timeRange) {
        
        ReviewEffectivenessReport report = new ReviewEffectivenessReport();
        
        // 1. 결함 발견율
        double defectDetectionRate = calculateDefectDetectionRate(reviews, timeRange);
        report.setDefectDetectionRate(defectDetectionRate);
        
        // 2. 패턴 적용 개선율
        double patternImprovementRate = calculatePatternImprovementRate(reviews);
        report.setPatternImprovementRate(patternImprovementRate);
        
        // 3. 코드 품질 향상도
        CodeQualityTrend qualityTrend = analyzeCodeQualityTrend(timeRange);
        report.setQualityTrend(qualityTrend);
        
        // 4. 리뷰 참여도
        ReviewParticipationMetrics participation = calculateParticipationMetrics(reviews);
        report.setParticipationMetrics(participation);
        
        return report;
    }
    
    // 패턴별 리뷰 성과 분석
    public Map<PatternType, PatternReviewMetrics> analyzePatternReviewMetrics(
            List<CodeReview> reviews) {
        
        Map<PatternType, PatternReviewMetrics> metrics = new HashMap<>();
        
        for (PatternType patternType : PatternType.values()) {
            List<CodeReview> patternReviews = reviews.stream()
                .filter(review -> review.involvePattern(patternType))
                .collect(Collectors.toList());
                
            if (!patternReviews.isEmpty()) {
                PatternReviewMetrics patternMetrics = PatternReviewMetrics.builder()
                    .totalReviews(patternReviews.size())
                    .averageReviewTime(calculateAverageReviewTime(patternReviews))
                    .defectsFound(countDefectsFound(patternReviews))
                    .improvementsSuggested(countImprovementsSuggested(patternReviews))
                    .implementationQualityScore(calculateImplementationQuality(patternReviews))
                    .build();
                    
                metrics.put(patternType, patternMetrics);
            }
        }
        
        return metrics;
    }
}

 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

// 엔터프라이즈 리뷰 프레임워크
@Configuration
public class EnterpriseReviewFramework {
    
    // 팀별 리뷰 정책 설정
    @Bean
    public ReviewPolicyManager reviewPolicyManager() {
        ReviewPolicyManager manager = new ReviewPolicyManager();
        
        // 백엔드 팀 정책
        ReviewPolicy backendPolicy = ReviewPolicy.builder()
            .teamName("Backend")
            .requiredReviewers(2)
            .mandatoryPatternCheck(true)
            .patternComplexityThreshold(PatternComplexity.MEDIUM)
            .codeQualityGate(CodeQualityGate.STRICT)
            .build();
            
        // 프론트엔드 팀 정책  
        ReviewPolicy frontendPolicy = ReviewPolicy.builder()
            .teamName("Frontend")
            .requiredReviewers(1)
            .mandatoryPatternCheck(false)
            .patternComplexityThreshold(PatternComplexity.LOW)
            .codeQualityGate(CodeQualityGate.STANDARD)
            .build();
            
        manager.addPolicy("backend", backendPolicy);
        manager.addPolicy("frontend", frontendPolicy);
        
        return manager;
    }
    
    // 자동화된 리뷰 워크플로우
    @Bean
    public ReviewWorkflowEngine reviewWorkflowEngine() {
        return ReviewWorkflowEngine.builder()
            .addStage(new AutomatedPatternAnalysisStage())
            .addStage(new CodeQualityCheckStage())
            .addStage(new SecurityScanStage())
            .addStage(new HumanReviewStage())
            .addStage(new ApprovalStage())
            .build();
    }
}