파이썬으로 살펴보는 아키텍처 패턴

Table of contents

1. 지은이·옮긴이 소개
2. 옮긴이의 말
3. 이 책에 대하여 (1/4)
4. 이 책에 대하여 (2/4)
5. 이 책에 대하여 (3/4)
6. 이 책에 대하여 (4/4)
7. 도입
   1. 0.1 설계가 왜 잘못되는가?
   2. 0.2 캡슐화와 추상화
   3. 0.3 계층화
   4. 0.4 의존성 역전 원칙
   5. 0.5 모든 비즈니스 로직을 위한 장소: 도메인 모델
8. 도메인 모델링을 지원하는 아키텍처 구축
9. 도메인 모델링
   1. 1.1 도메인 모델이란?
   2. 1.2 도메인 언어 탐구
   3. 1.3 도메인 모델 단위 테스트 (1/2)
   4. 1.3 도메인 모델 단위 테스트 (2/2)
      1. 1.3.1 값 객체로 사용하기 적합한 데이터 클래스
      2. 1.3.2 값 객체와 엔티티
   5. 1.4 모든 것을 객체로 만들 필요는 없다: 도메인 서비스 함수
      1. 1.4.1 파이썬 마법 메서드 사용 시 모델과 파이썬 숙어 함께 사용 가능
      2. 1.4.2 예외를 사용해 도메인 개념 표현 가능
10. 저장소 패턴
    1. 2.1 도메인 모델 영속화
    2. 2.2 의사코드: 무엇이 필요할까?
    3. 2.3 데이터 접근에 DIP 적용하기
    4. 2.4 기억 되살리기: 우리가 사용하는 모델
       1. 2.4.1 ‘일반적인’ ORM 방식: ORM에 의존하는 모델
       2. 2.4.2 의존성 역전: 모델에 의존하는 ORM
    5. 2.5 저장소 패턴 소개
       1. 2.5.1 추상화한 저장소
       2. 2.5.2 트레이드오프란 무엇인가?
    6. 2.6 테스트에 사용하는 가짜 저장소를 쉽게 만드는 방법
    7. 2.7 파이썬에서 포트는 무엇이고, 어댑터란 무엇인가
    8. 2.8 마치며
11. 막간: 결합과 추상화
    1. 3.1 추상적인 상태는 테스트를 더 쉽게 해준다
    2. 3.2 올바른 추상화 선택
    3. 3.3 선택한 추상화 구현
       1. 3.3.1 의존성 주입과 가짜를 사용해 에지투에지 테스트
       2. 3.3.2 패치를 사용하지 않는 이유
    4. 3.4 마치며
12. 첫 번째 유스케이스: 플라스크 API와 서비스 계층
    1. 4.1 애플리케이션을 실세계와 연결하기
    2. 4.2 첫 번째 엔드투엔드 테스트
    3. 4.3 직접 구현하기
    4. 4.4 데이터베이스 검사가 필요한 오류 조건
    5. 4.5 서비스 계층 소개와 서비스 계층 테스트용 FakeRepository 사용
       1. 4.5.1 전형적인 서비스 함수
    6. 4.6 모든 것을 왜 서비스라고 부르는가?
    7. 4.7 모든 요소를 폴더에 넣고 각 부분이 어떤 위치에 있는지 살펴보기
    8. 4.8 마치며
       1. 4.8.1 실제로 작동하는 DIP
13. 높은 기어비와 낮은 기어비의 TDD
    1. 5.1 테스트 피라미드는 어떻게 생겼는가?
    2. 5.2 도메인 계층 테스트를 서비스 계층으로 옮겨야 하는가?
    3. 5.3 어떤 종류의 테스트를 작성할지 결정하는 방법
    4. 5.4 높은 기어비와 낮은 기어비
    5. 5.5 서비스 계층 테스트를 도메인으로부터 완전히 분리하기
       1. 5.5.1 마이그레이션: 모든 도메인 의존성을 픽스처 함수에 넣기
       2. 5.5.2 누락된 서비스 추가
    6. 5.6 E2E 테스트에 도달할 때까지 계속 개선하기
    7. 5.7 마치며
14. 작업 단위 패턴
    1. 6.1 작업 단위는 저장소와 협력
    2. 6.2 테스트-통합 테스트로 UoW 조정하기
    3. 6.3 작업 단위와 작업 단위의 콘텍스트 관리자
       1. 6.3.1 SQLAlchemy 세션을 사용하는 실제 작업 단위
       2. 6.3.2 테스트를 위한 가짜 작업 단위
    4. 6.4 UoW를 서비스 계층에 사용하기
    5. 6.5 커밋/롤백 동작에 대한 명시적인 테스트
    6. 6.6 명시적 커밋과 암시적 커밋
    7. 6.7 예제: UoW를 사용해 여러 연산을 원자적 단위로 묶기
       1. 6.7.1 예제1: 재할당
       2. 6.7.2 예제2: 배치 수량 변경
    8. 6.8 통합 테스트 깔끔하게 정리하기
    9. 6.9 마치며
15. 애그리게이트와 일관성 경계
    1. 7.1 모든 것을 스프레드시트에서 처리하지 않는 이유
    2. 7.2 불변조건, 제약, 일관성
       1. 7.2.1 불변조건, 동시성, 락
    3. 7.3 애그리게이트란?
    4. 7.4 애그리게이트 선택
    5. 7.5 한 애그리게이트 = 한 저장소
    6. 7.6 성능은 어떨까?
    7. 7.7 버전 번호와 낙관적 동시성
       1. 7.7.1 버전 번호를 구현하는 다양한 방법
    8. 7.8 데이터 무결성 규칙 테스트
       1. 7.8.1 데이터베이스 트랜잭션 격리 수준을 사용해 동시성 규칙을 지키도록 강제
       2. 7.8.2 비관적 동시성 제어 예제: SELECT FOR UPDATE
    9. 7.9 마치며
    10. 7.10 1부 돌아보기
16. 이벤트 기반 아키텍처
17. 이벤트와 메시지 버스
    1. 8.1 지저분해지지 않게 막기
       1. 8.1.1 가장 먼저 웹 컨트롤러가 지저분해지는 일을 막자
       2. 8.1.2 그다음 모델이 지저분해지는 일을 막자
       3. 8.1.3 또는 서비스 계층이 지저분해지는 일을 막자
    2. 8.2 단일 책임 원칙
    3. 8.3 메시지 버스에 전부 다 싣자
       1. 8.3.1 이벤트를 기록하는 모델
       2. 8.3.2 이벤트는 간단한 데이터 클래스다
       3. 8.3.3 모델은 이벤트를 발생한다
       4. 8.3.4 메시지 버스는 이벤트를 핸들러에 매핑한다
    4. 8.4 ‌첫 번째 선택지: 서비스 계층이 모델에서 이벤트를 가져와 메시지 버스에 싣는다
    5. 8.5 두 번째 선택지: 서비스 계층은 자신만의 이벤트를 발생한다
    6. 8.6 세 번째 선택지: UoW가 메시지 버스에 이벤트를 발행한다
    7. 8.7 마치며
18. 메시지 버스를 타고 시내로 나가기
    1. 9.1 새로운 아키텍처가 필요한 새로운 요구 사항
       1. 9.1.1 구조 변경 상상해보기: 모든 것이 이벤트 핸들러다
    2. 9.2 서비스 함수를 메시지 핸들러로 리팩터링하기
       1. 9.2.1 메시지 버스는 이제 이벤트를 UoW로부터 수집한다
       2. 9.2.2 모든 테스트는 이벤트 바탕으로 다시 쓸 수 있다
       3. 9.2.3 보기 싫은 임시 땜빵: 결과를 반환해야 하는 메시지 버스
       4. 9.2.4 이벤트로 작동하도록 API 변경
    3. 9.3 새로운 요구 사항 구현하기
       1. 9.3.1 새로운 이벤트
    4. 9.4 새 핸들러 시범운영하기
       1. 9.4.1 구현
       2. 9.4.2 도메인 모델의 새 메서드
    5. 9.5 선택: 가짜 메시지 버스와 독립적으로 이벤트 핸들러 단위 테스트하기
    6. 9.6 마치며
       1. 9.6.1 시스템을 어떻게 변경했는가?
       2. 9.6.2 왜 이렇게 시스템을 변경했는가?
19. 커맨드와 커맨드 핸들러
    1. 10.1 커맨드와 이벤트
    2. 10.2 예외 처리 방식의 차이점
    3. 10.3 논의: 이벤트, 커맨드, 오류 처리
    4. 10.4 동기적으로 오류 복구하기
    5. 10.5 마치며
20. 이벤트 기반 아키텍처: 이벤트를 사용한 마이크로서비스 통합
    1. 11.1 분산된 진흙 공, 명사로 생각하기
    2. 11.2 분산 시스템에서 오류 처리하기
    3. 11.3 대안: 비동기 메시징을 사용한 시간적 결합
    4. 11.4 레디스 발행/구독 채널을 통합에 사용하기
    5. 11.5 엔드투엔드 테스트를 사용해 모든 기능 시범운영하기
       1. 11.5.1 레디스는 메시지 버스를 감싸는 다른 얇은 어댑터
       2. 11.5.2 외부로 나가는 새 이벤트
    6. 11.6 내부 이벤트와 외부 이벤트 비교
    7. 11.7 마치며
21. 명령-질의 책임 분리(CQRS)
    1. 12.1 쓰기 위해 존재하는 도메인 모델
    2. 12.2 가구를 구매하지 않는 사용자
    3. 12.3 Post/리디렉션/Get과 CQS
    4. 12.4 점심을 잠깐 미뤄라
    5. 12.5 CQRS 뷰 테스트하기
    6. 12.6 ‘명확한’ 대안 1: 기존 저장소 사용하기
    7. 12.7 읽기 연산에 최적화되지 않은 도메인 모델
    8. 12.8 ‘명확한’ 대안 2: ORM 사용하기
    9. 12.9 SELECT N+1과 다른 고려 사항
    10. 12.10 이제는 상어를 완전히 뛰어 넘을 때이다
        1. 12.10.1 이벤트 핸들러를 사용해 읽기 모델 테이블 업데이트하기
    11. 12.11 읽기 모델 구현을 변경하기 쉽다
    12. 12.12 마치며
22. 의존성 주입(그리고 부트스트래핑)
    1. 13.1 암시적 의존성과 명시적 의존성
    2. 13.2 명시적 의존성은 완전히 이상하고 자바스러운가?
    3. 13.3 핸들러 준비: 클로저와 부분함수를 사용한 수동 DI
    4. 13.4 클래스를 사용한 대안
    5. 13.5 부트스트랩 스크립트
    6. 13.6 실행 도중 핸들러가 제공된 메시지 버스
    7. 13.7 진입점에서 부트스트랩 사용하기
    8. 13.8 테스트에서 DI 초기화하기
    9. 13.9 어댑터 ‘적절히’ 구축하기: 실제 사례
       1. 13.9.1 추상적이고 구체적인 구현 정의하기
       2. 13.9.2 테스트를 위한 가짜 버전 만들기
       3. 13.9.3 실제 통지를 사용한 통합 테스트 방법 찾기
    10. 13.10 마치며
23. 맺음말
    1. 14.1 왜 지금인가?
    2. 14.2 여기서 거기까지 어떻게 갈 수 있을까?
    3. 14.3 뒤엉킨 책임 분리
    4. 14.4 애그리게이트와 제한된 콘텍스트 식별하기
    5. 14.5 스트랭글러 패턴을 통해 마이크로서비스로 전환하는 이벤트 기반 접근 방법
    6. 14.6 새로운 일을 시작하도록 이해관계자 설득하기
    7. 14.7 기술 리뷰어들의 질문
    8. 14.8 풋건
    9. 14.9 추가 자료
    10. 14.10 마치며
24. 부록
25. 정리 다이어그램과 표
26. 프로젝트 구조 틀
    1. B.1 환경 변수, 12 팩터, 설정, 컨테이너 내부와 외부
    2. B.2 config.py
    3. B.3 docker-compose와 컨테이너 설정
    4. B.4 소스를 패키지로 설치하기
    5. B.5 Dockerfile
    6. B.6 테스트
    7. B.7 마치며
27. 인프라 교체: CSV로 모든 데이터 처리하기
    1. C.1 CSV를 사용한 저장소와 작업 단위 구현하기
28. 장고에서 작업 단위와 저장소 패턴 사용하기
    1. D.1 장고를 사용한 저장소 패턴
       1. D.1.1 도메인 모델과 상호 변환하기 위한 장고 ORM 클래스 커스텀 메서드
    2. D.2 장고 작업 단위 패턴
    3. D.3 API: 장고 뷰는 어댑터다
    4. D.4 이 모든 게 왜 그렇게 어려웠는가?
    5. D.5 이미 장고 앱을 사용 중이라면
    6. D.6 장고와 함께 진행할 수 있는 단계들
29. 검증
    1. E.2 문법 검증
    2. E.3 포스텔의 법칙과 톨러런트 리더 패턴
    3. E.4 가장자리에서 검증하기
    4. E.5 의미론 검증하기
    5. E.6 검증 화용론
30. 찾아보기