PROGRAMMING

[BOJ] [JAVA] [GOLD 4] 17298: 오큰수

c0mmedes — Fri, 2 Aug 2024 16:33:44 +0900

https://www.acmicpc.net/problem/17298

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    static int N, A[];
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        N = Integer.parseInt(br.readLine()); // 크기
        A = new int[N];

        StringTokenizer st = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) {
            A[i] = Integer.parseInt(st.nextToken());
        }

        Stack<Integer> stack = new Stack<>();

        for (int i = 0; i < N; i++) {
            // 전에 있던 인덱스의 해당하는 수가 이번에 해당하는 수보다 작으면 그 자리에 넣어주기
            while(!stack.isEmpty() && A[stack.peek()] < A[i]) {
                A[stack.pop()] = A[i];
            }
            // 다음 인덱스 작업을 위해 넣어주고
            stack.push(i);
        }

        // 남은 애들 처리
        while(!stack.isEmpty()) {
            A[stack.pop()] = -1;
        }

        StringBuilder sb = new StringBuilder();
        
        for (int num : A) sb.append(num + " ");

        System.out.println(sb);

    }
}
// 오큰수(오른쪽에 있으면서 Ai 보다 큰 수 중에서 가장 왼쪽에 있는 수, 없을 경우 -1) 구하기
// ex) A = [3, 5, 2, 7] -> NGE(1) = 5, NGE(2) = 7, NGE(3) = 7, NGE(4) = -1
// ex) A = [9, 5, 4, 8] -> NGE(1) = -1, NGE(2) = 8, NGE(3) = 8, NGE(4) = -1

수가 아닌 인덱스로 접근하는 것이 핵심
StringBuilder 중요

[BOJ] [JAVA] [GOLD 3] 2623: 음악프로그램

c0mmedes — Fri, 5 Jul 2024 13:05:44 +0900

https://www.acmicpc.net/problem/2623

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {
    static int N, M;
    static Node adjList[];
    static int inDegree[];
    static class Node {
        int vertex;
        Node link;

        public Node (int vertex, Node link){
            this.vertex = vertex;
            this.link = link;
        }
    }
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken()); // 가수의 수
        M = Integer.parseInt(st.nextToken()); // 보조PD의 수
        
        adjList = new Node[N+1];
        inDegree = new int[N+1]; // 진입 간선의 수 체크

        for (int m = 0; m < M; m++) {
            st = new StringTokenizer(br.readLine());
            int num = Integer.parseInt(st.nextToken()); // 보조PD가 담당한 가수의 수
            int temp[] = new int[num];
            for (int i = 0; i < num; i++) {
                temp[i] = Integer.parseInt(st.nextToken()); // 순서
            }
            for (int i = 0; i < num-1; i++) {
                // A -> B
                int A = temp[i]; // 진출 정점
                int B = temp[i+1]; // 진입 정점
                adjList[A] = new Node(B, adjList[A]);
                inDegree[B]++; // 진입 간선++
            }
        }

        ArrayList<Integer> list = topologySort();
        if(list.size() == N) {
            for (Integer vertex : list) System.out.println(vertex);
        } else {
            System.out.println(0);
        }
    }

    private static ArrayList<Integer> topologySort() {
        ArrayList<Integer> orderList = new ArrayList<>();
        Queue<Integer> q = new ArrayDeque<>();

        for (int i = 1; i <= N; i++) {
            if(inDegree[i] == 0) q.offer(i); // 진입 차수가 0인 애들 넣어주고
        }

        while(!q.isEmpty()) {
            int cur = q.poll();
            orderList.add(cur);

            // 현재 정점 기준으로 인접정점 정리
            for (Node node = adjList[cur]; node != null; node = node.link) {
                if(--inDegree[node.vertex] == 0) q.offer(node.vertex);
            }
        }
        return orderList;
    }
}

위상 정렬

유향 그래프
싸이클 존재하지 않음
방향성을 거스리지 않으면서 순서적으로 탐색

메커니즘
- 차수 - 정점에 연결된 간선 수
  - 진출 차수 - 자신의 정점에서 타정점으로 나가는 간선 수
  - 진입 차수 - 타정점에서 자신의 정점으로 들어오는 간선 수
1. - 1. 진입 차수가 0인 노드(시작점)를 큐에 모두 넣는다.
    2. 큐에서 진입 차수가 0인 노드를 꺼내어 자신과 입전한 노드의 간선을 제거한다.
      1. 인접한 노드의 진입 차수를 1 감소시킨다.
    3. 간선 제거 후 진입 차수가 0이 된 노드를 큐에 넣는다.
    4. 큐가 공백 큐 상태가 될 때 까지 2-3 작업을 반복
      1. 모든 노드가 처리되지 않았다면 사이클 발생
      2. 모든 노드가 다 처리되었다면 위상 정렬 완성

[BOJ] [JAVA] [GOLD 3] 2252: 줄 세우기

c0mmedes — Wed, 3 Jul 2024 15:36:51 +0900

https://www.acmicpc.net/problem/2252

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class BOJ2252 {
    static class Node {
        int vertex;
        Node link;
        public Node (int vertex, Node link) {
            this.vertex = vertex;
            this.link = link;
        }
    }
    static int N, M;
    static Node adjList[];
    static int inDegree[];
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        N = Integer.parseInt(st.nextToken()); // N명의 학생
        M = Integer.parseInt(st.nextToken()); // 키를 비교한 회수
        adjList = new Node[N+1];
        inDegree = new int[N+1]; // 진입간선의 수 체크를 위한 배열

        for (int m = 0; m < M; m++) {
            st = new StringTokenizer(br.readLine());
            // A가 학생 B의 앞에 서야함
            // A -> B 로 가는 간선
            int A = Integer.parseInt(st.nextToken()); // from, 진출 정점
            int B = Integer.parseInt(st.nextToken()); // to, 진입 정점
            adjList[A] = new Node(B, adjList[A]);
            inDegree[B]++; // 간선을 받는 B++
        }

        ArrayList<Integer> list = topologySort();
        if(list.size() == N) {
            for (Integer vertex : list) {
                System.out.print(vertex + " ");
            }
        } else {
            System.out.println("사이클 발생");
        }
    }

    private static ArrayList<Integer> topologySort() {
        ArrayList<Integer> orderList = new ArrayList<>();
        Queue<Integer> q = new ArrayDeque<>();
        for (int i = 1; i <= N; i++) {
            if(inDegree[i] == 0) q.offer(i); // 진입 차수가 0인 정점 넣기
        }

        while(!q.isEmpty()) {
            int cur = q.poll();
            orderList.add(cur);

            // 현재 정점 기준으로 인접정점 처리
            for (Node temp = adjList[cur]; temp != null; temp = temp.link) {
                if (--inDegree[temp.vertex] == 0) q.offer(temp.vertex);
            }
        }
        return orderList;
    }
}

// tc
/*
3 2
1 3
2 3
answer : 1 2 3

4 2
4 2
3 1
answer : 4 2 3 1 (답은 여러가지)
*/

위상 정렬

유향 그래프
싸이클 존재하지 않음
방향성을 거스리지 않으면서 순서적으로 탐색

메커니즘
- 차수 - 정점에 연결된 간선 수
  - 진출 차수 - 자신의 정점에서 타정점으로 나가는 간선 수
  - 진입 차수 - 타정점에서 자신의 정점으로 들어오는 간선 수
1. - 1. 진입 차수가 0인 노드(시작점)를 큐에 모두 넣는다.
    2. 큐에서 진입 차수가 0인 노드를 꺼내어 자신과 입전한 노드의 간선을 제거한다.
      1. 인접한 노드의 진입 차수를 1 감소시킨다.
    3. 간선 제거 후 진입 차수가 0이 된 노드를 큐에 넣는다.
    4. 큐가 공백 큐 상태가 될 때 까지 2-3 작업을 반복
      1. 모든 노드가 처리되지 않았다면 사이클 발생
      2. 모든 노드가 다 처리되었다면 위상 정렬 완성

[SWEA] [JAVA] [Difficulty 4] [1249] [S/W 문제해결 응용] 4일차 - 보급로

c0mmedes — Wed, 3 Jul 2024 15:29:48 +0900

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AV15QRX6APsCFAYD&

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Solution {
    static class Coor {
        int x, y;
        public Coor (int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
    static int dx[] = {-1, 1, 0, 0};
    static int dy[] = {0, 0, -1, 1};
    static int N, arr[][];
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        int T = Integer.parseInt(br.readLine()); // 입력받는 데이터의 길이

        for (int t = 1; t <= T; t++) {
            N = Integer.parseInt(br.readLine());
            arr = new int[N][N];

            for (int i = 0; i < N; i++) {
                String s = br.readLine(); // 정보
                for (int j = 0; j < N; j++) {
                    arr[i][j] = s.charAt(j) - '0';
                }
            }

            sb.append("#" + t + " " + bfs() + "\n");
        }

        System.out.print(sb);
    }

    private static int bfs() {
        int tempArr[][] = new int[N][N];
        for (int i = 0; i < N; i++) Arrays.fill(tempArr[i], Integer.MAX_VALUE);
        Queue<Coor> q = new ArrayDeque<>();
        q.offer(new Coor(0, 0));
        tempArr[0][0] = 0;

        while(!q.isEmpty()) {
            Coor coor = q.poll();
            int x = coor.x;
            int y = coor.y;

            for (int d = 0; d < 4; d++) {
                int nx = x + dx[d];
                int ny = y + dy[d];
                if (nx < 0 || ny < 0 || nx >= N || ny >= N) continue;
                if (tempArr[x][y] + arr[nx][ny] < tempArr[nx][ny]) {
                    tempArr[nx][ny] = tempArr[x][y] + arr[nx][ny];
                    q.offer(new Coor(nx, ny));
                    }
                }
            }
        return tempArr[N-1][N-1];
    }
}
// 파손된 도로들은 이동 불가
// 출발지 S(0, 0) 에서 도착지 G(N-1, N-1)까지 가는 경로 중 복구 시간이 가장 짧은 경로에 대한 총 복구 시간 ㄱ하기
// 파여진 만큼의 복구 시간
// 최단거리 구하기 X 최단시간 구하기 O

[프로그래머스] [JAVA] [Level 2] [완전탐색] 피로도

c0mmedes — Thu, 27 Jun 2024 14:41:26 +0900

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

import java.util.*;
import java.io.*;

class Solution {
    static int numbers[];
    static boolean visited[];
    static int N, answer, mine;
    public int solution(int k, int[][] dungeons) {
        answer = -1;
        N = dungeons.length;
        mine = k;
        
        // 최대 개수 -> 순열로 던전의 수만큼 뽑기시작하고 그 값이 0이상일 때 break;
        // 최대의 경우의 수부터 뽑았기 때문
        for (int i = N; i > 0; i--) {
            numbers = new int[i];
            visited = new boolean[N];
            perm(i, 0, dungeons);
            if(answer > 0) break;
        }
        
        return answer;
    }
    private static void perm(int size, int cnt, int[][] dungeons) {
        if(cnt == size) {
            int temp = mine;
            int count = 0;
            for (int i = 0; i < numbers.length; i++){
                int index = numbers[i];
                int min = dungeons[index][0];// 최소 필요 피로도
                int use = dungeons[index][1];// 소모 피로도 
                if (temp < min) return;
                else {
                    temp -= use;
                    count++;
                }
            }
            answer = Math.max(count, answer);
            return;
        }
        
        for(int i = 0; i < N; i++) {
            if(visited[i]) continue;
            visited[i] = true;
            numbers[cnt] = i;
            perm(size, cnt + 1, dungeons);
            visited[i] = false;
        }
    }
}

// 각 던전마다 탐험 시작 최소 필요 피로도와 던전 탐험 후 소모 피로도가 있다.
// k - 현재 피로도, dungeons - 최소필요피로도, 소모피로도가 담긴 2차원 배열 던전
// 유저가 탐험할 수 있는 최대 던전 수 return

[BOJ] [JAVA] [GOLD 4] 17060 : 파이프 옮기기 2

c0mmedes — Tue, 25 Jun 2024 14:41:04 +0900

https://www.acmicpc.net/problem/17069

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    static int N, arr[][];
    static long dp[][][];
    public static void main(String[] args) throws Exception{
        BufferedReader br =  new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        N = Integer.parseInt(st.nextToken());

        arr = new int[N][N];
        dp = new long[N][N][3]; // 방향까지 저장해줄 3차원배열

        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < N; j++) {
                arr[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        if (arr[N-1][N-1] == 1) {
            System.out.println(0);
            return;
        }

        // 시작점
        dp[0][1][0] = 1;

        for (int i = 0; i < N; i++) {
            // 아래, 오른쪽, 대각선으로만 이동하기 때문에 시작의 꼬리 다음칸인 2부터 시작
            for (int j = 2; j < N; j++) {
                if(arr[i][j] == 1) continue;

                // 가로 - 전의 칸에 가로와 대각선으로 도착한 애들 추가
                dp[i][j][0] = dp[i][j-1][0] + dp[i][j-1][2];

                // 세로일 경우 맨 위칸은 위랑 대각선에서 못옴
                if (i == 0) continue;
                dp[i][j][1] = dp[i-1][j][1] + dp[i-1][j][2];

                // 대각선일 경우 다음칸의 상 좌에 1이 있을 경우 이동못함
                if (arr[i-1][j] == 1 || arr[i][j-1] == 1) continue;
                dp[i][j][2] = dp[i-1][j-1][0] + dp[i-1][j-1][1] + dp[i-1][j-1][2];
            }
        }

        System.out.println(dp[N-1][N-1][0] + dp[N-1][N-1][1] + dp[N-1][N-1][2]);
    }
}

// 파이프는 연속된 2칸 차지
// 상하 좌우 좌상우하(대각선) 가능
// 1.1 - 1.2의 파이프를 N,N까지 이동시키는 경우의 수 구하기.

application.properties yaml git ignore 민감정보 숨기기

c0mmedes — Tue, 12 Sep 2023 10:48:01 +0900

application-secret.properties

application-secret.yaml

# application-secret.yml

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/secretdb
    username: secretuser
    password: secretpassword

# 다른 시크릿 프로파일 관련 설정을 추가

application.yaml

spring:
  profiles:
    include: secret

application.properties

spring.profiles.include=secret

git ignore에 application-secret.properties, application-secret.yaml 등록

[자바 ORM 표준 JPA 프로그래밍] [섹션 6] 다양한 연관관계 매핑

c0mmedes — Mon, 17 Jul 2023 01:11:56 +0900

1. 연관관계 매핑시 고려사항 3가지

다중성
- 다대일: @ManyToOne
- 일대다: @OneToMany
- 일대일: @OneToOne
- 다대다: @ManyToMany
단방향, 양방향
- 테이블
  - 외래 키 하나로 양쪽 조인 가능
  - 사실 방향이라는 개념이 없음
- 객체
  - 참조용 필드가 있는 쪽으로만 참조 가능
  - 한쪽만 참조하면 단방향
  - 양쪽이 서로 참조하면 양방향
연관관계의 주인
- 테이블은 외래 키 하나로 두 테이블이 연관관계를 맺음
- 객체 양방향 관계는 A->B, B->A 처럼 참조가 2군데
- 객체 양방향 관계는 참조가 2군데 있음. 둘중 테이블의 외래 키 를 관리할 곳을 지정해야함
- 연관관계의 주인: 외래 키를 관리하는 참조
- 주인의 반대편: 외래 키에 영향을 주지 않음, 단순 조회만 가능

다대다는 실무에서 쓰면 안된다고 생각해라.

객체 -> 양방향이라는건 사실 없다. (참조 입장에서 보면 단방향이 두개가 있어서 양쪽으로 걸기때문에 양방향처럼 보이는거임)

2. 다대일 [N:1]

가장많이 사용
다대일의 반대는 일대다
N쪽에 외래키가 항상 가야됨
N이 연관관계의 주인
양쪽을 서로 참조하도록 개발

3. 일대다 [1:N]

일대다 단방향

일대다 단방향 정리

일대다 단방향은 일대다(1:N)에서 일(1)이 연관관계의 주인
테이블 일대다 관계는 항상 다(N) 쪽에 외래 키가 있음
객체와 테이블의 차이 때문에 반대편 테이블의 외래 키를 관리하 는 특이한 구조
@JoinColumn을 꼭 사용해야 함. 그렇지 않으면 조인 테이블 방식을 사용함(중간에 테이블을 하나 추가함)
일대다 단방향 매핑의 단점
- 엔티티가 관리하는 외래 키가 다른 테이블에 있음
- 연관관계 관리를 위해 추가로 UPDATE SQL 실행
일대다 단방향 매핑보다는 다대일 양방향 매핑을 사용하자

package hellojpa;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import java.util.List;

public class JpaMain {
    public static void main(String[] args) {
        // Persistence.xml에서 설정해준 name으로 factory를 만들어서 연결
        // 웹 서버가 올라오는 시점에 딱 1개만 생성
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");

        // 고객의 요청이 올 때마다 썼다가 버림(em.close)
        // 그래서 쓰레드간에 절대 공유 X(사용하고 버려야됨)
        EntityManager em = emf.createEntityManager();

        EntityTransaction tx = em.getTransaction();

        tx.begin();

        // JPA의 모든 DATA 변경은 트랜잭션 안에서 실행
        // 단순 조회는 트랜잭션 필요 X
        try {
            Member member = new Member();
            member.setUsername("member1");

            em.persist(member);

            // Team Insert
            Team team = new Team();
            team.setName("TeamA");

            // 권장하지않음
            // 다대일 양방향 매핑 권장
            team.getMembers().add(member);

            em.persist(team);

            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }

        emf.close();
    }
}

package hellojpa;

import javax.persistence.*;

@Entity
public class Member {

    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;

    @Column(name = "USERNAME")
    private String username;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }


}

package hellojpa;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;

@Entity
public class Team {
    @Id
    @GeneratedValue
    private Long id;
    private String name;

    @OneToMany
    @JoinColumn(name = "TEAM_ID")
    private List<Member> members= new ArrayList<>();

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Member> getMembers() {
        return members;
    }

    public void setMembers(List<Member> members) {
        this.members = members;
    }
}

일대다 단방향

일대다 양방향 정리

이런 매핑은 공식적으로 존재X
@JoinColumn(insertable=false, updatable=false)
읽기 전용 필드를 사용해서 양방향 처럼 사용하는 방법
다대일 양방향을 사용하자

결론 - 일대다보다는 다대일 양방향 매핑을 쓰자.

4. 일대일 [1:1]

일대일 관계

일대일 관계는 그 반대도 일대일
주 테이블이나 대상 테이블 중에 외래 키 선택 가능
- 주 테이블에 외래 키
- 대상 테이블에 외래 키
외래 키에 데이터베이스 유니크(UNI) 제약조건 추가

다대일(@ManyToOne) 단방향 매핑과 유사

다대일 양방향 매핑 처럼 외래 키가 있는 곳이 연관관계의 주인
반대편은 mappedBy 적용

단방향 관계는 JPA 지원X
양방향 관계는 지원

사실 일대일 주 테이블에 외래 키 양방향과 매핑 방법은 같음

일대일 정리

주 테이블에 외래 키
- 주 객체가 대상 객체의 참조를 가지는 것 처럼 주 테이블에 외래 키를 두고 대상 테이블을 찾음
- 객체지향 개발자 선호
- JPA 매핑 편리
- 장점: 주 테이블만 조회해도 대상 테이블에 데이터가 있는지 확인 가능
- 단점: 값이 없으면 외래 키에 null 허용
대상 테이블에 외래 키
- 대상 테이블에 외래 키가 존재
- 전통적인 데이터베이스 개발자 선호
- 장점: 주 테이블과 대상 테이블을 일대일에서 일대다 관계로 변경할 때 테이블 구조 유지
- 단점: 프록시 기능의 한계로 지연 로딩으로 설정해도 항상 즉시 로딩됨(프록시는 뒤에서 설명)

//public class Member 

@OneToOne
    @JoinColumn(name = "LOCKER_ID")
    private Locker locker;

// ------------------ //

public class Locker {

    @Id @GeneratedValue
    private Long id;
    private String name;


    // 양방향
//    @OneToOne(mappedBy = "locker")
//    private Member member;
}

5. 다대다 [N:M]

실무에서 쓰면 안된다. (왜 안되는지 알자)
관계형 데이터베이스는 정규화된 테이블 2개로 다대다 관계를 표현할 수 없음
연결 테이블을 추가해서 일대다, 다대일 관계로 풀어내야함

객체는 컬렉션을 사용해서 객체 2개로 다대다 관계 가능

@ManyToMany 사용
@JoinTable로 연결 테이블 지정
다대다 매핑: 단방향, 양방향 가능

다대다 매핑의 한계

편리해 보이지만 실무에서 사용X
연결 테이블이 단순히 연결만 하고 끝나지 않음
주문시간, 수량 같은 데이터가 들어올 수 있음

다대다 한계 극복

연결 테이블용 엔티티 추가(연결 테이블을 엔티티로 승격
@ManyToMany -> @OneToMany, @ManyToOne

package hellojpa;

import javax.persistence.*;
import java.time.LocalDateTime;

@Entity
public class MemberProduct {

    @Id @GeneratedValue
    private Long id;

    @ManyToOne
    @JoinColumn(name = "MEMBER_ID")
    private Member member;

    @ManyToOne
    @JoinColumn(name = "PRODUCT_ID")
    private Product product;

    private int count;
    private int price;

    private LocalDateTime orderDateTime;

}

package hellojpa;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;

@Entity
public class Product {
    @Id @GeneratedValue
    private Long id;
    private String name;
    @OneToMany(mappedBy = "prodcut")
    private List<MemberProduct> memberProducts = new ArrayList<>();

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<MemberProduct> getMemberProducts() {
        return memberProducts;
    }

    public void setMemberProducts(List<MemberProduct> memberProducts) {
        this.memberProducts = memberProducts;
    }
}

package hellojpa;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;

@Entity
public class Member {

    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;

    @Column(name = "USERNAME")
    private String username;

    @OneToOne
    @JoinColumn(name = "LOCKER_ID")
    private Locker locker;

    @OneToMany(mappedBy = "member")
    private List<MemberProduct> memberProductList = new ArrayList<>();

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }


}

6. 실전 예제 - 다양한 연관관계 매핑

N:M 관계는 1:N, N:1로

테이블의 N:M 관계는 중간 테이블을 이용해서 1:N, N:1
실전에서는 중간 테이블이 단순하지 않다.
@ManyToMany는 제약: 필드 추가X, 엔티티 테이블 불일치
실전에서는 @ManyToMany 사용X

@JoinColumn

외래 키를 매핑할 때 사용

@ManyToOne

@OneToMany

[자바 ORM 표준 JPA 프로그래밍] [섹션 5] 연관관계 매핑 기초

c0mmedes — Sat, 15 Jul 2023 16:25:44 +0900

Z1. 단방향 연관관계

객체를 테이블에 맞추어 데이터 중심으로 모델링하면, 협력 관계를 만들 수 없다.

테이블은 외래 키로 조인을 사용해서 연관된 테이블을 찾는다.
객체는 참조를 사용해서 연관된 객체를 찾는다.
테이블과 객체 사이에는 이런 큰 간격이 있다.

객체를 테이블에 맞추어 모델링 (연관관계가 없는 객체)

객체 지향 모델링 (ORM 매핑)

Member.java

package hellojpa;

import javax.persistence.*;

@Entity
public class Member {

    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;

    @Column(name = "USERNAME")
    private String username;

    @ManyToOne // 다대일 (멤버 N : 팀 1)
    @JoinColumn(name = "TEAM_ID") // 매핑해야되는 컬럼
    private Team team;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Team getTeam() {
        return team;
    }

    public void setTeam(Team team) {
        this.team = team;
    }
}

Team.java

package hellojpa;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Team {
    @Id
    @GeneratedValue
    private Long id;
    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

JpaMain.java

package hellojpa;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

public class JpaMain {
    public static void main(String[] args) {
        // Persistence.xml에서 설정해준 name으로 factory를 만들어서 연결
        // 웹 서버가 올라오는 시점에 딱 1개만 생성
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");

        // 고객의 요청이 올 때마다 썼다가 버림(em.close)
        // 그래서 쓰레드간에 절대 공유 X(사용하고 버려야됨)
        EntityManager em = emf.createEntityManager();

        EntityTransaction tx = em.getTransaction();

        tx.begin();

        // JPA의 모든 DATA 변경은 트랜잭션 안에서 실행
        // 단순 조회는 트랜잭션 필요 X
        try {
            // * insert
//            Member member = new Member();
//            member.setId(1L);
//            member.setName("HelloA");
//            em.persist(member);

            // * select
//            Member findMember = em.find(Member.class, 1L);
//            System.out.println("findMember.id = " + findMember.getId());
//            System.out.println("findMember.name = " + findMember.getId());

            // * delete
//            Member findMember = em.find(Member.class, 1L);
//            em.remove(findMember);

            // * update
            // 객체에서 값만 바꿔도 되는 이유는 JPA가 관리해서 트랜잭션을
            // 커밋하는 시점에 다 체크해서 UPDATE 쿼리를 만들어서 날림 그 이후에 커밋
//            Member findMember = em.find(Member.class, 1L);
//            findMember.setName("HelloJPA");

            // 저장
            Team team = new Team();
            team.setName("TeamA");
            em.persist(team);

            Member member = new Member();
            member.setUsername("member1");
            member.setTeam(team);
            em.persist(member);

            // 영속성 컨텍스트 말고 DB에서 가져오는걸 보고싶을 때
//            em.flush();
//            em.clear();

            Member findMember = em.find(Member.class, member.getId());
            Team findTeam = findMember.getTeam();
            System.out.println("findTeam = " + findTeam.getName());

            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }

        emf.close();
    }
}

2. 양방향 연관관계와 연관관계의 주인

양방향 매핑

연관관계의 주인과 mappedBy

mappedBy = JPA의 멘탈붕괴 난이도
mappedBy는 처음에는 이해하기 어렵다.
객체와 테이블간에 연관관계를 맺는 차이를 이해해야 한다.

객체와 테이블이 관계를 맺는 차이

객체 연관관계 = 2개
- 회원 -> 팀 연관관계 1개(단방향)
- 팀 -> 회원 연관관계 1개(단방향)
테이블 연관관계 = 1개
- 회원 <-> 팀의 연관관계 1개(양방향)

객체의 양방향 관계

객체의 양방향 관계는 사실 양방향 관계가 아니라 서로 다른 단 뱡향 관계 2개다.
객체를 양방향으로 참조하려면 단방향 연관관계를 2개 만들어야 한다.
A -> B (a.getB())
B -> A (b.getA())
ex) class A { B b; }, class B { A a; }

테이블의 양방향 관계

테이블은 외래 키 하나로 두 테이블의 연관관계를 관리
MEMBER.TEAM_ID 외래 키 하나로 양방향 연관관계 가짐 (양쪽으로 조인할 수 있다.)

SELECT *
FROM MEMBER M
JOIN TEAM T ON M.TEAM_ID = T.TEAM_ID

SELECT *
FROM TEAM T
JOIN MEMBER M ON T.TEAM_ID = M.TEAM_ID

둘 중 하나로 외래 키를 관리해야 한다.

연관관계의 주인(Owner)

양방향 매핑 규칙

객체의 두 관계중 하나를 연관관계의 주인으로 지정
연관관계의 주인만이 외래 키를 관리(등록, 수정)
주인이 아닌쪽은 읽기만 가능
주인은 mappedBy 속성 사용X
주인이 아니면 mappedBy 속성으로 주인 지정

누구를 주인으로?

외래 키가 있는 있는 곳을 주인으로 정해라
여기서는 Member.team이 연관관계의 주인
N쪽이 연관관계의 주인

3. 양방향 연관관계와 연관관계의 주인 2 - 주의점, 정리

양방향 매핑시 가장 많이 하는 실수 (연관관계의 주인에 값을 입력하지 않음)

Team team = new Team();
 team.setName("TeamA");
 em.persist(team);
 Member member = new Member();
 member.setName("member1");
 //역방향(주인이 아닌 방향)만 연관관계 설정
 team.getMembers().add(member);
 em.persist(member);

양방향 매핑시 연관관계의 주인에 값을 입력해야 한다. (순수한 객체 관계를 고려하면 항상 양쪽다 값을 입력해야 한다.)

Team team = new Team();
 team.setName("TeamA");
 em.persist(team);
 Member member = new Member();
 member.setName("member1");
 team.getMembers().add(member);
 //연관관계의 주인에 값 설정
 member.setTeam(team); //**
 em.persist(member);

양방향 연관관계 주의 - 실습

순수 객체 상태를 고려해서 항상 양쪽에 값을 설정하자
연관관계 편의 메소드를 생성하자

 /* jpaMain.java */
 Team team = new Team();
            team.setName("TeamA");
            em.persist(team);

            Member member = new Member();
            member.setUsername("member1");

//            setTeam에서 해주도록 등록해놨기 때문에 필요없음
//            team.getMembers().add(member);

            //연관관계의 주인에 값 설정
            member.setTeam(team); //**
            em.persist(member);


public void setTeam(Team team) {
        this.team = team;
        // this == member
        team.getMembers().add(this);
}

양방향 매핑시에 무한 루프를 조심하자
- 예: toString(), lombok, JSON 생성 라이브러리
- lombok에서 tostring 만드는건 웬만하면 쓰지말자
- 컨트롤러에서 엔티티를 바로 반환x (컨트롤러에서 dto로 변환해서 반환해라)

양방향 매핑 정리

단방향 매핑만으로도 이미 연관관계 매핑은 완료 (처음 설계할 때는 무조건 단방향으로 해라)
양방향 매핑은 반대 방향으로 조회(객체 그래프 탐색) 기능이 추가된 것 뿐
JPQL에서 역방향으로 탐색할 일이 많음
단방향 매핑을 잘 하고 양방향은 필요할 때 추가해도 됨 (테이블에 영향을 주지 않음)

연관관계의 주인을 정하는 기준

비즈니스 로직을 기준으로 연관관계의 주인을 선택하면 안됨
연관관계의 주인은 외래 키의 위치를 기준으로 정해야함

4. 실전 예제 - 2. 연관관계 매핑 시작

실전 예제 1에서 했던 프로젝트를 연관관계로 바꾸자

Member.java

package jpabook.jpashop.domain;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;

@Entity
public class Member {

    // @GeneratedValue의 Default는 Auto
    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;
    private String name;
    private String city;
    private String street;
    private String zipcode;

    // Order의 member가 연관관계의 주인
    @OneToMany(mappedBy = "member")
    private List<Order> orders = new ArrayList<>();

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public String getZipcode() {
        return zipcode;
    }

    public void setZipcode(String zipcode) {
        this.zipcode = zipcode;
    }
}

Order.java

package jpabook.jpashop.domain;

import javax.persistence.*;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

@Entity
@Table(name = "ORDERS") // db의 예약어가 order인 경우가 있어서
public class Order {

    @Id @GeneratedValue
    @Column(name = "ORDER_ID")
    private Long id;

    // 주문자명
    // 관계형DB를 객체에 만든 설계
//    @Column(name = "MEMBER_ID")
//    private Long memberId;

    // 연관관계 매핑
    @ManyToOne
    @JoinColumn(name = "MEMBER_ID")
    private Member member;

    @OneToMany(mappedBy = "order")
    private List<OrderItem> orderItems = new ArrayList<>();

    // 연관관계 편의 메서드
    public void addOrderItem(OrderItem orderItem) {
        orderItems.add(orderItem);
        orderItem.setOrder(this);
    }

    public Member getMember() {
        return member;
    }

    public void setMember(Member member) {
        this.member = member;
    }

    // 이게 객체지향적인 코드
//    Private Member member
//    public Private getMember() {
//        return Member;
//    }

    private LocalDateTime orderDate;

    @Enumerated(EnumType.STRING)
    private OrderStatus status;



    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

//    public Long getMemberId() {
//        return memberId;
//    }
//
//    public void setMemberId(Long memberId) {
//        this.memberId = memberId;
//    }

    public LocalDateTime getOrderDate() {
        return orderDate;
    }

    public void setOrderDate(LocalDateTime orderDate) {
        this.orderDate = orderDate;
    }

    public OrderStatus getStatus() {
        return status;
    }

    public void setStatus(OrderStatus status) {
        this.status = status;
    }
}

Item.java

package jpabook.jpashop.domain;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Item {

    @Id @GeneratedValue
    @Column(name = "ITEM_ID")
    private Long id;
    private String name;
    private int price;
    private int stockQuantity;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public int getStockQuantity() {
        return stockQuantity;
    }

    public void setStockQuantity(int stockQuantity) {
        this.stockQuantity = stockQuantity;
    }
}

OrderItem.java

package jpabook.jpashop.domain;

import javax.persistence.*;

@Entity
public class OrderItem {

    @Id @GeneratedValue
    @Column(name = "ORDER_ITEM_ID")
    private Long id;
//    @Column(name = "ORDER_ID")
//    private Long orderId;

//    @Column(name = "ITEM_ID")
//    private Long itemid;
    @ManyToOne
    @Column(name = "ORDER_ID")
    private Order order;

    @ManyToOne
    @Column(name = "ITEM_ID")
    private Item Item;

    private Long orderPrice;
    private int count;

    public Long getId() {
        return id;
    }

    public Order getOrder() {
        return order;
    }

    public void setOrder(Order order) {
        this.order = order;
    }

    public void setId(Long id) {
        this.id = id;
    }

//    public Long getOrderId() {
//        return orderId;
//    }
//
//    public void setOrderId(Long orderId) {
//        this.orderId = orderId;
//    }
//
//    public Long getItemid() {
//        return itemid;
//    }
//
//    public void setItemid(Long itemid) {
//        this.itemid = itemid;
//    }

    public Long getOrderPrice() {
        return orderPrice;
    }

    public void setOrderPrice(Long orderPrice) {
        this.orderPrice = orderPrice;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
}

JpaMain.java

package jpabook.jpashop;

import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderItem;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

public class JpaMain {
    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");
        EntityManager em = emf.createEntityManager();

        EntityTransaction tx = em.getTransaction();

        tx.begin();
        try {
            Order order = new Order();
            em.persist(order);

            // 방법 1 : 양방향 연관관계 매핑(JPQL에서 중요)
//            order.addOrderItem(new OrderItem());

            // 방법 2 : 단방향으로 처리해도 아무문제 x
            OrderItem orderItem = new OrderItem();
            orderItem.setOrder(order);

            em.persist(orderItem);

            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }

        emf.close();
}
}

핵심은 단방향으로 설계를 잘 하는게 중요하다.

[자바 ORM 표준 JPA 프로그래밍] [섹션 4] 엔티티 매핑

c0mmedes — Thu, 13 Jul 2023 23:23:41 +0900

1. 객체와 테이블 매핑

객체와 테이블 매핑: @Entity, @Table

@Entity

@Entity가 붙은 클래스는 JPA가 관리
JPA를 사용해서 테이블과 매핑할 클래스는 @Entity 필수
기본 생성자 필수(파라미터가 없는 public 또는 protected 생성자)
final, enum, interface, inner 클래스 사용X

@Entity
@Table(name = "MBR")// MBR이라는 테이블과 매핑 -> INSERT INTO MBR ~public class Member {

2. 데이터베이스 스키마 자동 생성

DDL(CREATE, ALTER, DROP)을 애플리케이션 실행 시점에 자동 생성
테이블 중심 -> 객체 중심
데이터베이스 방언을 활용해서 데이터베이스에 맞는 적절한 DDL 생성
이렇게 생성된 DDL은 개발 장비에서만 사용
생성된 DDL은 운영서버에서는 사용하지 않거나, 적절히 다듬은 후 사용

속성

persistence.xml

<property name="hibernate.hbm2ddl.auto" value="create" />

create - 기존 테이블 삭제 후 다시 생성(DROP + CREATE)
create-drop - create와 같으나 종료시점에 테이블 DROP
update - 변경분만 반영(운영DB에는 사용하면 안됨)
validate - 엔티티와 테이블이 정상 매핑되었는지만 확인
none - 사용하지 않음

주의

운영 장비에는 절대 create, create-drop, update 사용 x
개발 초기 단계는 create 또는 update
테스트 서버는 update 또는 validate (여러명이서 개발하는 환경)
스테이징과 운영 서버는 validate 또는 none

DDL 생성 기능

Member.java

 @Column(unique = true, length = 10)
    private String name;

제약조건 추가
DDL 생성 기능은 DDL을 자동 생성할 때만 사용되고 JPA의 실행 로직에는 영향을 주지 않는다.

3. 필드와 컬럼 매핑

필드와 컬럼 매핑: @Column

매핑 어노테이션 정리

hibernate.hbm2ddl.auto

@Column - 컬럼 매핑
- name - 필드와 매핑할 테이블의 컬럼 이름 (기본값 - 객체의 필드 이름)
- insertable, updatable - 등록, 변경 가능 여부 (기본값 - TRUE)
- nullable(DDL) - null 값의 허용 여부를 설정한다. false로 설정하면 DDL 생성 시에 not null 제약조건이 붙는다.
- unique(DDL) - @Table uniqueConstraints와 같지만 한 컬럼에 간단히 유니크 제약조건을 걸 때 사용한다. (키값이 이상하게 부여돼서 자주 사용하지 않고 @Table 속성에서 주로 씀)
- columnDefinition(DDL) - 데이터베이스 컬럼 정보를 직접 줄 수 있다. ex) varchar(100) default ‘EMPTY'
- length(DDL) - 문자 길이 제약조건, String 타입에만 사용한다. (기본값 - 255)
- precision, scale(DDL) - BigDecimal 타입에서 사용한다(BigInteger도 사용할 수 있다). precision은 소수점을 포함한 전체 자 릿수를, scale은 소수의 자릿수다. 참고로 double, float 타입에는 적용되지 않는다. 아주 큰 숫자나 정밀한 소수를 다루어야 할 때만 사용한다. (기본값 - precision=19, scale=2)
@Temporal - 날짜 타입 매핑
- TemporalType.DATE: 날짜, 데이터베이스 date 타입과 매핑 (예: 2013–10–11)
- TemporalType.TIME: 시간, 데이터베이스 time 타입과 매핑 (예: 11:11:11)
- TemporalType.TIMESTAMP: 날짜와 시간, 데이터베이 스 timestamp 타입과 매핑(예: 2013–10–11 11:11:11)
- 참고: LocalDate, LocalDateTime을 사용할 때는 생략 가능(최신 하이버네이트 지원)
@Enumerated - enum 타입 매핑
- EnumType.ORDINAL(기본값): enum 순서를 데이터베이스에 저장
- EnumType.STRING: enum 이름을 데이터베이스에 저장
- ORDINAL 사용X → 순서로 갱신하기 때문에 새로운 값이 추가되면 그게 다시 0이돼서
@Lob - BLOB, CLOB 매핑
- @Lob에는 지정할 수 있는 속성이 없다.
- 매핑하는 필드 타입이 문자면 CLOB 매핑, 나머지는 BLOB 매핑 • CLOB: String, char[], java.sql.CLOB • BLOB: byte[], java.sql. BLOB
@Transient - 특정 필드를 컬럼에 매핑하지 않음(매핑 무시), DB에서는 사용하지 않게(메모리에만 사용할 수 있게)

4. 기본 키 매핑

기본 키 매핑
- 자동 생성 - @GeneratedValue
  - IDENTITY: 데이터베이스에 위임, MYSQL
    - 기본 키 생성을 데이터베이스에 위임
    - 주로 MySQL, PostgreSQL, SQL Server, DB2에서 사용 (예: MySQL의 AUTO_ INCREMENT)
    - JPA는 보통 트랜잭션 커밋 시점에 INSERT SQL 실행
    - AUTO_ INCREMENT는 데이터베이스에 INSERT SQL을 실행한 이후에 ID 값을 알 수 있음
    - IDENTITY 전략은 em.persist() 시점에 즉시 INSERT SQL 실행하고 DB에서 식별자를 조회
```
@Entity
public class Member {
 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY)
 private Long id;
```
  - SEQUENCE: 데이터베이스 시퀀스 오브젝트 사용, ORACLE @SequenceGenerator 필요
    - 데이터베이스 시퀀스는 유일한 값을 순서대로 생성하는 특별한 데이터베이스 오브젝트(예: 오라클 시퀀스)
    - 오라클, PostgreSQL, DB2, H2 데이터베이스에서 사용
```
@Entity
@SequenceGenerator(
 name = “MEMBER_SEQ_GENERATOR",
 sequenceName = “MEMBER_SEQ", //매핑할 데이터베이스 시퀀스 이름
 initialValue = 1, allocationSize = 1)
public class Member {
 @Id
 @GeneratedValue(strategy = GenerationType.SEQUENCE,
 generator = "MEMBER_SEQ_GENERATOR")
 private Long id;
```
  - TABLE: 키 생성용 테이블 사용, 모든 DB에서 사용
    - @TableGenerator 필요
    - 키 생성 전용 테이블을 하나 만들어서 데이터베이스 시퀀스를 흉내내는 전략
    - 장점: 모든 데이터베이스에 적용 가능
    - 단점: 성능
    - 비주류
```
@Entity
@TableGenerator(
 name = "MEMBER_SEQ_GENERATOR",
 table = "MY_SEQUENCES",
 pkColumnValue = “MEMBER_SEQ", allocationSize = 1)
public class Member {
 @Id
 @GeneratedValue(strategy = GenerationType.TABLE,
 generator = "MEMBER_SEQ_GENERATOR")
 private Long id;
```
```
create table MY_SEQUENCES (
 sequence_name varchar(255) not null,
 next_val bigint,
 primary key ( sequence_name )
)
```
  - AUTO: 방언에 따라 자동 지정, 기본값
- 직접 할당 - @Id
연관관계 매핑: @ManyToOne, @JoinColumn

권장하는 식별자 전략

기본 키 제약 조건: null 아님, 유일, 변하면 안된다.
미래까지 이 조건을 만족하는 자연키는 찾기 어렵다. 대리키(대 체키)를 사용하자.
예를 들어 주민등록번호도 기본 키로 적절하지 않다.
권장: Long형 + 대체키 + 키 생성전략 사용

5. 실전 예제 -1. 요구사항 분석과 기본 매핑

요구사항 분석

회원은 상품을 주문할 수 있다.
주문 시 여러 종류의 상품을 선택할 수 있다.

기능 목록

회원 기능
- 회원등록
- 회원조회
상품 기능
- 상품등록
- 상품수정
- 상품조회
주문 기능
- 상품주문
- 주문내역조회
- 주문취소

도메인 모델 분석

회원과 주문의 관계: 회원은 여러 번 주문할 수 있다. (일대다)
주문과 상품의 관계: 주문할 때 여러 상품을 선택할 수 있다. 반대로 같은 상품도 여러 번 주문될 수 있다. 주문상품 이라는 모델을 만들어서 다대다 관계를 일다대, 다대일 관계로 풀어냄

테이블 설계

엔티티 설계와 매핑

데이터 중심 설계의 문제점

현재 방식은 객체 설계를 테이블 설계에 맞춘 방식
테이블의 외래키를 객체에 그대로 가져옴
객체 그래프 탐색이 불가능
참조가 없으므로 UML도 잘못됨

package jpabook.jpashop.domain;

import javax.persistence.*;
import java.time.LocalDateTime;

@Entity
@Table(name = "ORDERS") // db의 예약어가 order인 경우가 있어서
public class Order {

    @Id @GeneratedValue
    @Column(name = "ORDER_ID")
    private Long id;

    // 주문자명
    // 관계형DB를 객체에 만든 설계
    @Column(name = "MEMBER_ID")
    private Long memberId;

    // 이게 객체지향적인 코드
//    Private Member member
//    public Private getMember() {
//        return Member;
//    }

    private LocalDateTime orderDate;

    @Enumerated(EnumType.STRING)
    private OrderStatus status;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Long getMemberId() {
        return memberId;
    }

    public void setMemberId(Long memberId) {
        this.memberId = memberId;
    }

    public LocalDateTime getOrderDate() {
        return orderDate;
    }

    public void setOrderDate(LocalDateTime orderDate) {
        this.orderDate = orderDate;
    }

    public OrderStatus getStatus() {
        return status;
    }

    public void setStatus(OrderStatus status) {
        this.status = status;
    }
}