๐ฑ Entity์ ์ํ (์๋ช ์ฃผ๊ธฐ)
JPA์์ ์ํฐํฐ๋ ํฌ๊ฒ 4๊ฐ์ง ์ํ๋ฅผ ๊ฐ์ง๋ฉฐ, ์ํ๋ฅผ ์ ํ์ํค๋ ๊ธฐ๋ฅ์ EntityManager๊ฐ ์ ๊ณตํ๋ค.
1. Transient(๋น์์): ์ํฐํฐ ๊ฐ์ฒด๊ฐ Java ๋ฉ๋ชจ๋ฆฌ์์๋ง ์กด์ฌํ๊ณ , ์์์ฑ ์ปจํ ์คํธ์ ์๋ฌด ๊ด๋ จ ์๋ ์ํ
2. Persistent(์์): ์ํฐํฐ ๊ฐ์ฒด๊ฐ ์์์ฑ ์ปจํ ์คํธ์ ๊ด๋ฆฌ๋ ์ํ(์์ ์ํ๋ผ๊ณ ๋ฐ๋ก DB์ ์ฟผ๋ฆฌ๊ฐ ๋ ๋ผ๊ฐ๋ ๊ฒ X)
3. Detached(์ค์์): ์ํฐํฐ ๊ฐ์ฒด๊ฐ ์์์ฑ ์ปจํ ์คํธ์ ์ ์ฅ๋์๋ค๊ฐ ๋ถ๋ฆฌ๋ ์ํ
4. Removed(์ญ์ ): ์ค์ DB ์ญ์ ๋ฅผ ์์ฒญํ ์ํ
๐ฑ Hibernate JPA EntityManager ํต์ฌ ๊ธฐ๋ฅ
1๏ธโฃ Persist
persist๋ ์ํฐํฐ์ ์๋ก์ด ์ธ์คํด์ค๋ฅผ ์์์ฑ ์ปจํ ์คํธ์ ์ ์ฅํ ๋ ์ฌ์ฉ๋๋ค.
Person person = new Person(name); // Transient/New
em.persist(person); // Managed
์ฒ์ ์ํฐํฐ ๊ฐ์ฒด ์์ฑ ์ ํด๋น ๊ฐ์ฒด๋ Transiend/New ์ํ๋ก ๋ถ๋ฆฐ๋ค.
persist ์์ด ๋ฐ๋ก Transaction์ ์ข ๋ฃํ๋ฉด ๋ฐ์ดํฐ๋ฒ ์ด์ค์์๋ ์๋ฌด ๋ณํ๋ ์ผ์ด๋์ง ์๋๋ค.
์ด ์ํฐํฐ๋ฅผ ์์์ฑ ์ปจํ ์คํธ๊ฐ ๊ด๋ฆฌํ๋๋ก ํ๊ธฐ ์ํด์๋ persist ๋ฉ์๋๋ฅผ ํธ์ถํด์ผ ํ๋ฉฐ, ํด๋น ๋ฉ์๋ ํธ์ถ ๋ค persion์ Managed ์ํ๊ฐ ๋๋ค.
์ด๋ฐ Managed ์ํ์ ์ํฐํฐ๋ค์ EntityManager์ ์ํด Dirty Check(๋ณ๊ฒฝ ๊ฐ์ง)๊ฐ ๋์ด ์์์ฑ ์ปจํ ์คํธ ๋ด์ ๋ด์ฉ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๋ฐ์ํ๋ flush ๋ฉ์๋๊ฐ ํธ์ถ๋์์ ๋, ๋ณ๊ฒฝ๋ ํ๋์ ๋ํด ์๋์ผ๋ก update/insert๋ฌธ์ด ๋ฐํ๋๋ค.
2๏ธโฃ Detach
entityManager.detach(person);
person.setName(anotherName); // will not saved automatically
์ํฐํฐ๊ฐ Managed์ธ ์ํ์์ detach ๋ฉ์๋ ํธ์ถ ์ ํด๋น ์ํฐํฐ๋ Detached ์ํ๊ฐ ๋์ด ๋ ์ด์ ์์์ฑ ์ปจํ ์คํธ์ ์ํด ๊ด๋ฆฌ๋ฅผ ๋ฐ์ง ์๊ฒ ๋๋ค. ๋ฐ๋ผ์, ํธ๋์ญ์ ์ด ์ข ๋ฃ๋๋๋ผ๋ detach ๋ ์ํฐํฐ์ ๋ํ ์๋์ ์ธ ์์ฑ/์์ ์์ ์ ์ ํ ์ผ์ด๋์ง ์๊ฒ ๋๋ค.
Person person = entityManager.find(Person.class, 1L);
entityManager.detach(person);
์์์ฑ ์ปจํ ์คํธ์์ id๊ฐ 1L์ธ ์ํฐํฐ๊ฐ ์๊ณ ์ด๋ฅผ find๋ก ์ฐพ์์จ ๊ฒฝ์ฐ, ์ด ๊ฐ์ฒด๋ ์์์ฑ ์ปจํ ์คํธ์ ์ํด ๊ด๋ฆฌ๋๋ ์ค์ด๋ฏ๋ก, Managed ์ํ์ด๋ค.
ํ์ง๋ง detach ๋ฉ์๋๋ก ์์์ฑ ์ปจํ ์คํธ์ ๊ด๊ณ๋ฅผ ๋์ผ๋ฉด ํด๋น persion ๊ฐ์ฒด๋ Detached ์ํ๊ฐ ๋๋ค.
(Detached ๋์ด๋, ํธ๋์ญ์ ์ด ์ข ๋ฃ๋ ๋ ์์์ฑ ์ปจํ ์คํธ ๋ด์ ์๋ ๋ด์ฉ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ์์ ์ผ๋ก ๋ฐ์๋๋ค.)
detach๋ ์์์ฑ ์ปจํ ์คํธ๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์๋ ์ ํ ์ํฅ์ ์ฃผ์ง ์๊ณ , ์ด๋ค ์ํฐํฐ ์ธ์คํด์ค๋ฅผ '์คํ๋ผ์ธ' ์ํ๋ก ๋ง๋ ๋ค๊ณ ๋ณผ ์ ์๋ค.(์์์ฑ ์ปจํ ์คํธ์๋ ์ฌ์ ํ ์จ๋ผ์ธ ์ํ์ ์ํฐํฐ ์กด์ฌ)
3๏ธโฃ Merge
merge๋ ์์์ฑ ์ปจํ ์คํธ์ ์๋ ์ํฐํฐ์ ์ํ๋ฅผ ๋ถ๋ฆฌ๋์ด ์๋ ์ํฐํฐ ์ธ์คํด์ค์ ์ ํ๋ ๊ฐ์ผ๋ก ์ ๋ฐ์ดํธํ ๋ ์ฌ์ฉ๋๋ค.
Person person = new Person(id, content);
entityManager.merge(person);
merge๋ ๋ค์๊ณผ ๊ฐ์ ์์ ์ ์ํํ๋ค.
- merge() ์คํ
- ํ๋ผ๋ฏธํฐ๋ก ๋์ด์จ ์ค์์ ์ํฐํฐ์ ID ๊ฐ์ผ๋ก 1์ฐจ ์บ์์์ ์ํฐํฐ ์กฐํ
→ 1์ฐจ ์บ์์ ์ํฐํฐ๊ฐ ์์ผ๋ฉด ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์ํฐํฐ๋ฅผ ์กฐํํ๊ณ 1์ฐจ ์บ์์ ์ ์ฅ
- ์กฐํํ ์์ ์ํฐํฐ(mergePerson)์ person ์ํฐํฐ์ ๊ฐ ์ฑ์ ๋ฃ์
- ์์ ์ํ์ธ mergePerson ๋ฐํ
persist()๋ return ๊ฐ์ด ์์ง๋ง, ์ ๋ฌ๋ ์ธ์คํด์ค๊ฐ managed ๋๋ค.
merge()๋ ์ ๋ฌ๋ ์ธ์คํด์ค๊ฐ ์ฌ์ ํ Detached ์ํ์ธ ๋์ Managed ์ํ์ธ ์ธ์คํด์ค๋ฅผ return ํ๋ค.
๋ฐ๋ผ์ merge()๋ฅผ ํธ์ถํ๋ ๊ฒฝ์ฐ ๋ฐ๋์ ๋ฆฌํด๋ ๊ฒฐ๊ณผ๋ฅผ ํตํด ๋ค์ ์์ ์ ์งํํด์ผ entityManager๊ฐ ๊ด๋ฆฌํ๋ ์ํ๋ฅผ ์ถ์ ํ ์ ์๋ค.
4๏ธโฃ Remove
remove๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์ํฐํฐ๊ฐ ์ญ์ ๋๊ธฐ๋ฅผ ์ํ ๋ ์ฌ์ฉ๋๋ค.
em.remove(comment); // will removed from db
์ด ๊ฒฝ์ฐ ์์์ฑ ์ปจํ ์คํธ์์ ์ ๊ฑฐ๋๊ณ ํธ๋์ญ์ ์ด ์ข ๋ฃ๋ ๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์ญ์ ๋ ๋๋ค.
Hibernate JPA EntityManager ํต์ฌ ๊ธฐ๋ฅ ์ ๋ฆฌ
persist, detach, merge, remove์ ๋ค์ํ ์ฌ๋ก
tech.junhabaek.net
JPA EntityManager: Why use persist() over merge()?
EntityManager.merge() can insert new objects and update existing ones. Why would one want to use persist() (which can only create new objects)?
stackoverflow.com
'Back-end' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[JPA] CascadeType.REMOVE vs orphanRemoval = true (0) | 2024.04.21 |
---|---|
[JPA] Cascade ์์์ฑ ์ ์ด (1) | 2024.04.19 |
[Spring] Spring REST Docs ๊ถํ ์๋ฌ (2) | 2024.02.29 |
[Spring] ์์กด์ฑ ์ฃผ์ ์ @Autowired๋ณด๋ค ์์ฑ์ ์ฃผ์ ์ ๊ถ์ฅํ๋ ์ด์ (0) | 2024.02.28 |
[JPA] ์์์ฑ ์ปจํ ์คํธ์ ๋์์๋ฆฌ์ ์ด์ (0) | 2024.02.14 |