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
// SRP 위반: 이 클래스를 변경해야 하는 이유가 세 가지다
public class UserService {
    private final JdbcTemplate jdbcTemplate;

    public UserService(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    // 책임 1: 사용자 비즈니스 로직 (액터: 기획팀)
    public void registerUser(User user) {
        validateUser(user);
        saveUser(user);
        sendWelcomeEmail(user);
    }

    // 책임 2: 데이터베이스 접근 (액터: DBA / 인프라팀)
    private void saveUser(User user) {
        jdbcTemplate.update(
            "INSERT INTO users (name, email) VALUES (?, ?)",
            user.getName(), user.getEmail()
        );
    }

    // 책임 3: 이메일 발송 (액터: 마케팅팀 / 운영팀)
    private void sendWelcomeEmail(User user) {
        String subject = "환영합니다!";
        String body = user.getName() + "님, 가입을 축하합니다.";
        // SMTP 연결, 이메일 전송 로직...
    }

    private void validateUser(User user) {
        if (user.getEmail() == null || !user.getEmail().contains("@")) {
            throw new IllegalArgumentException("유효하지 않은 이메일입니다.");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 급여 계산 클래스 — SRP 위반
public class Employee {
    private String name;
    private BigDecimal baseSalary;
    private int overtimeHours;

    // 액터 1: CFO (재무팀) — 급여 계산 규칙을 결정한다
    public BigDecimal calculatePay() {
        return baseSalary.add(calculateOvertimePay());
    }

    // 액터 2: COO (운영팀) — 근무 시간 보고 규칙을 결정한다
    public int reportHours() {
        return 8 + overtimeHours;
    }

    // 두 메서드가 공유하는 내부 로직
    private BigDecimal calculateOvertimePay() {
        // 초과근무 급여 = 기본급의 1.5배 × 초과근무 시간
        return baseSalary.divide(BigDecimal.valueOf(160), RoundingMode.HALF_UP)
            .multiply(BigDecimal.valueOf(1.5))
            .multiply(BigDecimal.valueOf(overtimeHours));
    }
}

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
// 책임 1: 사용자 비즈니스 로직만 담당
@Service
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;
    private final UserValidator userValidator;

    public UserService(UserRepository userRepository,
                       EmailService emailService,
                       UserValidator userValidator) {
        this.userRepository = userRepository;
        this.emailService = emailService;
        this.userValidator = userValidator;
    }

    public void registerUser(User user) {
        userValidator.validate(user);
        userRepository.save(user);
        emailService.sendWelcomeEmail(user);
    }
}

// 책임 2: 데이터 접근만 담당
@Repository
public class UserRepository {
    private final JdbcTemplate jdbcTemplate;

    public UserRepository(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public void save(User user) {
        jdbcTemplate.update(
            "INSERT INTO users (name, email) VALUES (?, ?)",
            user.getName(), user.getEmail()
        );
    }

    public Optional<User> findByEmail(String email) {
        return jdbcTemplate.query(
            "SELECT * FROM users WHERE email = ?",
            new UserRowMapper(), email
        ).stream().findFirst();
    }
}

// 책임 3: 이메일 발송만 담당
@Service
public class EmailService {
    private final JavaMailSender mailSender;

    public EmailService(JavaMailSender mailSender) {
        this.mailSender = mailSender;
    }

    public void sendWelcomeEmail(User user) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(user.getEmail());
        message.setSubject("환영합니다!");
        message.setText(user.getName() + "님, 가입을 축하합니다.");
        mailSender.send(message);
    }
}

// 책임 4: 검증 로직만 담당
@Component
public class UserValidator {
    public void validate(User user) {
        if (user.getEmail() == null || !user.getEmail().contains("@")) {
            throw new IllegalArgumentException("유효하지 않은 이메일입니다.");
        }
        if (user.getName() == null || user.getName().isBlank()) {
            throw new IllegalArgumentException("이름은 필수입니다.");
        }
    }
}

1
2
3
4
5
6
7
8
// 높은 응집도: 모든 메서드가 balance를 중심으로 동작한다
public class BankAccount {
    private BigDecimal balance;

    public void deposit(BigDecimal amount) { balance = balance.add(amount); }
    public void withdraw(BigDecimal amount) { balance = balance.subtract(amount); }
    public BigDecimal getBalance() { return balance; }
}

1
2
3
4
5
6
7
// 낮은 응집도: 메서드들이 서로 관련 없는 데이터를 다룬다
public class Utils {
    public static String formatDate(LocalDate date) { ... }
    public static BigDecimal calculateTax(BigDecimal income) { ... }
    public static void sendEmail(String to, String body) { ... }
    public static byte[] compressData(byte[] data) { ... }
}

1
2
3
4
5
6
7
8
9
10
// Meyer의 OCP — 상속으로 확장
public class Shape {
    public double area() { return 0; }
}

public class Circle extends Shape {
    private double radius;
    @Override
    public double area() { return Math.PI * radius * radius; }
}

1
2
3
4
5
6
7
8
9
10
// Martin의 OCP — 추상화로 확장
public interface Shape {
    double area();
}

public class Circle implements Shape {
    private double radius;
    @Override
    public double area() { return Math.PI * radius * radius; }
}

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
// OCP 위반: 새로운 할인 정책을 추가할 때마다 이 클래스를 수정해야 한다
public class DiscountCalculator {

    public BigDecimal calculateDiscount(Order order, String discountType) {
        if ("PERCENTAGE".equals(discountType)) {
            return order.getTotalAmount()
                .multiply(BigDecimal.valueOf(0.1));
        } else if ("FIXED".equals(discountType)) {
            return BigDecimal.valueOf(5000);
        } else if ("FIRST_ORDER".equals(discountType)) {
            if (order.isFirstOrder()) {
                return order.getTotalAmount()
                    .multiply(BigDecimal.valueOf(0.2));
            }
            return BigDecimal.ZERO;
        } else if ("VIP".equals(discountType)) {
            if (order.getUser().isVip()) {
                return order.getTotalAmount()
                    .multiply(BigDecimal.valueOf(0.15));
            }
            return BigDecimal.ZERO;
        }
        // 시즌 할인 추가? → else if 추가
        // 쿠폰 할인 추가? → else if 추가
        return BigDecimal.ZERO;
    }
}

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
// 할인 정책 인터페이스 — 확장 지점
public interface DiscountPolicy {
    BigDecimal calculateDiscount(Order order);
    boolean supports(String discountType);
}

// 각 할인 정책은 독립적인 구현체
@Component
public class PercentageDiscount implements DiscountPolicy {
    @Override
    public BigDecimal calculateDiscount(Order order) {
        return order.getTotalAmount().multiply(BigDecimal.valueOf(0.1));
    }

    @Override
    public boolean supports(String discountType) {
        return "PERCENTAGE".equals(discountType);
    }
}

@Component
public class FirstOrderDiscount implements DiscountPolicy {
    @Override
    public BigDecimal calculateDiscount(Order order) {
        if (!order.isFirstOrder()) return BigDecimal.ZERO;
        return order.getTotalAmount().multiply(BigDecimal.valueOf(0.2));
    }

    @Override
    public boolean supports(String discountType) {
        return "FIRST_ORDER".equals(discountType);
    }
}

@Component
public class VipDiscount implements DiscountPolicy {
    @Override
    public BigDecimal calculateDiscount(Order order) {
        if (!order.getUser().isVip()) return BigDecimal.ZERO;
        return order.getTotalAmount().multiply(BigDecimal.valueOf(0.15));
    }

    @Override
    public boolean supports(String discountType) {
        return "VIP".equals(discountType);
    }
}

// DiscountCalculator는 수정 없이 새로운 할인 정책을 지원한다
@Service
public class DiscountCalculator {
    private final List<DiscountPolicy> policies;

    public DiscountCalculator(List<DiscountPolicy> policies) {
        this.policies = policies;
    }

    public BigDecimal calculateDiscount(Order order, String discountType) {
        return policies.stream()
            .filter(policy -> policy.supports(discountType))
            .findFirst()
            .map(policy -> policy.calculateDiscount(order))
            .orElse(BigDecimal.ZERO);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 새로운 할인 정책 추가 — 기존 코드 수정 없음
@Component
public class SeasonDiscount implements DiscountPolicy {
    @Override
    public BigDecimal calculateDiscount(Order order) {
        if (isHolidaySeason()) {
            return order.getTotalAmount().multiply(BigDecimal.valueOf(0.3));
        }
        return BigDecimal.ZERO;
    }

    @Override
    public boolean supports(String discountType) {
        return "SEASON".equals(discountType);
    }

    private boolean isHolidaySeason() {
        int month = LocalDate.now().getMonthValue();
        return month == 12 || month == 1;
    }
}

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
// Template Method — 골격은 닫혀 있고(final), 특정 단계만 열려 있다(abstract)
public abstract class DataExportTemplate {

    // 템플릿 메서드 — 수정에 닫혀 있다
    public final void export(String query) {
        List<Map<String, Object>> data = fetchData(query);
        List<Map<String, Object>> processed = processData(data);
        String formatted = formatData(processed);
        writeOutput(formatted);
        logCompletion(processed.size());
    }

    // 공통 단계 — 모든 내보내기에서 동일
    protected List<Map<String, Object>> fetchData(String query) {
        // DB 조회
        return List.of();
    }

    // 훅 메서드 — 선택적 확장 지점
    protected List<Map<String, Object>> processData(
            List<Map<String, Object>> data) {
        return data;
    }

    private void logCompletion(int count) {
        System.out.println("내보내기 완료: " + count + "건");
    }

    // 확장에 열려 있는 단계
    protected abstract String formatData(List<Map<String, Object>> data);
    protected abstract void writeOutput(String formattedData);
}

// CSV 내보내기 — 확장
public class CsvExporter extends DataExportTemplate {
    @Override
    protected String formatData(List<Map<String, Object>> data) {
        // CSV 형식으로 변환
        return data.stream()
            .map(row -> row.values().stream()
                .map(Object::toString)
                .collect(Collectors.joining(",")))
            .collect(Collectors.joining("\n"));
    }

    @Override
    protected void writeOutput(String formattedData) {
        // 파일로 저장
    }
}

// JSON 내보내기 — 확장
public class JsonExporter extends DataExportTemplate {
    @Override
    protected String formatData(List<Map<String, Object>> data) {
        // JSON 형식으로 변환
        return new ObjectMapper().writeValueAsString(data);
    }

    @Override
    protected void writeOutput(String formattedData) {
        // API로 전송
    }
}

1
2
3
4
5
6
7
8
9
10
11
// java.sql.Driver — 인터페이스만 정의 (닫혀 있다)
public interface Driver {
    Connection connect(String url, Properties info) throws SQLException;
    boolean acceptsURL(String url) throws SQLException;
}

// MySQL 드라이버 — 구현체를 추가 (열려 있다)
public class com.mysql.cj.jdbc.Driver implements java.sql.Driver { ... }

// PostgreSQL 드라이버 — 구현체를 추가 (열려 있다)
public class org.postgresql.Driver implements java.sql.Driver { ... }

1
2
3
4
5
6
7
8
9
10
11
12
13
// Spring 컨테이너는 수정 없이, BeanPostProcessor를 통해 확장된다
@Component
public class LoggingBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean.getClass().isAnnotationPresent(Loggable.class)) {
            // 프록시를 생성하여 로깅 기능을 동적으로 추가
            return createLoggingProxy(bean);
        }
        return bean;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 직사각형
public class Rectangle {
    protected int width;
    protected int height;

    public void setWidth(int width) { this.width = width; }
    public void setHeight(int height) { this.height = height; }
    public int getArea() { return width * height; }
}

// LSP 위반: 정사각형이 직사각형을 상속
public class Square extends Rectangle {
    @Override
    public void setWidth(int width) {
        this.width = width;
        this.height = width;  // 정사각형이므로 높이도 변경
    }

    @Override
    public void setHeight(int height) {
        this.width = height;  // 정사각형이므로 너비도 변경
        this.height = height;
    }
}

1
2
3
4
5
6
public void resize(Rectangle rectangle) {
    rectangle.setWidth(10);
    rectangle.setHeight(5);
    // 직사각형이라면 넓이가 50이어야 한다
    assert rectangle.getArea() == 50;  // Square가 들어오면 실패! (25)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// LSP를 지키는 설계: 불변 객체
public class Rectangle {
    private final int width;
    private final int height;

    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public int getArea() { return width * height; }
    public int getWidth() { return width; }
    public int getHeight() { return height; }
}

public class Square extends Rectangle {
    public Square(int side) {
        super(side, side);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 상위 타입: 양수만 받는다
public class Calculator {
    public double sqrt(double value) {
        if (value < 0) throw new IllegalArgumentException("음수 불가");
        return Math.sqrt(value);
    }
}

// LSP 위반: 사전 조건을 강화했다 (0도 거부)
public class StrictCalculator extends Calculator {
    @Override
    public double sqrt(double value) {
        if (value <= 0) throw new IllegalArgumentException("0 이하 불가");
        return Math.sqrt(value);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 상위 타입: 정렬된 리스트를 반환한다
public class DataProvider {
    public List<Integer> getSortedData() {
        List<Integer> data = fetchData();
        Collections.sort(data);
        return data;  // 사후 조건: 정렬된 상태
    }
}

// LSP 위반: 사후 조건을 약화했다 (정렬을 보장하지 않음)
public class FastDataProvider extends DataProvider {
    @Override
    public List<Integer> getSortedData() {
        return fetchData();  // 성능을 위해 정렬을 생략 — 계약 위반
    }
}

1
2
3
4
5
6
List<String> original = new ArrayList<>(List.of("A", "B", "C"));
List<String> unmodifiable = Collections.unmodifiableList(original);

// List 인터페이스는 add()가 가능하다고 선언한다
// 그러나 unmodifiableList는 UnsupportedOperationException을 던진다
unmodifiable.add("D");  // UnsupportedOperationException!

1
2
3
4
5
6
7
8
9
10
11
12
13
// LSP 위반 패턴 1: 지원하지 않는 연산에서 예외
public interface Bird {
    void fly();
    void eat();
}

public class Penguin implements Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("펭귄은 날 수 없습니다!");
    }
    // ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 해결: 인터페이스 분리 (ISP와의 협력)
public interface Bird {
    void eat();
}

public interface FlyingBird extends Bird {
    void fly();
}

public class Sparrow implements FlyingBird {
    @Override
    public void fly() { System.out.println("참새가 날아갑니다."); }
    @Override
    public void eat() { System.out.println("참새가 먹이를 먹습니다."); }
}

public class Penguin implements Bird {
    @Override
    public void eat() { System.out.println("펭귄이 물고기를 먹습니다."); }
}

1
2
3
4
5
6
7
8
9
// LSP 위반 패턴 2: instanceof 검사 — 다형성을 포기한 코드
public BigDecimal calculateShippingCost(Order order) {
    if (order instanceof DomesticOrder) {
        return calculateDomesticShipping((DomesticOrder) order);
    } else if (order instanceof InternationalOrder) {
        return calculateInternationalShipping((InternationalOrder) order);
    }
    throw new IllegalArgumentException("알 수 없는 주문 타입");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 해결: 다형성으로 행위를 각 타입에 위임
public abstract class Order {
    public abstract BigDecimal calculateShippingCost();
}

public class DomesticOrder extends Order {
    @Override
    public BigDecimal calculateShippingCost() {
        return BigDecimal.valueOf(3000);
    }
}

public class InternationalOrder extends Order {
    @Override
    public BigDecimal calculateShippingCost() {
        return BigDecimal.valueOf(15000);
    }
}

// 호출부: instanceof 없이 동작
public BigDecimal calculateShippingCost(Order order) {
    return order.calculateShippingCost();
}

1
2
3
4
5
6
7
8
9
10
11
12
public class Animal {
    public Animal reproduce() {
        return new Animal();
    }
}

public class Dog extends Animal {
    @Override
    public Dog reproduce() {  // 반환 타입이 Animal이 아닌 Dog — 공변 반환
        return new Dog();
    }
}

1
2
3
4
5
6
7
8
// ISP 위반: 모든 기기가 이 인터페이스를 구현해야 한다
public interface MultiFunctionDevice {
    void print(Document document);
    void scan(Document document);
    void fax(Document document);
    void copy(Document document);
    void staple(Document document);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class SimplePrinter implements MultiFunctionDevice {
    @Override
    public void print(Document document) { /* 실제 구현 */ }

    @Override
    public void scan(Document document) {
        throw new UnsupportedOperationException("스캔 기능 없음");
    }

    @Override
    public void fax(Document document) {
        throw new UnsupportedOperationException("팩스 기능 없음");
    }

    @Override
    public void copy(Document document) {
        throw new UnsupportedOperationException("복사 기능 없음");
    }

    @Override
    public void staple(Document document) {
        throw new UnsupportedOperationException("제본 기능 없음");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public class PrintService {
    private final MultiFunctionDevice device;

    public PrintService(MultiFunctionDevice device) {
        this.device = device;
    }

    public void printDocument(Document doc) {
        device.print(doc);
        // device.fax(), device.scan(), device.staple() 등
        // 사용하지 않는 메서드가 IDE의 자동완성에 모두 노출된다
    }
}

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
public interface Printer {
    void print(Document document);
}

public interface Scanner {
    void scan(Document document);
}

public interface Fax {
    void fax(Document document);
}

// 복합기: 필요한 인터페이스를 모두 구현
public class AllInOnePrinter implements Printer, Scanner, Fax {
    @Override
    public void print(Document document) { /* 구현 */ }
    @Override
    public void scan(Document document) { /* 구현 */ }
    @Override
    public void fax(Document document) { /* 구현 */ }
}

// 단순 프린터: Printer만 구현
public class SimplePrinter implements Printer {
    @Override
    public void print(Document document) { /* 구현 */ }
}

// 클라이언트는 필요한 인터페이스에만 의존한다
public class PrintService {
    private final Printer printer;

    public PrintService(Printer printer) {
        this.printer = printer;  // SimplePrinter든 AllInOnePrinter든 상관없다
    }

    public void printDocument(Document document) {
        printer.print(document);
        // print()만 보인다. 깔끔하다.
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Java 8 이전: ISP를 따르기 위해 인터페이스를 분리하면
// 구현체마다 여러 인터페이스를 구현해야 했다

// Java 8: default 메서드로 선택적 기능을 표현할 수 있다
public interface EventListener {
    void onEvent(Event event);

    // default 메서드: 구현이 선택적이다
    default void onError(Event event, Throwable error) {
        // 기본 동작: 무시
    }

    default void onComplete() {
        // 기본 동작: 아무것도 하지 않음
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

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
// 마커 인터페이스 — 메서드 없음
public interface Repository<T, ID> { }

// CRUD만 필요하면 이 인터페이스만 사용
public interface CrudRepository<T, ID> extends Repository<T, ID> {
    <S extends T> S save(S entity);
    Optional<T> findById(ID id);
    Iterable<T> findAll();
    void deleteById(ID id);
    long count();
    boolean existsById(ID id);
}

// 페이징이 필요하면 이 인터페이스 사용
public interface PagingAndSortingRepository<T, ID>
        extends CrudRepository<T, ID> {
    Iterable<T> findAll(Sort sort);
    Page<T> findAll(Pageable pageable);
}

// JPA 전용 기능이 필요하면 이 인터페이스 사용
public interface JpaRepository<T, ID>
        extends PagingAndSortingRepository<T, ID> {
    void flush();
    <S extends T> S saveAndFlush(S entity);
    void deleteAllInBatch();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// DIP 위반: 고수준 모듈이 저수준 모듈의 구체 클래스에 직접 의존
public class OrderService {
    private final MySQLOrderRepository repository;
    private final SmtpEmailSender emailSender;
    private final StripePaymentGateway paymentGateway;

    public OrderService() {
        this.repository = new MySQLOrderRepository();
        this.emailSender = new SmtpEmailSender();
        this.paymentGateway = new StripePaymentGateway();
    }

    public void placeOrder(Order order) {
        paymentGateway.charge(order.getTotalAmount(), order.getPaymentInfo());
        repository.save(order);
        emailSender.send(
            order.getUserEmail(), "주문 확인", "주문이 완료되었습니다."
        );
    }
}

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
// 추상화 — 고수준 모듈이 필요로 하는 계약을 정의한다
public interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(String orderId);
    List<Order> findByUserId(String userId);
}

public interface NotificationSender {
    void send(String to, String subject, String body);
}

public interface PaymentGateway {
    PaymentResult charge(BigDecimal amount, PaymentInfo paymentInfo);
    PaymentResult refund(String transactionId, BigDecimal amount);
}

// 고수준 모듈: 추상화에만 의존한다
@Service
public class OrderService {
    private final OrderRepository repository;
    private final NotificationSender notificationSender;
    private final PaymentGateway paymentGateway;

    public OrderService(OrderRepository repository,
                         NotificationSender notificationSender,
                         PaymentGateway paymentGateway) {
        this.repository = repository;
        this.notificationSender = notificationSender;
        this.paymentGateway = paymentGateway;
    }

    public void placeOrder(Order order) {
        PaymentResult result = paymentGateway.charge(
            order.getTotalAmount(), order.getPaymentInfo());

        if (!result.isSuccess()) {
            throw new PaymentFailedException(result.getErrorMessage());
        }

        order.markAsPaid(result.getTransactionId());
        repository.save(order);

        notificationSender.send(
            order.getUserEmail(), "주문 확인", "주문이 완료되었습니다."
        );
    }
}

// 저수준 모듈: 추상화를 구현한다
@Repository
public class JpaOrderRepository implements OrderRepository {
    private final JpaOrderEntityRepository jpaRepository;

    @Override
    public void save(Order order) {
        jpaRepository.save(OrderEntity.from(order));
    }

    @Override
    public Optional<Order> findById(String orderId) {
        return jpaRepository.findById(orderId).map(OrderEntity::toDomain);
    }

    @Override
    public List<Order> findByUserId(String userId) {
        return jpaRepository.findByUserId(userId).stream()
            .map(OrderEntity::toDomain)
            .toList();
    }
}

@Component
public class SendGridNotificationSender implements NotificationSender {
    @Override
    public void send(String to, String subject, String body) {
        // SendGrid API 호출
    }
}

@Component
public class TossPaymentGateway implements PaymentGateway {
    @Override
    public PaymentResult charge(BigDecimal amount, PaymentInfo info) {
        // 토스페이먼츠 API 호출
    }

    @Override
    public PaymentResult refund(String transactionId, BigDecimal amount) {
        // 토스페이먼츠 환불 API 호출
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// DIP: "추상화에 의존하라" — 이것은 설계 결정이다
public class OrderService {
    private final OrderRepository repository;  // 구체 클래스가 아닌 인터페이스

    // DI: "외부에서 주입하라" — 이것은 의존성 제공 방식이다
    public OrderService(OrderRepository repository) {
        this.repository = repository;
    }
}

// IoC: "컨테이너가 제어한다" — 이것은 프레임워크의 역할이다
@Configuration
public class AppConfig {
    @Bean
    public OrderRepository orderRepository(DataSource dataSource) {
        return new JpaOrderRepository(dataSource);
    }

    @Bean
    public OrderService orderService(OrderRepository repository) {
        return new OrderService(repository);  // 컨테이너가 조립한다
    }
}

1
2
3
4
5
6
7
8
9
// 좋은 예: 인터페이스 타입으로 참조
Set<String> names = new LinkedHashSet<>();
Map<String, Order> orders = new HashMap<>();
List<User> users = new ArrayList<>();

// 나쁜 예: 구체 클래스 타입으로 참조
LinkedHashSet<String> names = new LinkedHashSet<>();
HashMap<String, Order> orders = new HashMap<>();
ArrayList<User> users = new ArrayList<>();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class NotificationService {
    public void sendNotification(String channel, String userId, String message) {
        User user = new UserDao().findById(userId);  // DIP 위반: 구체 클래스

        if ("EMAIL".equals(channel)) {
            // SRP 위반: 이메일 발송 로직이 여기에
            SmtpClient smtp = new SmtpClient("smtp.example.com");
            smtp.send(user.getEmail(), "알림", message);

        } else if ("SMS".equals(channel)) {
            // OCP 위반: 새 채널 추가 시 수정 필요
            SmsApi smsApi = new SmsApi("api-key-123");
            smsApi.send(user.getPhone(), message);

        } else if ("PUSH".equals(channel)) {
            FcmClient fcm = new FcmClient();
            fcm.send(user.getDeviceToken(), message);
        }
        // Slack 추가? → else if 추가
    }
}

1
2
3
4
5
// ISP: 채널별 인터페이스 정의
public interface MessageChannel {
    void send(User user, String message);
    boolean supports(String channel);
}

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
@Component
public class EmailChannel implements MessageChannel {
    private final SmtpClient smtpClient;

    public EmailChannel(SmtpClient smtpClient) {
        this.smtpClient = smtpClient;
    }

    @Override
    public void send(User user, String message) {
        smtpClient.send(user.getEmail(), "알림", message);
    }

    @Override
    public boolean supports(String channel) {
        return "EMAIL".equals(channel);
    }
}

@Component
public class SmsChannel implements MessageChannel {
    private final SmsApi smsApi;

    public SmsChannel(SmsApi smsApi) {
        this.smsApi = smsApi;
    }

    @Override
    public void send(User user, String message) {
        smsApi.send(user.getPhone(), message);
    }

    @Override
    public boolean supports(String channel) {
        return "SMS".equals(channel);
    }
}

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
@Service
public class NotificationService {
    private final UserRepository userRepository;  // DIP: 인터페이스에 의존
    private final List<MessageChannel> channels;  // DIP: 인터페이스 목록에 의존

    public NotificationService(UserRepository userRepository,
                                List<MessageChannel> channels) {
        this.userRepository = userRepository;
        this.channels = channels;
    }

    public void sendNotification(String channel, String userId, String message) {
        User user = userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException(userId));

        channels.stream()
            .filter(ch -> ch.supports(channel))
            .findFirst()
            .orElseThrow(() -> new UnsupportedChannelException(channel))
            .send(user, message);
    }

    // 모든 채널로 동시 발송
    public void broadcast(String userId, String message) {
        User user = userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException(userId));
        channels.forEach(ch -> ch.send(user, message));
    }
}