코드메모장

2.1 네 개의 영역

• 표현 영역
  • Controller 부분
  • 사용자와 상호 작용하는 영역
  • HTTP 요청 ↔ 응용 영역이 서로 통신할 수 있도록 요청과 응답을 변환
• 응용 영역
  • Service 부분
  • 시스템이 사용자에게 제공해야 할 기능을 구현
  • 기능을 구현하기 위해 도메인 영역의 도메인 모델을 사용
• 도메인 영역
  • Entity, Value 부분
  • 도메인의 핵심 로직을 구현
    • ex) Order 도메인의 핵심 기능은 ‘배송지 변경’, ‘결제 완료’ … 등이 있으며 해당 로직을 구현한다.
• 인프라스트럭처 영역
  • Repository, Utils 부분
  • 도메인 로직을 지원하고 구현을 외부 시스템과 연결하는 기술적 구조
    • ex) DB 연결, STMP 메일발송, 메세지큐 … 등

2.2 계층 구조 아키텍처

• 상위 계층에서 하위 계층으로 의존만 존재하고 하위 계층에서 상위 계층에 의존하지 않는다.

2.3 DIP

• DIP 란?
  • DIP(Dependency Inversion Principle, 의존성 역전 원칙)은 객체 지향 설계 원칙 중 하나로, 고수준 모듈이 저수준 모듈에 의존해서는 안 되고, 추상화를 통해 저수준 모듈이 고수준 모듈을 의존
• 장점
  • 저수준 모듈을 교체 하기가 용이
  • 테스트코드를 구현하기에 용이
    • 저수준 모듈의 구현체가 없는 추상화(Interface)만 존재하는 경우에도 테스트 코드 작성이 가능하다 (Mock 이용)

2.3.1 DIP 주의사항

• 단순히 인터페이스와 구현 클래스를 분리하는 것은 잘못된 사용
• 결과 구조만 보는것이 아닌 모듈의 관점에서 생각하여 추상화를 만들어야 한다.
  • ex)
    1. cacluateDiscountService → RuleEngine ← DroolsRuleEngine (잘못된 사용)
    2. cacluateDiscountService → RuleDiscounter ← DroolsRuleDiscounter (good)

2.3.2 DIP와 아키텍처

• DIP를 적용하게 되면, 응용 영역과 도메인 영역의 코드 수정 없이 인프라스트럭처부분만 코드를 추가/수정 및 변경하여 요구사항을 충족시킬 수 있다.

2.4 도메인 영역의 주요 구성요소

2.4.1 엔티티와 벨류

• 도메인 모델의 엔티티 vs DB 테이블의 엔티티
  • 도메인 모델의 엔티티는 단순 데이터만 담고 있는 구조가 아닌 데이터와 함께 도메인 기능을 제공
  • 도메인 모델 두개이상의 데이터가 개념적으로 하나인 경우에 Value 타입을 이용해서 표현할 수 있다.
    • ex) Order → name, email 을 Orderer라는 Value타입 객채를 만들어 관리 가능

2.4.2 애그리거트

• 지도를 볼 때 매우 상세하게 나온 대축척 지도를 보면 큰 수준에서 어디에 위치하고 있는지 이해하기 어려우므로 큰 수준에서 보여주는 소축척 지도를 함께 봐야 현재 위치를 보다 정확하게 이해할 수 있다. 이와 비슷하게 도메인 모델도 개별 객체뿐만 아니라 상위 수준에서 모델을 볼 수 있어야 전체 모델의 관계와 개별 모델을 이해하는데 도움이 된다.
  • ex) ‘주문’, ‘배송지 정보’, ‘주문자’, ‘주문 목록’, ‘총 결제 금액’의 하위 모델들을 ‘주문’이라는 상위 개념으로 표현할 수 있다.

2.5 요청 처리 흐름

2.6 인프라스트럭처 개요

• 표현 영역, 응용 영역, 도메인 영역을 지원한다.
• DIP에서 언급한 내용처럼 인프라스트럭처의 기능을 직접 사용하는것보다 인터페이스를 만들어서 사용하게 되면 시스템을 더 유연하고 테스트하기 쉽게 만들어준다. 하지만 무조건 인프라스트럭처에 대한 의존을 없애게 되면 오히려 더 복잡하고 어려운 코드를 유도할 수 있다.
  • ex) 인프라 스트럭처를 직접 사용하지 않기 위해 @Transaction 어노테이션을 사용하지 않고 개발을 하려고 하면 한줄로 처리할 수 있는 코드를 복잡하고 개발시간만 더 늘어날 뿐이다.

2.7 모듈 구성

• 도메인이 크면 하위 도메인으로 나누고 각 하위 도메인 마다 별도 패키지를 구성한다.
• 모듈 구성에 대해서는 정답이 없으며, 한 패키지에 10~15개 미만으로 타입 개수를 유지하려고 노력한다.

작성 목적

해당 게시글은 DDD관련하여 공부를 하던 중 개인적으로 모르거나 햇갈리는 용어에 대해 리마인드 하기 위해 요약한 내용입니다.

잘못 이해하고 있는 내용이 있으면 댓글로 남겨주시면 감사하겠습니다.

(DDD관련 학습을 진행하는 동안 지속적으로 업데이트 할 예정)

용어

• 도메인 주도 설계(DDD(Domain-Driven Design))
  • 복잡한 소프트웨어를 설계 및 개발하는 과정에서 핵심적인 비지니스 개념과 비지니스 논리 중심으로 설계하는 방법
• 도메인 전문가
  • 특정 분야나 사업에 대해 깊이있는 지식과 경험을 가진 사람
• 개념모델 vs구현 모델
  • 개념모델 : "무엇"을 할 것인지에 대한 전략적 설계를 제공
  • 구현모델 : "어떻게" 실행할 것인지에 대한 실용적인 가이드를 제공
• 유비쿼터스 언어 (보편언어)
  • 팀원 모두가 동일하게 이해하고 표현하는 공통적인 언어

참고 자료

• 도메인 주도 개발 시작하기: DDD 핵심 개념 정리부터 구현까지
• ChatGPT 4.0

(1) 문제

• 행의 수가 N이고 열의 수가 M인 격자의 각 칸에 1부터 N×M까지의 번호가 첫 행부터 시작하여 차례로 부여되어 있다. 격자의 어떤 칸은 ○ 표시가 되어 있다. (단, 1번 칸과 N × M번 칸은 ○ 표시가 되어 있지 않다. 또한, ○ 표시가 되어 있는 칸은 최대 한 개이다. 즉, ○ 표시가 된 칸이 없을 수도 있다.) 
  • 조건 1: 로봇은 한 번에 오른쪽에 인접한 칸 또는 아래에 인접한 칸으로만 이동할 수 있다. (즉, 대각선 방향으로는 이동할 수 없다.)
  • 조건 2: 격자에 ○로 표시된 칸이 있는 경우엔 로봇은 그 칸을 반드시 지나가야 한다. 
• 위에서 보인 것과 같은 격자가 주어질 때, 로봇이 이동할 수 있는 서로 다른 경로의 두 가지 예가 아래에 있다.
  • 1 → 2 → 3 → 8 → 9 → 10 → 15
  • 1 → 2 → 3 → 8 → 13 → 14 → 15
• 격자에 관한 정보가 주어질 때 로봇이 앞에서 설명한 두 조건을 만족하면서 이동할 수 있는 서로 다른 경로가 총 몇 개나 되는지 찾는 프로그램을 작성하라. 
• 격자의 1번 칸에서 출발한 어떤 로봇이 아래의 두 조건을 만족하면서 N×M번 칸으로 가고자 한다. 
• 행의 수가 3이고 열의 수가 5인 격자에서 각 칸에 번호가 1부터 차례대로 부여된 예가 아래에 있다. 이 격자에서는 8번 칸에 ○ 표시가 되어 있다.

(2) 입력

• 입력의 첫째 줄에는 격자의 행의 수와 열의 수를 나타내는 두 정수 N과 M(1 ≤ N, M ≤ 15), 그리고 ○로 표시된 칸의 번호를 나타내는 정수 K(K=0 또는 1 < K < N×M)가 차례로 주어지며, 각 값은 공백으로 구분된다. K의 값이 0인 경우도 있는데, 이는 ○로 표시된 칸이 없음을 의미한다. N과 M이 동시에 1인 경우는 없다.

(3) 출력

• 주어진 격자의 정보를 이용하여 설명한 조건을 만족하는 서로 다른 경로의 수를 계산하여 출력해야 한다. 

(4) 예제 입력 및 출력

(5) 코드

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class 전화번호목록{

    public static void main(String[] args) throws IOException{
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in)); 
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));

        //방식 0,0 에서 K까지의 경우의 수 * K에서의 n,m 까지의 경우의 수를 구하면됩니다..

        //N은 행 M은 열

        StringTokenizer stk = new StringTokenizer(bufferedReader.readLine());

        int N = Integer.parseInt(stk.nextToken());
        int M = Integer.parseInt(stk.nextToken());
        int K = Integer.parseInt(stk.nextToken());

        //1부터 검사하기위해 +1 해준 값으로 초기화합니다.
        int[][] visitCount = new int[M + 1][N + 1];

        Point startPoint = new Point(1,1);
        Point targetPoint;

        int targetX;
        int targetY;

        int midCount = 1;
        int answer = 0;

        if(K != 0){
            targetX = K % M;
            targetY = (K / M) + 1;

            if(targetX == 0){
                targetX = M;
                targetY --;
            }            

            targetPoint = new Point(targetX,targetY);

            midCount = DP(startPoint, targetPoint, visitCount);

            startPoint = targetPoint;
        } 


        targetX = M;
        targetY = N;

        targetPoint = new Point(targetX,targetY);
        
        visitCount = new int[M + 1][N + 1];

        answer = DP(startPoint, targetPoint, visitCount) * midCount;

        bufferedWriter.write(String.valueOf(answer));
        bufferedWriter.flush();
        bufferedWriter.close();
        bufferedReader.close();
    }

    public static int DP(Point startPoint, Point targetPoint, int[][] visitCount){

        // 피라미드 형태로 생각해서 구현하였습니다.
        Queue<Point> queue = new LinkedList<>();

        visitCount[startPoint.x][startPoint.y] = 1;

        queue.add(startPoint);

        while(!(queue.isEmpty())){
            Point point = queue.poll();
            if(!(point.x == startPoint.x && point.y == startPoint.y)){
                visitCount[point.x][point.y] = visitCount[point.x - 1][point.y] + visitCount[point.x][point.y - 1];
            }
            
            // 범위 설정 오른쪽 또는 아래로 이동하기 때문에 모든 수가 0보다 크다.
            if(point.x < targetPoint.x){
                Point newPoint = new Point(point.x + 1,point.y);
                queue.add(newPoint);
            } else {
                if(point.y < targetPoint.y){
                    Point newPoint = new Point(startPoint.x,point.y + 1);
                    queue.add(newPoint);
                }                
            }
        }

        return visitCount[targetPoint.x][targetPoint.y];
    }

    public static class Point{
        private int x;
        private int y;

        public int getX(){
            return this.x;
        }

        public void setX(int x){
            this.x = x;
        }
        
        public int getY(){
            return this.y;
        }

        public void setY(int y){
            this.y = y;
        }

        public Point(int x, int y){
            this.x = x;
            this.y = y;
        }
    }
}

(6) 실행결과