feat: domain

Author: SeokRae

README.md

@@ -6,4 +6,11 @@
 
 ## Settings
 
-- 멀티 모듈기반으로 주제 별로 관리 
+- 멀티 모듈기반으로 주제 별로 관리
+
+## JPA에서 제공하는 트랜잭션과 락에 대한 개념정리
+
+### 트랜잭션과 락
+
+- [트랜잭션과 격리 수준](docs/_1_transaction_and_lock.md)
+- [낙관적 락과 비관적 락 기초](docs/_2_optimistic_lock_and_pessimistic_lock.md)

docs/_1_transaction_and_lock.md

@@ -0,0 +1,58 @@
+### 트랜잭션과 락
+
+> **트랜잭션과 격리 수준**
+
+- 트랜잭션 기초와 JPA가 제공하는 낙관적인 락과 비관적인 락에 대한 정리
+
+> **트랜잭션의 특성**
+
+트랜잭션은 `ACID`라 하는 원자성, 일관성, 격리성, 지속성을 보장해야 한다.
+
+- `원자성`:
+    - 트랜잭션내에서 실행한 작업들은 마치 하나의 작업인 것처럼 모두 `성공` 하든가 모두 `실패`해야 한다.
+- `일관성`:
+    - 모든 트랜잭션은 `일관성`있는 데이터베이스 상태를 유지해야한다.
+    - 예를 들어 데이터베이스에서 정한 `무결성 제약 조건`을 항상 만족해야 한다.
+- `격리성`:
+    - 동시에 실행되는 트랜잭션들이 서로에게 영향을 미치지 않도록 격리한다.
+    - 예를 들어 동시에 같은 데이터를 수정하지 못하도록 해야 한다.
+    - `격리성`은 `동시성과 관련된 성능 이슈`로 인해 `격리 수준을 선택`할 수 있다.
+- `지속성`:
+    - 트랜잭션을 성공적으로 끝내면 그 `결과`가 `항상 기록`되어야 한다.
+    - 중간에 `시스템에 문제가 발생`해도 데이터베이스 로그 등을 사용해서 `성공한 트랜잭션 내용을 복구`해야 한다.
+
+* 여기서 중요한 점은 `트랜잭션 간`에 `격리성을 완벽히 보장`하기 위해서는 트랜잭션을 차례로 실행해야 하고, 그렇게 되면 `동시성 처리 성능`이 나빠진다.
+* 그리하여 `트랜잭션의 격리 레벨에 대한 이해`와 `동시성에 대한 문제를 해결`하는 방법에 대해 알아야 한다.
+
+> **트랜잭션과 격리 수준**
+
+- **READ UNCOMMITED(커밋되지않은 읽기)**
+    - 커밋하지 않은 데이터를 읽을 수 있다.
+    - 트랜잭션 A 가 데이터를 수정하고 있는 와중에 `COMMIT`을 하지 않아도 트랜잭션 B가 수정 중인 데이터를 볼 수 있다.
+    - 이를 `DIRTY READ`라 하고, 데이터 정합성에 심각한 문제가 발생할 수 있다.
+
+- **READ COMMITTED(커밋된 읽기)**
+    - 커밋한 데이터만 읽을 수 있다.
+    - 커밋한 데이터만 볼 수 있기 때문에 `DIRTY READ` 현상이 발생하지 않는다.
+    - 하지만 `NON-REPEATABLE READ`는 발생할 수 있다.
+    - 트랜잭션 A가 회원 1을 조회 중인데, 그 순간에 트랜잭션 B가 회원 1을 수정하고 `COMMIT`하는 경우 트랜잭션 A가 다시 회원을 조회 하였을 때 수정된 데이터가 조회된다.
+    - 이처럼 반복해서 같은 데이터를 읽을 수 없는 상태를 `NON-REPEATABLE READ`라 한다.
+    - `DIRTY-READ`는 허용하지만, `NON-REPEATABLE READ`는 허용하는 격리 수준을 `READ COMMITED`라 한다.
+
+- **REPEATABLE READ(반복가능한 읽기)**
+    - 한 번 조회한 데이터를 반복해서 조회해도 같은 데이터가 조회된다.
+    - 하지만 `PHANTOM READ`가 발생할 수 있다.
+    - 트랜잭션 A가 회원 10 살 이하의 회원을 조회 했는데 트랜잭션 B가 5살 회원을 추가하고 커밋하면, 트랜잭션 A가 다시 10살 이하의 회원을 조회하는 경우 회원 하나가 추가된 상태로 조회된다.
+    - 이처럼 반복 조회 시 결과 집합이 달라지는 것을 `PHANTOM READ`라 한다.
+    - `NON-REPEATABLE READ`는 허용하지 않지만, `PHANTOM READ`는 허 용하는 격리 수준을 `REPEATABLE READ`라 한다.
+
+- **SERIALIZABLE(직렬화 가능)**
+    - 가장 엄격한 트랜잭션 격리 수준이다.
+    - `PHANTOM READ`가 발생하지 않는다. 하지만 `동시성 처리 성능`이 급격히 떨어질 수 있다.
+
+> **격리 수준에 대한 고민하기**
+
+어플리케이션 대부분은 `동시성 처리`가 중요하므로 `READ COMMITED`의 격리 수준을 기본으로 사용한다.
+
+기본은 `READ COMMITED`로 두고 더 높은 격리 수준이 필요한 경우 `데이터베이스 트랜잭션이 제공하는 잠금 기능`을 사용하는 방식을 쓴다.
+

docs/_2_optimistic_lock_and_pessimistic_lock.md

@@ -0,0 +1,6 @@
+### 낙관적 락과 비관적 락 기초
+
+JPA를 사용함으로써 누릴 수 있는 것이 영속성 컨텍스트이다.
+
+영속성 컨텍스트를 적절하게 사용하면 데이터베이스 트랜잭션이 `READ COMMITED` 격리 수준이어도 애플리케이션 레벨에서 `반복 가능한 읽기(REPEATABLE READ)`가 가능하다.
+

optimistic/images/pet-clinic-domain.png

@@ -0,0 +1,30 @@
+package com.example.optimistic.application.owner;
+
+import com.example.optimistic.application.pet.Pet;
+import com.example.optimistic.core.domain.Person;
+
+import javax.persistence.*;
+import javax.validation.constraints.Digits;
+import javax.validation.constraints.NotEmpty;
+import java.util.Set;
+
+@Entity
+@Table(name = "OWNERS")
+public class Owner extends Person {
+
+    @Column(name = "address")
+    @NotEmpty
+    private String address;
+
+    @Column(name = "CITY")
+    @NotEmpty
+    private String city;
+
+    @Column(name = "TELEPHONE")
+    @NotEmpty
+    @Digits(fraction = 0, integer = 10)
+    private String telephone;
+
+    @OneToMany(cascade = CascadeType.ALL, mappedBy = "owner", fetch = FetchType.EAGER)
+    private Set<Pet> pets;
+}

optimistic/src/main/java/com/example/optimistic/application/owner/Owner.java

@@ -0,0 +1,31 @@
+package com.example.optimistic.application.pet;
+
+import com.example.optimistic.application.owner.Owner;
+import com.example.optimistic.application.visit.Visit;
+import com.example.optimistic.core.domain.NamedEntity;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import javax.persistence.*;
+import java.time.LocalDate;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+@Entity
+@Table(name = "PETS")
+public class Pet extends NamedEntity {
+
+    @Column(name = "BIRTH_DATE")
+    @DateTimeFormat(pattern = "yyyy-MM-dd")
+    private LocalDate birthDate;
+
+    @ManyToOne
+    @JoinColumn(name = "type_id")
+    private PetType type;
+
+    @ManyToOne
+    @JoinColumn(name = "owner_id")
+    private Owner owner;
+
+    @Transient
+    private Set<Visit> visits = new LinkedHashSet<>();
+}

optimistic/src/main/java/com/example/optimistic/application/pet/Pet.java

@@ -0,0 +1,12 @@
+package com.example.optimistic.application.pet;
+
+import com.example.optimistic.core.domain.NamedEntity;
+
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+@Entity
+@Table(name = "TYPES")
+public class PetType extends NamedEntity {
+
+}

optimistic/src/main/java/com/example/optimistic/application/pet/PetType.java

@@ -0,0 +1,14 @@
+package com.example.optimistic.application.vet;
+
+
+import com.example.optimistic.core.domain.NamedEntity;
+
+import javax.persistence.Entity;
+import javax.persistence.Table;
+import java.io.Serializable;
+
+@Entity
+@Table(name = "SPECIALTIES")
+public class Specialty extends NamedEntity implements Serializable {
+
+}

optimistic/src/main/java/com/example/optimistic/application/vet/Specialty.java

@@ -0,0 +1,25 @@
+package com.example.optimistic.application.vet;
+
+import com.example.optimistic.core.domain.Person;
+
+import javax.persistence.*;
+import java.util.HashSet;
+import java.util.Set;
+
+@Entity
+@Table(name = "VETS")
+public class Vet extends Person {
+
+	@ManyToMany(fetch = FetchType.EAGER)
+	@JoinTable(name = "VET_SPECIALTIES", joinColumns = @JoinColumn(name = "vet_id"),
+			inverseJoinColumns = @JoinColumn(name = "specialty_id"))
+	private Set<Specialty> specialties;
+
+	protected Set<Specialty> getSpecialtiesInternal() {
+		if (this.specialties == null) {
+			this.specialties = new HashSet<>();
+		}
+		return this.specialties;
+	}
+
+}

optimistic/src/main/java/com/example/optimistic/application/vet/Vet.java

@@ -0,0 +1,27 @@
+package com.example.optimistic.application.visit;
+
+import com.example.optimistic.core.domain.BaseEntity;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+import javax.validation.constraints.NotEmpty;
+import java.time.LocalDate;
+
+@Entity
+@Table(name = "VISITS")
+public class Visit extends BaseEntity {
+
+    @Column(name = "PET_ID")
+    private Integer petId;
+
+    @Column(name = "VISIT_DATE")
+    @DateTimeFormat(pattern = "yyyy-MM-dd")
+    private LocalDate date;
+
+    @NotEmpty
+    @Column(name = "DESCRIPTION")
+    private String description;
+
+}