에스알닷컴

JPA 영속성 컨텍스트의 특징

• SpringBoot를 하면서 JPA의 개념적으로 모르고 사용했었기에 정리

영속성 컨텍스트와 식별자 값

• 영속성 컨텍스트는 엔티티를 식별자 값(@Id로 테이블의 기본 키와 매핑한 값)으로 구분한다.
• 영속 상태는 식별자 값이 반드시 있어야 한다.
• 식별자 값이 없으면 예외가 발생한다.

영속성 컨텍스트와 데이터베이스 저장

• 트랜잭션을 커밋하는 순간 영속성 컨텍스트에 새로 저장된 엔티티를 데이터베이스에 반영(동기화)한다.(플러시: Flush)

영속성 컨텍스트가 엔티티를 관리할 때 장점

• 1차 캐시
• 동일성 보장
• 트랜잭션을 지원하는 쓰기 지연
• 변경 감지(Dirty Checking)
• 지연 로딩(Lazy Loading)

엔티티 조회

엔티티 등록

엔티티 수정

엔티티 삭제

SpringBoot 공부 중에 @Builder 패턴에 대한 이해가 필요하여 @Builder 어노테이션설정으로 인하여 어떻게 동작 하는지 알아보기 위하여 정리

1. Java Builder Pattern

@Builder

public class Response {

    private Long id;
    private String name;

    public Response(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public static ResponseBuilder builder() {
        return new ResponseBuilder();
    }

    public static class ResponseBuilder {
        private Long id;
        private String name;

        ResponseBuilder() {}

        public ResponseBuilder id(Long id) {
            this.id = id;
            return this;
        }

        public ResponseBuilder name(String name) {
            this.name = name;
            return this;
        }

        public Response build() {
            return new Response(id, name);
        }

        @Override
        public String toString() {
            return "ResponseBuilder{" + "id=" + id + ", name='" + name + '\'' +  '}';
        }
    }
}

2. @Builder

• 빌더패턴을 이용했을 때 가장 큰 장점은 멤버변수의 optional과 required를 컴파일하는 시점에서 체크할 수 있다는 점
• 특정 멤버변수에 접근하기 위한 메서드가 정해져 있기 때문에 실수로 다른 멤버변수에 다른 값을 집어넣는 실수를 막을 수 있다.

@Builder
public class Response {

    private Long id;
    private String name;

    public Response(Long id, String name) {
        this.id = id;
        this.name = name;
    }
}

3. Builder를 활용하기

import static java.lang.Thread.sleep;

public class ThreadBuilderTest {

    public static void main(String[] args) {

        ThreadOuter th = new ThreadOuter();
        th.start();
        ThreadOuter01 th01 = new ThreadOuter01();
        th01.start();

        for(int i = 11 ; i < 20 ; i++) {
            Response res = Response.builder()
                    .id(Long.valueOf(i))
                    .name("thread" + i)
                    .build();
            System.out.println(res.toString() + " :: " + Thread.currentThread().getName());
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class ThreadOuter extends Thread {

    @Override
    public void run() {
        for(int i = 0 ; i < 10 ; i++) {
            Response res = Response.builder()
                    .id((long) i)
                    .name("thread01" + i)
                    .build();
            System.out.println(res.toString() + " :: " + getName());
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class ThreadOuter01 extends Thread {

    @Override
    public void run() {
        for(int i = 21 ; i < 30 ; i++) {
            Response res = Response.builder()
                    .id((long) i)
                    .name("thread02" + i)
                    .build();
            System.out.println(res.toString() + " :: " + getName());
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

어노테이션 설명

• 매핑 정보가 상속되는 엔티티에 적용되는 클래스를 지정
• 매핑된 상위클래스는 별도의 테이블이 없다.
• @MappedSuperclass가 지정된 클래스는 Entity와 동일한 방법으로 매핑될 수 있다.
• 매핑은 테이블이 없으므로 하위 클래스에만 적용된다.
• 슈퍼클래스에 적용되었을 떄, 상속받은 클래스에 상위클래스 테이블의 context를 적용할 수 있다.
• AttributeOverride 및 AssociationOverride 어노테이션 또는 해당 XML elements를 사용하여 이러한 하위 클래스에 하여 재정의 할 수 있다.

어노테이션 용도

• Entity별 공통 요소를 상속 필요성
• @MappedSuperclass를 이용하여 공통요소를 Super Class에 정의
• 간소화된 Entity
• 공통 컬럼명을 override가 필요한 경우 @AttributeOverride로 재정의

예시 코드

@MappedSuperclass
public class Employee {
    @Id
    protected Integer empId;
    @Version
    protected Integer version;
    @ManyToOne
    @JoinColumn(name = "ADDR")
    protected Address address;

    public Integer getEmpId() { ... }

    public void setEmpId(Integer id) { ... }

    public Address getAddress() { ... }

    public void setAddress(Address addr) { ... }
}

// Default table is FTEMPLOYEE table
@Entity
public class FTEmployee extends Employee {

    // Inherited empId field mapped to FTEMPLOYEE.EMPID
    // Inherited version field mapped to FTEMPLOYEE.VERSION
    // Inherited address field mapped to FTEMPLOYEE.ADDR fk

    // Defaults to FTEMPLOYEE.SALARY
    protected Integer salary;

    public FTEmployee() {
    }

    public Integer getSalary() { ... }

    public void setSalary(Integer salary) { ... }
}

- @AssociationOverride 어노테이션을 통해 address 속성을 ADDR_ID를 조인컬럼으로 사용

@Entity
@Table(name = "PT_EMP")
@AssociationOverride(name = "address", joincolumns = @JoinColumn(name = "ADDR_ID"))
public class PartTimeEmployee extends Employee {

    // Inherited empId field mapped to PT_EMP.EMPID
    // Inherited version field mapped to PT_EMP.VERSION
    // address field mapping overridden to PT_EMP.ADDR_ID fk
    @Column(name = "WAGE")
    protected Float hourlyWage;

    public PartTimeEmployee() {
    }

    public Float getHourlyWage() { ... }

    public void setHourlyWage(Float wage) { ... }
}

1. 엔티티 연관

• 시스템 개발에서 사용되는 구성요소들은 서로 연관을 가진다.

연관관계 매핑 키워드

• 방향
  • 단방향, 양방향이 있다.
  • 사원 -> 회사 또는 회사 -> 사원과 같이 한 쪽만 참조하는 것을 단방향 관계라고 한다.
  • 사원 -> 회사, 회사 -> 사원과 같이 서로 참조하는 것을 양방향 관계라고 한다.
  • 방향은 객체 관계에서만 존재하고 테이블 관계는 항상 양방향이다.
• 다중성(Multiplicity)
  • 다대일(N:1), 일대다(1:N), 일대일(1:1), 다대다(N:M)가 있다.
  • 여러 사원은 하나의 회사에 속하므로 사원과 회사는 다대일 관계이다.
  • 하나의 회사는 여러 사원이 소속될 수 있으므로 회사와 사원은 일대다 관계이다.
  • 하나의 회원은 하나의 회원상세 정보만을 가질 수 있으므로 회원과 회원상세는 일대일 관계이다.
  • 하나의 고객은 여러 상품을 구매할 수 있고, 하나의 상품은 여러 고객에게 판매될 수 있으므로 다대다 관계이다.
• 연관관계의 주인(Owner)
  • 엔티티를 양방향 연관관계로 설정하면 객체 관계의 참조는 둘인데 테이블 외래 키는 하나이다.
  • 양방향 연관관계를 매핑할 때 두 연관관계 중 하나를 연관관계의 주인으로 정해야 한다.
  • 연관관계의 주인은 외래 키를 관리(등록, 수정, 삭제) 할 수 있고 주인이 아닌 쪽은 읽기만 할 수 있다.
  • 연관관계의 주인을 정할 때 mappedBy 속성을 사용하는데 mappedBy 속성을 사용하지 않은 쪽이 주인이 된다.

연관관계 어노테이션

• @JoinColumn
  • @JoinColumn은 외래키를 매핑할 때 사용, 생략 가능

• @ManyToOne
  • @ManyToOne은 다대일 관계에서 사용한다. 다중성을 나타내는 어노테이션은 필수

• @OneToMany
  • @OneToMany은 일대다 관계에서 사용한다.

• @ManyToMany
  • @ManyToMany 다대다 관계에서 사용한다.

• @JoinTable
  • @JoinTable은 다대다 관계를 일대다, 다대일 관계로 풀어내기 위해 필요한 연결 테이블을 매핑할 때 사용한다.

2. 일대다 단방향

• @OneToMany 어노테이션을 사용하여 일대다 단방향 연관을 설정할 수 있다.

연관관계

• 관계 정의

  • 상위 클래스는 여러 하위 클래스를 가질 수 있다.
  • 상위 클래스와 하위 클래스는 일대다 관계이다.

• 객체 연관관계

  • 상위 객체는 List<하위객체> 컬렉션 필드로 하위객체와 연관관계를 맺는다.
  • 상위 객체와 하위 객체는 단방향 관계이다.
  • 상위 객체는 하위 객체에 접근할 수 있는 필드를 갖고 있지만 반대로 하위객체는 상위 객체에 접근할 수 없다.

• 테이블 연관관계

  • 하위객체의 테이블은 상위객체에 접근할 수 있는 필드 값으로 상위객체 테이블과 연관관계를 맺는다.
  • 하위객체 테이블에서 상위 객체에 접근할 수 있는 필드 값을 통해 하위 객체와 상위 객체를 조인할 수 있고 반대로 상위 객체와 하위객체를 조인할 수있다.

• 연관관계 매핑

  • @OneToMany: 상위객체와 하위 객체는 일대다 관계이다.
  • @JoinColumn(name = "외래키"): name 속성에는 매핑할 외래 키 이름을 지정한다.

• 연관관계 구현

@OneToMany(cascade = CascadeType.ALL)
@JoinColumn(name = "상위객체의 pk 필드")
private List<하위객체> 하위객체List;

3. 다대일 단방향

• @ManyToOne 어노테이션을 사용하여 다대일 단방향 연관을 설정할 수 있다.

연관관계

• 관계정의

  • 여러 하위객체는 하나의 상위객체에 속할 수 있다.
  • 하위객체와 상위객체는 다대일 관계이다.

• 객체 연관관계

  • 하위객체는 상위객체에 접근할 수 있는 참조 키 필드로 상위객체와 연관관계를 맺는다.
  • 하위객체와 상위객체는 단방향 관계이다.
  • 하위객체는 참조키 필드를 통해 상위객체를 알 수 있지만 반대로 상위 객체는 하위객체를 알 수 없다.

• 테이블 연관관계

  • 하위객체 테이블은 외래키로 상위객체 테이블과 연관관계를 맺는다.
  • 하위객체 테이블은 외래키를 통해 상위객체와 하위객체를 조인할 수 있고, 반대로 상위객체와 하위객체를 조인할 수 있다.

• 연관관계 매핑

  • @ManyToOne: 코드상세와 코드그룹은 다대일 관계이다.
  • @JoinColumn(name = "외래키"): name 속성에는 매핑할 외래 키 이름을 지정한다.

• 연관관계 구현

  • 하위객체 -> 상위객체 다대일 연관

@ManyToOne
@JoinColumn(name = "외래키")
private 상위객체 상위객체;

4. 다대일 양방향

• @OneToMany와 @ManyToOne 어노테이션을 사용하여 다대일 양방향 연관을 설정할 수 있다.

연관관계

• 관계정의

  • 상위객체는 여러 코드 상세를 가질 수 있다.
  • 여러 하위객체는 하나의 상위객체에 속할 수 있다.
  • 상위객체와 하위객체는 일대다 관계이다.
  • 하위객체와 상위객체는 다대일 관계이다.

• 객체 연관관계

  • 하위객체는 외래키 필드로 상위객체와 연관관계를 맺는다.
  • 상위객체는 List<하위객체> 컬렉션 필드로 상위객체와 연관관계를 맺는다.
  • 하위객체와 상위객체는 양방향 관계이다.
  • 하위객체는 외래키필드를 통해서 상위객체에 접근할 수 있고 반대로 상위객체는 하위객체 필드를 통해서 하위객체에 접근할 수 있다.

• 테이블 연관관계

  • 하위객체 테이블은 외래키로 상위객체 테이블과 연관관계를 맺는다.
  • 하위객체 테이블은 외래키를 통해서 하위객체와 상위객체를 조인할 수 있고, 반대로 상위객체와 하위객체를 조인할 수 있다.

• 연관관계 매핑

  • @ManyToOne: 코드상세와 코드그룹은 다대일 관계이다.
  • @OneToMany(mappedBy = "상위객체 PK 필드") 상위객체와 하위객체는 일대다 관계이다.
    • mappedBy 속성은 양방향 매핑일 때 사용하는데 반대쪽 매핑의 필드 이름을 값으로 주면 된다.
    • 하위객체 테이블이 외래 키를 가지고 있으므로 SubClass.SuperClass가 주인이 된다.
    • 주인이 아닌 SuperClass.subClass에는 mappedBy = "superClass" 속성을 사용해서 주인이 아님을 설정한다.
  • @JoinColumn(name = "외래키"): name 속성에는 매핑할 외래 키 이름을 지정한다.

• 연관관계 구현

1. 하위객체 -> 상위객체 다대일 연관

@ManyToOne
@JoinColumn(name = "외래키")
private 상위객체 상위객체;

2. 상위객체 -> 하위객체 일대다 연관

@OneToMany(mappedBy = "상위객체의 PK필드", casecade = CasecadeType.ALL, fetch = FetchType.LAZY)
private List<하위객체> 하위객체List;

3. 연관관계 편의 메서드

public class SuperClass {
    public void addSubClass(SubClass subClass) {
        subClass.setSuperClass(this);
        this.subClass.add(subClass);
    }
}

• 주종관계란?

5. 일대일 단방향

• 하나의 회원은 하나의 회원상세를 갖는다.
• 회원상세 클래스에서 @OneToOne 어노테이션과 @JoinColumn 어노테이션을 사용하여 일대일 단방향 연관을 설정할 수 있다.

연관관계

• 관계 정의
  • 하나의 회원상세는 하나의 회원에 속할 수 있다.
  • 회원상세와 회원은 일대일 관계이다.
• 객체 연관관계
  • 회원상세 객체는 member 필드로 회원 객체와 연관관계를 맺는다.
  • 회원상세 객체와 회원 객체는 단방향 관계이다.
  • 회원상세는 member 필드를 통해서 회원을 알 수 있지만 반대로 회원은 회원상세를 알 수 없다.
• 테이블 연관관계
  • 회원상세 테이블은 user_no 외래 키로 회원 테이블과 연관관계를 맺는다.
  • 회원상세 테이블의 user_no 외래 키를 통해서 회원상세와 회원을 조인할 수 있고, 반대로 회원과 회원상세를 조인할 수 있다.
• 연관관계 매핑
  • @OneToOne: 회원상세와 회원은 일대일 관계이다.
  • @JoinColumn(name = "user_no"): name 속성에는 매핑할 외래 키 이름을 지정한다.
• 연관관계 구현

@OneToOne
@JoinColumn(name = "user_no")
private Member member;

6. 일대일 단방향

• 하나의 회원은 하나의 회원상세를 갖는다.
• 회원 클래스에서 @OneToOne 어노테이션과 @JoinColumn 어노테이션을 사용하여 일대일 단방향 연관을 설정할 수 있다.

연관관계

• 관계 정의
  • 하나의 회원은 하나의 회원상세를 가질 수 있다.
  • 회원과 회원상세는 일대일 관계이다.
• 객체 연관관계
  • 회원 객체는 memberDetail 필드로 회원상세 객체와 연관관계를 맺는다.
  • 회원 객체와 회원상세 객체는 단방향 관계이다.
  • 회원은 memberDetail 필드를 통해서 회원상세에 접근할 수 있지만 반대로 회원상세는 회원에 접근할수 없다.
• 테이블 연관관계
  • 회원상세 테이블은 user_no 외래 키로 회원 테이블과 연관관계를 맺는다.
  • 회원상세 테이블의 user_no 외래 키를 통해서 회원상세와 회원을 조인할 수 있고, 반대로 회원과 회원상세를 조인할 수 있다.
• 연관관계 매핑
  • @OneToOne: 회원관 회원상세는 일대일 관계이다.
  • @JoinColumn(name = "user_no"): name 속성에는 매핑할 외래 키 이름을 지정한다.
• 연관관계 구현

@OneToOne(casecade = CasecadeType.ALL)
@JoinColumn(name = "user_no")
private MemberDetail memberDetail;

7. 일대일 양방향

• 하나의 회원은 하나의 회원상세를 갖는다.
• 회원 클래스와 회원상세 클래스에서 @OneToOne 어노테이션을 사용하여 일대일 양방향 연관을 설정할 수 있다.

연관관계

• 관계정의
  • 회원은 여러 회원상세를 가질 수 있다.
  • 여러 회원상세는 하나의 회원에 속할 수 있다.
  • 회원과 회원상세는 일대일 관계이다.
  • 회원상세와 회원은 일대일 관계이다.
• 객체 연관관계
  • 회원상세 객체는 member 필드로 회원 객체와 연관관계를 맺는다.
  • 회원 객체는 memberDetail 필드로 회원상세 객체와 연관관계를 맺는다.
  • 회원상세 객체와 회원 객체는 양방향 관계이다.
  • 회원상세는 member 필드를 통해서 회원에 접근할 수 있고, 반대로 회원은 memberDetail 필드를 통해서 회원상세에 접근할 수 있다.
• 테이블 연관관계
  • 회원상세 테이블은 user_no 외래 키로 회원 테이블과 연관관계를 맺는다.
  • 회원상세 테이블의 user_no 외래 키를 통해서 회원상세와 회원을 조인할 수 있고, 반대로 회원과 회원상세를 조인할 수 있다.
• 연관관계 매핑
  • @OneToOne: 회원상세와 회원은 일대일 관계이다.
  • @OneToOne:(mappedBy = "member") 회원과 회원상세는 일대일 관계이다.
    • mappedBy 속성은 양방향 매핑일 때 사용하는 데 반대쪽 매핑의 필드 이름을 값으로 주면된다.
    • 회원상세 테이블이 외래 키를 가지고 있으므로 MemberDetail.member가 주인이 된다.
    • 주인이 아닌 Member.memberDetail에는 meppedBy="member" 속성을 사용해서 주인이 아님을 설정한다.
    • @JoinColumn(name = "user_no"): name 속성에는 매핑할 외래 키 이름을 지정한다.
• 연관관계 구현

1. MemberDetail -> Member 일대일 연관

@OneToOne
@JoinColumn(name = "user_no")
private Member member;

2. Member -> MemberDetail 일대일 연관

@OneToOne(mappedBy = "member", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private MemberDetail memberDetail;

8. 다대다 단방향

• 한 명의 회원은 여러 상품을 구입할 수 있고 하나의 상품은 여러 명의 회원에 팔릴 수 있다.
• 회원 클래스에서 @ManyToMany 어노테이션을 사용하여 다대다 단방향 연관을 설정할 수 있다.

연관관계

• 관계 정의

  • 하나의 회원은 여러 상품을 구매할 수 있다.
  • 하나의 상품은 여러 명의 회원에 팔릴 수 있다.
  • 회원과 상품은 다대다 관계이다.

• 객체 연관관계

  • 회원 객체는 List itemList 컬렉션 필드로 상품 객체와 연관관계를 맺는다.
    • 회원 객체와 상품 객체는 단방향 관계이다.
  • 회원은 items 필드를 통해서 상품에 접근할 수 있지만 반대로 상품은 회원에 접근할 수 없다.

• 테이블 연관관계

  • 회원 테이블과 상품 테이블과 외래키로 연관관계를 가지는 회원상품 테이블이 생성된다.
  • 회원 테이블은 user_no 외래 키로 회원상품 테이블과 연관관계를 맺는다.
  • 상품 테이블은 item_no 외래 키로 회원상품 테이블과 연관관계를 맺는다.
    • 회원 테이블은 user_no 외래 키를 통해서 회원과 회원상품을 조인할 수 있다.
  • 상품 테이블은 item_no 외래 키를 통해서 상품과 회원상품을 조인할 수 있다.

• 연관관계 매핑

  • @ManyToMany: 회원과 상품은 다대다 관계이다.
    • @JoinTable.name: 연결 테이블을 지정
    • @JoinTable.joinColumns: 순 방향 엔티티와 매핑할 조인 컬럼 정보를 지정한다.
  • @JoinTable.inverseJoinColumns: 역 방향 엔티티와 매핑할 조인 컬럼 정보를 지정한다.

• 연관관계 구현

@ManyToMany
@JoinTable(
    name = "user_item",
    joinColumns = @JoinColumn(name = "user_no"),
    inverseJoinColumns = @JoinColumn(name = "item_no"))
private List<Item> items = new ArrayList<>();

9. 다대다 양방향

• 한 명의 회원은 여러 개의 상품을 구입할 수 있고, 하나의 상품은 여러 명의 회원에 팔릴 수 있다.
• 회원 클래스와 상품 클래스에서 @ManyToMany 어노테이션을 사용하여 다대다 양방향 연관을 설정할 수 있다.

연관관계

• 관계 정의

  • 회원은 여러 상품을 구매할 수 있다.
  • 여러 상품은 하나의 회원에 판매될 수 있다.
  • 회원과 상품은 다대다 관계이다.

• 객체 연관관계

  • 상품 객체는 List members 필드로 회원 객체와 연관관계를 맺는다.
  • 회원 객체는 List items 필드로 상품 객체와 연관관계를 맺는다.
  • 상품 객체와 회원 객체는 양방향 관계이다.
  • 상품은 members 필드를 통해서 회원에 접근할 수 있고, 반대로 회원은 items 필드를 통해서 상품에 접근할 수 있다.

• 테이블 연관관계

  • 회원 테이블과 상품 테이블과 외래키로 연관관계를 가지는 회원상품 테이블이 생성된다.
  • 회원 테이블은 user_no 외래 키로 회원상품 테이블과 연관관계를 맺는다.
  • 상품 테이블은 item_no 외래 키로 회원상품 테이블과 연관관계를 맺는다.
  • 회원 테이블은 user_no 외래 키를 통해서 회원과 회원상품을 조인할 수 있다.
  • 상품 테이블의 item_no 외래 키를 통해서 상품과 회원상품을 조인할 수 있다.

• 연관관계 매핑

  • @ManyToMany: 회원과 상품은 다대다 관계이다.
  • @JoinTable.name: 연결 테이블을 지정한다.
  • @JoinTable.joinColumns: 순 방향 엔티티와 매핑할 조인 컬럼 정보를 지정한다.
  • @JoinTable.inverseJoinColumns: 역 방향 엔티티와 매핑할 조인 컬럼 정보를 지정한다.
  • @ManyToMany(mappedBy = "items"): 주인이 아닌 item.members 에는 mappedBy = "items" 속성을 사용해서 주인이 아님을 설정한다.

• 연관관계 구현

1. Member -> Item 다대다 연관

@ManyToMany
@JoinTable(name = "user_item",
    joinColumns = @JoinColumn(name = "user_no"),
    inverseJoinColumns = @JoinColumn(name = "item_no"))
private List<Item> items = new ArrayList<>();

2. Item -> Member 다대다 연관

@ManyToMany(mappedBy = "items")
private List<Member> members = new ArrayList<>();

10. 다대다 연결 엔티티

• 한 명의 회원은 여러 개의 상품을 구입할 수 있고, 하나의 상품은 여러 명의 회원에 팔릴 수 있다.
• 회원 상품 연결 엔티티 클래스를 추가하여 회원 클래스와 상품 클래스의 다대다 연관을 해소할 수 있다.

연관관계

• 관계 정의

  • 회원은 여러 회원상품을 가질 수 있다.
  • 여러 회원상품은 하나의 회원에 속할 수 있다.
  • 회원과 회원상품은 일대다 관계이다.
  • 회원상품과 회원은 다대일 관계이다.
  • 상품은 여러 회원상품에 포함될 수 있다.
  • 여러 회원상품은 하나의 상품에 속할 수 있다.
  • 상품과 회원상품은 일대다 관계이다.
  • 회원상품과 상품은 다대일 관계이다.

• 객체 연관관계

  • 회원상품 객체는 member 필드로 회원 객체와 연관관계를 맺는다.
  • 회원 객체는 List userItems 컬렉션 필드로 회원상품 객체와 연관관계를 맺는다.
    • 회원상품 객체와 회원 객체는 양방향 관계이다.
    • 회원상품은 member 필드를 통해서 회원에 접근할 수 있고, 반대로 회원은 userItems 필드를 통해서 회원상품에 접근할 수 있다.
    • 회원상품 객체는 Item 필드로 상품 객체와 연관관계를 맺는다.
    • 회원상품은 item 필드를 통해서 상품에 접근할 수 있고, 반대로 상품은 회원상품에 접근할 수 있다.

• 테이블 연관관계

  • 회원상품 테이블은 user_no 외래 키로 회원 테이블과 연관관계를 맺는다.
  • 회원상품 테이블은 item_no 외래 키로 상품 테이블과 연관관계를 맺는다.
  • 회원상품 테이블의 user_no 외래 키를 통해서 회원상품과 회원을 조인할 수 있고, 반대로 회원과 회원상품을 조인할 수 있다.
  • 회원상품 테이블의 item_no 외래 키를 통해서 회원상품과 상품을 조인할 수 있고, 반대로 상품과 회원상품을 조인할 수 있다.

• 연관관계 매핑

- @ManyToOne: 회원상품과 회원은 다대일 관계이다.
- @JoinColumn(name = "user_no"): name 속성에는 매핑할 외래 키를 지정한다.
- @OneToMany(mappedBy = "member"): 회원과 회원상품은 일대다 관계이다.
    - mappedBy 속성은 양방향 매핑일 때 사용하는데 반대쪽 매핑의 필드 이름을 값으로 주면된다.
    - 회원상품 테이블이 외래 키를 가지고 있으므로 UserItem.member가 주인이 된다.
    - 주인이 아닌 Member.userItems에는 mappedBy = "member" 속성을 사용해서 주인이 아님을 설정한다.
-   @ManyToOne: 회원상품과 상품은 다대일 관계이다.
    -   @JoinColumn(name = "item\_no"): name 속성에는 매핑할 외래 키 이름을 지정한다.

• 연관관계 구현

1. UserItem -> Member 다대일 연관

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

2. Member -> UserItem 다대일 연관

@OneToMany(mappedBy = "member", cascade = CascadeType.ALL)
private List<UserItem> userItems = new ArrayList<>();

3. UserItem -> Item 다대일 연관

@ManyToOne
@JoinColumn(name = "item_no")
private Item item;

JPA 요소

• 엔티티(Entity)
  • 데이터베이스에서 지속적으로 저장된 데이터를 자바 객체에 매핑한 것
  • 메모리 상에 자바 객체의 인스턴스 형태로 존재하며 EntityManager에 의해 데이터베이스의 데이터와 동기화된다.
• 엔티티 매니저(Entity Manager)
  • 필요에 따라 Entity와 데이터베이스의 데이터를 동기화한다.
  • EntityManager에서 제공하는 Entity 조작 API를 이용해 Entity에 대해 CRUD 작업을 할 수 있다.
• 영속성 컨텍스트(Persistence context)
  • 영속성 영구적으로 저장하는 환경이다.
  • 엔티티를 저장하거나 검색할 때 엔티티 관리자는 영속성 컨텍스트에서 엔티티를 저장하고 관리한다.
  • 영속성 컨텍스트에 접근하거나 관리를 하려면 엔티티 매니저를 통해야 한다.

엔티티 상태

영속성 전이(persistence cascade)

• 엔티티의 영속성 상태 변화를 연관된 엔티티에도 함께 적용하는 것
• 엔티티를 저장할 때 연관된 엔티티도 함께 저장하고 엔티티를 삭제할 때 연관된 엔티티도 함께 삭제하는 것

JPA 메서드

• deleteById() vs delete()

JPA Annotation

Spring Data JPA

• CrudRepository 인터페이스

Interface CrudRepository<T,ID> extends Repository<T,ID>

참조 사이트 - docs.spring.io

Query Method

• Spring Data JPA에서 메서드 형식으로 제공하는 쿼리 호출
• 쿼리 메서드 지원 키워드(Supported Keywords inside method names)

DTO

• Value Object라고도 불리는 Transfer Object는 데이터를 전송하기 위한 객체에 대한 패턴이다.
• 웹 개발 시 DTO, VO, Entity를 구분하는 것을 목표

DTO (Data Transfer Object)

• DTO의 속성 및 역할

  1. 하나의 객체에 여러 타입의 값을 전달하는 일을 수행

     • 데이터 전송 객체라는 의미

  2. Transfer Object를 사용할 때 필드를 private으로 지정하여 getter() 메서드와 setter() 메서드를 만들어야 할 지, 아니면 public으로 지정하여 메서드들을 만들지 않을 지에 대한 정답은 없다.

  3. 성능상으로 따져 볼 때 getter()와 setter() 메서드를 만들지 않는 것이 더 빠르다.

     • 하지만, 정보를 은닉하고, 모든 필드의 값들을 아무나 수정할 수 없게 하려면 getter, setter 메서드를 작성하는 것이 일반적이다.

  4. getEmpName() 메서드처럼empName이 null 값이라도 null을 리턴하지 않고, 길이가 0인 String을 리턴한다.

     • 즉, TransferObject에서 잘 처리하여 각 소스에서 일일이 null 체크를 할 필요가 없기 때문에 개발에 편해진다.

  5. toString() 메서드를 해당 객체에서 구현하지 않고 호출하는 경우 알 수 없는 값을 리턴하게된다.

     • toString() 메서드를 구현하는 경우, 객체에 대한 값 비교를 명확하게 할 수 있다.

  6. Serializable의 구현 이유

     • 이 인터페이스를 구현했다고 해서 추가적으로 구현해야 하는 메서드가 있는 것은 아니다.
     • 그러나 인터페이스를 구현하는 경우 객체를 직렬화할 수가 있다.
     • 다시말해 서버 사이의 데이터 전송이 가능해진다.
     • 원격지 서버에 데이터를 전송하거나, 파일로 객체를 저장할 경우에 인터페이스를 구현해야 한다.

  7. 주로 비동기 처리를 하는 경우 사용

     • SpringBoot에서 Jackson 라이브러리의 ObjectMapper를 사용하여 Json 타입으로 변환

public class EmployeeTO implements Serializable {

    private long empId;
    private String empName;
    private String empPhone;

    public EmployeeTO() {
        super();
    }

    public EmployeeTO(long empId, String empName, String empPhone) {
        super();
        this.empId = empId;
        this.empName = empName;
        this.empPhone = empPhone;
    }

    public long getEmpId() {
        return empId;
    }

    public void setEmpId(long empId) {
        this.empId = empId;
    }

    public String getEmpName() {
        if(empName == null) return "";
        return empName;
    }

    public void setEmpName(String empName) {
        this.empName = empName;
    }

    public String getEmpPhone() {
        return empPhone;
    }

    public void setEmpPhone(String empPhone) {
        this.empPhone = empPhone;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("empId=").append(empId);
        sb.append(" empName=").append(empName);
        sb.append(" empPhone=").append(empPhone);
        return sb.toString();
    }
}

VO (Value Object)

• VO의 속성 및 역할
  1. 값, 객체를 의미
  2. 핵심 역할인 equals, hashCode를 오버라이딩하여 구현
     • VO 내부에 선언된 속성의 모든 값들이 VO 객체마다 값이 같아야 똑같은 객체로 판별
  3. Getter, Setter를 가질 수 있다.
     • 테이블 내에 있는 속성 외에 추가적인 속성을 가질 수 있다.
     • 여러 테이블에 대한 공통 속성을 모아 만든 BaseVO 클래스를 상속받아 사용할 수 있다.

public class EmployeeVO {

    private long empId;
    private String empName;
    private String empPhone;

    public long getEmpId() {
        return empId;
    }

    public void setEmpId(long empId) {
        this.empId = empId;
    }

    public String getEmpName() {
        return empName;
    }

    public void setEmpName(String empName) {
        this.empName = empName;
    }

    public String getEmpPhone() {
        return empPhone;
    }

    public void setEmpPhone(String empPhone) {
        this.empPhone = empPhone;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        EmployeeVO empVo = (EmployeeVO) obj;

        return Objects.equals(empId, empVo.empId);
    }

    @Override
    public int hashCode() {
        return Objects.hash(empId);
    }
}

Entity

• Entity
  1. DB 테이블 내에 존재하는 컬럼만을 속성 값으로 갖는 클래스
  2. Entity 클래스는 상속을 받거나 구현체여서는 안된다.
  3. 테이블 내에 존재하는 컬럼을 가져서도 안된다.

@Entity
public class EmployeeEntity {

    private long empId;
    private String empName;
    private String empPhone;

}

 * 포스팅 된 내용은 카카오 OAuth를 사용하여 프로필의 정보를 가져와 서비스 로그인 활용하는 내용을 작성

카카오 로그인 개요

 - REST API를 사용한 카카오 로그인은 HTTP 요청이 가능한 모든 환경에서 쓸 수 있다.

 - REST API를 사용한 카카오 로그인은 카카오 계정 정보를 입력하는 웹뷰(Web View)를 사용

 - 사용자가 로그인을 요청하면 클라이언트(Client)에 카카오 계정 입력 페이지가 나타난다.

 - REST API로 구현하는 카카오 로그인은 인증코드 받기, 사용자 토큰 받기의 두 단계를 거친다.

 - 먼저 인증 코드를 받고 그 인증 코드로 사용자 토큰을 요청하는 방식

인증 코드 받기

 - 카카오 로그인을 시작하는 단계
 - 로그인 동의 화면을 호출하고, 인증 코드 발급을 요청하는 API
 - 서비스에서 인증 코드 받기 요청을 하면, 카카오는 인증 코드 발급에 앞서 사용자에게 동의 화면을 보여줌
 - 사용자가 로그인 동의 항목들을 선택하고 '동의하고 시작하기'를 누르면, 카카오는 해당 사용자에 대한 인증 코드를 발급해 서비스에 전달

 - 인증 코드 받기 요청 시, 해당 기기에서 카카오계정으로 6시간 이내에 로그인한 적이 있다면 바로 로그인 화면이 나타나거나 로그인된다.
 - 그렇지 않다면, 로그인 창으로 리다이렉트된다.

 - 로그인 화면에서 사용자가 동의 버튼을 클릭하면 인증 코드가 담긴 쿼리 스트링(QueryString)을 요청 시 전달된 redirect_uri로 전송한다.
 - 이때, 응답 상태 유형은 HTTP 302 Redirect로, Location에 인증 코드 또는 에러 유형을 포함
 - 사용자가 취소 버튼을 클릭하면 에러 쿼리 스트링이 request_uri로 전송된다.

1. 인증 코드 요청

URL

Parameter

Response

Sample

 * 위 작업 시 인증 코드를 활용하여 access_token값을 요청할 수 있는 상태가 된다.

2. 사용자 토큰 받기

 - 인증 코드를 받은 뒤, 인증 코드로 사용자 토큰을 발급 받는 API
 - 사용자 토큰 발급까지 완료되어야 로그인 절차가 끝난다.
 - 필수 파라미터 값들을 담아 POST로 요청

 - 요청 성공 시, 응답은 JSON 객체로 Redirect URI에 전달되며 두 가지 종류의 토큰과 타입, 초 단위로 된 만료 시간을 포함

 - 사용자가 로그인에 성공하면 발급되는 액세스 토큰(Access Token)과 리프레시 토큰(Refresh Token)은 각각 역할과 유효기간이 다르다.
 - 실제 사용자 인증을 맡는 액세스 토큰은 비교적 짧은 만료 시간을 가진다.
 - 하지만 유효한 리프레시 토큰이 있다면, 사용자가 다시 로그인했을 때 리프레시 토큰으로 액세스 토큰을 다시 발급 받을 수 있다.

URL

Parameter

Response

Sample

 * access_token을 이용하여 kakao 사용자 관리 API를 호출할 수 있는 상태

3. 사용자 정보 요청

 - 현재 로그인한 사용자의 정보를 불러온다.
 - 사용자 정보 요청 REST API는 사용자 액세스 토큰을 사용하는 방법, 앱 어드민 키를 사용하는 방법 두 가지로 제공된다.
 - 어드민 키는 앱의 마스터 키와 같아 보안에 유의해야 하므로 서버에서 호출할 때만 사용한다.

 - 사용자 액세스 토큰 또는 어드민 키와 사용자 ID를 헤더(header)에 담아 GET/POST로 요청한다.
 - 어드민 키로 요청할 때는 어떤 사용자의 정보가 필요한 지 명시하기 위해 대상 사용자의 ID를 전달한다.
 - 추가 파라미터를 사용하면 특정 정보만 지정해서 받아오거나 URL 응답 값을 https로 받을지 지정할 수 있다.

 - 사용자 정보에는 앱 설정에 등록해 사용하는 추가 사용자 정보 기능이 제공된다.
 - 예로 서비스에서 따로 설정한 사용자 닉네임 등을 카카오 계정 정보에도 저장해 둘 수 있다.
 - 사용자 정보 요청 성공 시, 응답 바디(Body)는 JSON 객체로 사용자 정보들을 포함한다.

 * 현재 페이지에서는 Access Token을 사용하는 내용만을 서술, Admin Key를 사용하는 방식은 카카오 공홈 참고

URL

Header

Additional Parameter

Property keys

Response (사용자 정보 공통 가이드)

Sample

 * 위 작업을 정상적으로 완료한 경우, 사용자 정보를 통하여 서비스에서 활용할 수 있다.

# Network Management with NetStat

 - NetStat (네트워크 통계)는 라우팅 테이블, 인터페이스 통계 등을 볼 수 있을 뿐만아니라 수신 및 발신 네트워크 연결을 모니터링하기 위한 CLI 도구이다.

 - 이는 네트워크의 문제 해결과 성능 측정에서 매우 유용하다.

 - NetStat은 가장 기본적인 네트워크 서비스 디버깅 도구 중 하나로, 열려있는 포트와 포트에서 수신 중인 프로그램이 있는지의 여부를 알려준다.

 - NetStat은 리눅스 네트워크 관리자와 시스템 관리자가 네트워크 관련 문제를 모니터링하고 해결하고 네트워크 트래픽 성능을 결정하는 데 매우 중요하고 유용하다.

# List all LISTENING Ports of TCP and UDP connections

 - Listing all ports (both TCP and UDP) using netstat -a option.

# netstat -a | more

# List TCP Port connections

 - Listing only TCP (Transmission Control Protocol) port connections using netstat -at

# netstat -at

# List UDP Port connections

 - Listing only UDP (User Datagram Protocol) port connections using netstat -au

# netstat -au

# List all LISTENING Connections

 - Listing all active listening ports connections with netstat -l

# netstat -l

# List all TCP Listening Posts

 - Listing all active listening TCP ports by using option netstat -lt

# netstat -lt

# List all UDP Listening Posts

 - Listing all active listening UDP ports by using option netstat -lu

# netstat -lu

# List all UNIX Listening Ports

 - Listing all active UNIX listening ports using netstat -lx

# netstat -lx

# Show Statistics by Protocol

 - Displays statistics by protocol. By default, statistics are shown for the TCP, UDP, ICMP, and IP protocols. The -s parameter can be used to specify a set of protocols.

# netstat -s

# Show Statistics by TCP Protocol

 - Showing statistics of only TCP protocol by using option netstat -st

# netstat -st

# Show Statistics by UDP Protocol

# netstat -su

# Display Service name with PID

 - Displaying service name with their PID number, using option netstat -tp will display “PID/Program Name”.

# netstat -tp

# Display Promiscuous Mode

 - Displaying Promiscuous mode with -ac switch, netstat print the selected information or refresh screen every five second. Default screen refresh in every second.

# netstat -ac 5 | grep tcp

# Display Kernel IP routing

 - Display Kernel IP routing table with netstat and route command.

# netstat -r

# Show Network Interface Transactions

 - Showing network interface packet transactions including both transferring and receiving packets with MTU size

# netstat -i

# Show Kernel Interface Table

 - Showing Kernel interface table, similar to ifconfig command.

# netstat -ie

# Display IPv4 and IPv6 Information

 - Displays multicast group membership information for both IPv4 and IPv6.

# netstat -g

# Print Netstat Information Continuously

 - To get netstat information every few second, then use the following command, it will print netstat information continuously, say every few seconds.

# netstat -c

# Find non supportive Address

 - Finding un-configured address families with some useful information.

# netstat --verbose

# Find Listening Programs

 - Find out how many listening programs running on a port.

# netstat -ap | grep http

# Display RAW Network Statistics

# netstat --statistics --raw

# Display all ports in the LISTEN state

# netstat -an | grep LISTEN

 [ Option ]

   --verbose, -v
       Tell the user what is going on by being verbose. Especially print
       some useful information about unconfigured address families.

   --wide, -W
       Do not truncate IP addresses by using output as wide as needed. This
       is optional for now to not break existing scripts.

   --numeric, -n
       Show numerical addresses instead of trying to determine symbolic
       host, port or user names.

   --numeric-hosts
       shows numerical host addresses but does not affect the resolution of
       port or user names.

   --numeric-ports
       shows numerical port numbers but does not affect the resolution of
       host or user names.

   --numeric-users
       shows numerical user IDs but does not affect the resolution of host
       or port names.

   --protocol=family, -A
       Specifies the address families (perhaps better described as low level
       protocols) for which connections are to be shown.  family is a comma
       (',') separated list of address family keywords like inet, inet6,
       unix, ipx, ax25, netrom, econet, ddp, and bluetooth.  This has the
       same effect as using the --inet|-4, --inet6|-6, --unix|-x, --ipx,
       --ax25, --netrom, --ddp, and --bluetooth options.

       The address family inet (Iv4) includes raw, udp, udplite and tcp
       protocol sockets.

       The address family bluetooth (Iv4) includes l2cap and rfcomm protocol
       sockets.

   -c, --continuous
       This will cause netstat to print the selected information every
       second continuously.

   -e, --extend
       Display additional information.  Use this option twice for maximum
       detail.

   -o, --timers
       Include information related to networking timers.

   -p, --program
       Show the PID and name of the program to which each socket belongs.

   -l, --listening
       Show only listening sockets.  (These are omitted by default.)

   -a, --all
       Show both listening and non-listening sockets.  With the --interfaces
       option, show interfaces that are not up

   -F
       Print routing information from the FIB.  (This is the default.)

   -C
       Print routing information from the route cache.