Ver5.0 ๐ณ JPA Hibernate์ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฐ๋ ์ฑ๋ฅ ์ต์ ํ ๊ธฐ๋ฒ โ N+1 ์ง์ฅ ํ์ถ๋ถํฐ ๋ฐฐ์นยท์บ์ยท์ปค๋ฅ์ ํ๊น์ง, ๋๋ฆฐ ์ฃผ๋ฐฉ์ ๋ฏธ์๋ญ์ผ๋ก ๋ฐ๊พธ๋ ์ค์ ํ๋ ๊ฐ์ด๋

๐ณ JPA Hibernate์ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฐ๋ ์ฑ๋ฅ ์ต์ ํ ๊ธฐ๋ฒ โ N+1 ์ง์ฅ ํ์ถ๋ถํฐ ๋ฐฐ์นยท์บ์ยท์ปค๋ฅ์ ํ๊น์ง, ๋๋ฆฐ ์ฃผ๋ฐฉ์ ๋ฏธ์๋ญ์ผ๋ก ๋ฐ๊พธ๋ ์ค์ ํ๋ ๊ฐ์ด๋
"์ฝ๋๋ ๋ฉ์ฉกํ๋ฐ ์ API๊ฐ 3์ด๋ ๊ฑธ๋ฆฌ์ง?" ๋ฒ์ธ์ ๋๊ฐ ๋น์ฆ๋์ค ๋ก์ง์ด ์๋๋ผ, ์ฐ๋ฆฌ๊ฐ ๋ณด์ง ๋ชปํ ๊ณณ์์ ์์์ง๋ SQL์
๋๋ค.
์ค๋์ Hibernate๋ผ๋ ์จ์ดํฐ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ผ๋ ์ฃผ๋ฐฉ ์ฌ์ด๋ฅผ ์ค๊ฐ๋ ์ฃผ๋ฌธ์๋ฅผ ํ๋ํ๋ ์ถ์ ํ๋ฉฐ, ๋ ์คํ ๋(์ ํ๋ฆฌ์ผ์ด์
)์ ๋น ๋ฅด๊ฒ ๋ง๋๋ ๋ฐฉ๋ฒ์ ์ ๋ฆฌํด ๋ด
๋๋ค.
๐ฝ๏ธ 1์ฅ. ์จ์ดํฐ์ ์์ฒฉ: Hibernate๋ ์ค์ ๋ก ์ด๋ป๊ฒ ์ผํ๋๊ฐ
์ฑ๋ฅ ํ๋์ ์๋ฆฌ๋ฅผ ๋ชจ๋ฅด๋ฉด "์ด๋์ ๊ฐ ๋ณธ ์ค์ ๋ณต๋ถ"์ผ๋ก ๋๋ฉ๋๋ค. ๊ทธ๋์ ๋จผ์ Hibernate์ ํต์ฌ ์์
๊ณต๊ฐ์ธ ์์์ฑ ์ปจํ
์คํธ(Persistence Context)๋ฅผ ์ดํดํด์ผ ํฉ๋๋ค. JPA ํ์ค์์ EntityManager, Hibernate ๋ค์ดํฐ๋ธ API์์ Session์ด๋ผ ๋ถ๋ฅด๋ ์ด ๊ฐ์ฒด๋ ํ๋์ ์์
๋จ์(๋ณดํต ํ๋์ ํธ๋์ญ์
) ๋์ ์ํฐํฐ๋ฅผ ๋ณด๊ดํ๊ณ ์ถ์ ํ๋ ์จ์ดํฐ์ ์์ฒฉ๊ณผ ๊ฐ์ต๋๋ค.
1์ฐจ ์บ์: ๊ฐ์ ์๋์๊ฒ ๊ฐ์ ์ง๋ฌธ์ ๋ ๋ฒ ํ์ง ์๋๋ค
์์์ฑ ์ปจํ
์คํธ ์์๋ (์ํฐํฐ ํ์
, ์๋ณ์)๋ฅผ ํค๋ก ํ๋ ๋งต์ด ์์ต๋๋ค. ์ด๊ฒ์ด ํํ ๋งํ๋ 1์ฐจ ์บ์์
๋๋ค. ๊ฐ์ ํธ๋์ญ์
์์์ em.find(Member.class, 1L)๋ฅผ ๋ ๋ฒ ํธ์ถํ๋ฉด ๋ ๋ฒ์งธ๋ SQL ์์ด ๋งต์์ ๊บผ๋ด ์ต๋๋ค. ๋๋ถ์ ๋์ผ์ฑ(identity) ๋ณด์ฅ, ์ฆ ๊ฐ์ ํ์ ๊ฐ์ ์๋ฐ ๊ฐ์ฒด๋ก ํํ๋๋ค๋ ์ฑ์ง์ด ์๊น๋๋ค.
๋จ, ์ฌ๊ธฐ์ ๋ง์ด ์คํดํ๋ ์ง์ ์ด ์์ต๋๋ค. 1์ฐจ ์บ์๋ ์๋ณ์๋ก ์กฐํํ ๋๋ง ํจ๊ณผ๊ฐ ์์ต๋๋ค. JPQL๋ก select m from Member m where m.id = 1์ ์คํํ๋ฉด Hibernate๋ ์ผ๋จ SQL์ DB๋ก ๋ณด๋
๋๋ค. ๊ฒฐ๊ณผ๋ฅผ ๋ฐ์ ๋ค์์ผ "์ด ํ์ ์ด๋ฏธ ์์ฒฉ์ ์๋ค" ํ๊ณ ๊ธฐ์กด ๊ฐ์ฒด๋ฅผ ๋๋ ค์ค ๋ฟ์ด์ฃ . ๋ํ 1์ฐจ ์บ์๋ ํธ๋์ญ์
์ด ๋๋๋ฉด ์ฌ๋ผ์ง๋ ๋จ๋ช
์บ์๋ผ์, ์ ํ๋ฆฌ์ผ์ด์
์ ์ฒด ์ฑ๋ฅ์ ๋์ด์ฌ๋ฆฌ๋ ์บ์๊ฐ ์๋๋๋ค.
์ํฐํฐ์ ๋ค ๊ฐ์ง ์์ ๋จ๊ณ
๋ณ๊ฒฝ ๊ฐ์ง(Dirty Checking)์ ์ค๋ ์ท
Hibernate๊ฐ update() ๋ฉ์๋ ์์ด๋ ํ๋ ๊ฐ ๋ณ๊ฒฝ์ DB์ ๋ฐ์ํ๋ ๋น๊ฒฐ์ ์ค๋
์ท์
๋๋ค. ์ํฐํฐ๋ฅผ ์์ ์ํ๋ก ๋ก๋ฉํ ๋ Hibernate๋ ๋ก๋ฉ ์์ ์ ์ํ ๋ฐฐ์ด์ ๋ณต์ฌํด ๋ก๋๋ค. ๊ทธ๋ฆฌ๊ณ flush ์์ ์ ํ์ฌ ๊ฐ์ฒด ์ํ์ ์ค๋
์ท์ ํ๋ ๋จ์๋ก ๋น๊ตํด ๋ค๋ฅธ ๊ฒ์ด ์์ผ๋ฉด UPDATE๋ฅผ ๋ง๋ญ๋๋ค.
ํธ๋ฆฌํ์ง๋ง ๊ณต์ง๊ฐ ์๋๋๋ค. ์ํฐํฐ ํ๋๋น ์ค๋ ์ท ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ถ๊ฐ๋ก ๋ค๊ณ , flush๋ง๋ค ๊ด๋ฆฌ ์ค์ธ ๋ชจ๋ ์ํฐํฐ๋ฅผ ๋น๊ตํฉ๋๋ค. ์ํฐํฐ 10๋ง ๊ฐ๋ฅผ ํ ํธ๋์ญ์ ์์ ์ฝ์ด ๋ค์ด๋ฉด, ์์ ํ์ง ์์๋๋ผ๋ ๋ฉ๋ชจ๋ฆฌ์ CPU๋ฅผ ๊ทธ๋งํผ ์๋๋ค. ์ด ์ฌ์ค์ด ์ดํ ๋ฑ์ฅํ '์ฝ๊ธฐ ์ ์ฉ ์ต์ ํ'์ '๋ฐฐ์น ์ฒ๋ฆฌ ์ clear'์ ๊ทผ๊ฑฐ๊ฐ ๋ฉ๋๋ค.
์ฐ๊ธฐ ์ง์ฐ๊ณผ flush ํ์ด๋ฐ
persist()๋ฅผ ํธ์ถํ๋ค๊ณ ์ฆ์ INSERT๊ฐ ๋๊ฐ์ง ์์ต๋๋ค(์์ธ๋ ๋ค์์ ๋ค๋ฃฐ IDENTITY ์ ๋ต). Hibernate๋ SQL์ ์ก์
ํ์ ์์ ๋์๋ค๊ฐ flush ์์ ์ ํ๊บผ๋ฒ์ ๋ณด๋
๋๋ค. ๊ธฐ๋ณธ flush ๋ชจ๋์ธ AUTO์์ flush๋ ๋ค์ ์ํฉ์ ๋ฐ์ํฉ๋๋ค.
em.flush()๋ฅผ ์ง์ ํธ์ถํ ๋์ฐ๊ธฐ ์ง์ฐ ๋๋ถ์ JDBC ๋ฐฐ์น๊ฐ ๊ฐ๋ฅํด์ง๊ณ , ๊ฐ์ ์ํฐํฐ๋ฅผ ์ฌ๋ฌ ๋ฒ ์์ ํด๋ UPDATE๋ ์ต์ข ์ํ๋ก ํ ๋ฒ๋ง ๋๊ฐ๋๋ค. ๋ฐ๋๋ก ์ฟผ๋ฆฌ ์ค๊ฐ์ค๊ฐ ์๋ flush๊ฐ ์ผ์ด๋๋ฉด ๋น๊ต ๋น์ฉ์ด ๋ฐ๋ณต๋๋ฏ๋ก, ๋๋ ์ฒ๋ฆฌ ๋ฃจํ ์์์ JPQL์ ์์ด ์ฐ๋ฉด ์์ธ๋ก ๋๋ ค์ง ์ ์์ต๋๋ค.
โก ๋ณ๊ฒฝ ๊ฐ์ง๋ ์ค๋ ์ท ๋น๊ต ๋น์ฉ๊ณผ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋๊ฐ๋ก ์ป๋ ํธ๋ฆฌํจ์ด๋ค.
โข flush๋ SQL์ ๋ชจ์์ ๋ณด๋ด๋ ์๊ฐ์ด๋ฉฐ, ๊ทธ ํ์ด๋ฐ์ด ๋ฐฐ์น ์ฑ๋ฅ์ ์ข์ฐํ๋ค.
๐ 2์ฅ. ์๋ฆฌ๋ฅผ ๊ณ ์น๊ธฐ ์ ์ ์์์ฆ๋ถํฐ: ์ธก์ ๋๊ตฌ ์ธํ
์ต์ ํ์ ์ 1์์น์ "์ถ์ธกํ์ง ๋ง๊ณ ์ธก์ ํ๋ผ"์
๋๋ค. JPA ์ฑ๋ฅ ์ด์๋ ์ฝ๋์์ ๋์ ๋ณด์ด์ง ์๋๋ค๋ ์ ์ด ํนํ ๋ฌด์ญ์ต๋๋ค. order.getMember().getName()์ด๋ผ๋ ํ๋ฒํ getter ํ ์ค์ด SQL์ ๋ฐ์์ํฌ ์ ์์ผ๋๊น์. ๊ทธ๋์ ๊ฐ๋ฐ ๋จ๊ณ๋ถํฐ SQL์ '๋ณด์ด๊ฒ' ๋ง๋๋ ๊ฒ์ด ์์์
๋๋ค.
Hibernate ๊ธฐ๋ณธ ๋ก๊น ๊ณผ ํต๊ณ
# application.yml (Spring Boot 3 / Hibernate 6 ๊ธฐ์ค)
spring:
jpa:
properties:
hibernate:
format_sql: true
generate_statistics: true # ์ด์์์๋ ์ ์คํ๊ฒ
logging:
level:
org.hibernate.SQL: debug
org.hibernate.orm.jdbc.bind: trace # ๋ฐ์ธ๋ฉ ํ๋ผ๋ฏธํฐ (Hibernate 6)
org.hibernate.stat: debug
spring.jpa.show-sql=true๋ ํ์ค ์ถ๋ ฅ(System.out)์ผ๋ก ์ฐ๊ธฐ ๋๋ฌธ์ ๋ก๊ทธ ํ๋ ์์ํฌ ๊ด๋ฆฌ ๋์์ด ์๋๋๋ค. ๋ก๊ฑฐ ๋ ๋ฒจ ๋ฐฉ์์ ์ฐ๋ ํธ์ด ๋ซ์ต๋๋ค. Hibernate 5 ์์ ์๋ ํ๋ผ๋ฏธํฐ ๋ก๊ฑฐ๊ฐ org.hibernate.type.descriptor.sql์ด์๊ณ , Hibernate 6๋ถํฐ๋ org.hibernate.orm.jdbc.bind๋ก ๋ฐ๋์๋ค๋ ์ ๋ ๊ธฐ์ตํด ๋๋ฉด ๋ง์ด๊ทธ๋ ์ด์
ํ "ํ๋ผ๋ฏธํฐ ๋ก๊ทธ๊ฐ ์ฌ๋ผ์ก๋ค"๋ ํผ๋์ ํผํ ์ ์์ต๋๋ค.
generate_statistics๋ฅผ ์ผ๋ฉด ์ธ์
์ด ๋๋ ๋ ๋ค์๊ณผ ๊ฐ์ ์์ฝ์ด ๋จ์ต๋๋ค. ์คํ๋ JDBC ๋ฌธ์ฅ ์, ๋ฐฐ์น ์คํ ์, 2์ฐจ ์บ์ ์ ์ค/์คํจ, flush ํ์ ๋ฑ์ด ๋ณด์ด๋ฏ๋ก "์ด API๋ ์ฟผ๋ฆฌ๋ฅผ ๋ช ๋ฒ ๋ ๋ฆฌ๋๊ฐ"๋ฅผ ์ซ์๋ก ํ์ธํ ์ ์์ต๋๋ค.
์ธ๋ถ ํ๋ก์ ๋๊ตฌ
pg_stat_statements, ๊ทธ๋ฆฌ๊ณ EXPLAIN/EXPLAIN ANALYZE๋ DB ์
์ฅ์์ ๋น์ผ ์ฟผ๋ฆฌ๋ฅผ ์๋ ค ์ค๋๋ค.๐ฅ 3์ฅ. ์ ๋ช ๋์ N+1 ๋ฌธ์ ํด๋ถ
JPA๋ฅผ ์ฐ๋ ํ์ด๋ผ๋ฉด ํ ๋ฒ์ ๋ฐ๋์ ๋ง๋๋ ๋ณด์ค ๋ชฌ์คํฐ์ ๋๋ค. ์ ์๋ ๋จ์ํฉ๋๋ค. ๋ชฉ๋ก 1๊ฑด์ ์กฐํํ๋ ์ฟผ๋ฆฌ 1๋ฒ + ๋ชฉ๋ก ๊ฐ ํญ๋ชฉ์ ์ฐ๊ด ์ํฐํฐ๋ฅผ ๊ฐ์ ธ์ค๋ ์ฟผ๋ฆฌ N๋ฒ. ์จ์ดํฐ๊ฐ ์๋ 100๋ช ์๊ฒ ์ฃผ๋ฌธ์ ๋ฐ๊ณ ๋์, ๋ฐ์ฐฌ์ ํ๋์ฉ ๊ฐ์ง๋ฌ ์ฃผ๋ฐฉ์ 100๋ฒ ์๋ณตํ๋ ์ ์ ๋๋ค.
์ฌํ ์ฝ๋
@Entity
public class Order {
@Id @GeneratedValue
private Long id;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "member_id")
private Member member;
@OneToMany(mappedBy = "order")
private List<OrderItem> items = new ArrayList<>();
}
// ์๋น์ค
List<Order> orders = orderRepository.findAll(); // SELECT * FROM orders โ 1๋ฒ
for (Order o : orders) {
System.out.println(o.getMember().getName()); // ์ฃผ๋ฌธ๋ง๋ค SELECT member โ N๋ฒ
}
์ง์ฐ ๋ก๋ฉ(LAZY)์ผ๋ก ์ค์ ํ๋๋ผ๋ N+1์ ์ฌ๋ผ์ง์ง ์์ต๋๋ค. LAZY๋ ์ฟผ๋ฆฌ ๋ฐ์ ์์ ์ '๋์ค์ผ๋ก' ๋ฏธ๋ฃฐ ๋ฟ, ํ์๋ฅผ ์ค์ฌ ์ฃผ์ง ์์ต๋๋ค. ๋ค๋ง ํ ๊ฐ์ง ์ํ ์์๋ ์๋๋ฐ, ๊ฐ์ ํ์์ด ์ฌ๋ฌ ์ฃผ๋ฌธ์ ํ๋ค๋ฉด ๋ ๋ฒ์งธ๋ถํฐ๋ 1์ฐจ ์บ์์ ์ด๋ฏธ ์์ผ๋ฏ๋ก ์ฟผ๋ฆฌ๊ฐ ๋๊ฐ์ง ์์ต๋๋ค. ์ฆ ์ค์ ์ถ๊ฐ ์ฟผ๋ฆฌ ์๋ "์๋ก ๋ค๋ฅธ ํ์ ์"๋งํผ์ ๋๋ค.
EAGER๋ก ๋ฐ๊พธ๋ฉด ํด๊ฒฐ๋ ๊น? ์๋์
์ฆ์ ๋ก๋ฉ(EAGER)์ em.find()์ฒ๋ผ ID๋ก ํ๋๋ฅผ ์กฐํํ ๋๋ ์กฐ์ธ์ผ๋ก ํ ๋ฒ์ ๊ฐ์ ธ์ค๊ธฐ๋ ํ์ง๋ง, JPQL๋ก ๋ชฉ๋ก์ ์กฐํํ๋ ๊ฒฝ์ฐ JPQL์ ์์ฑ๋ ๊ทธ๋๋ก SQL๋ก ๋ฒ์ญ๋๊ณ , ๊ทธ ํ Hibernate๊ฐ EAGER ์ฐ๊ด์ ์ฑ์ฐ๊ธฐ ์ํด ์ถ๊ฐ ์ฟผ๋ฆฌ๋ฅผ ๋ ๋ฆฝ๋๋ค. ๊ฒฐ๊ตญ N+1์ด ๊ทธ๋๋ก ๋ฐ์ํ๊ณ , ์ฌ์ง์ด ํ์ ์๋ ํ๋ฉด์์๋ ๋ฌด์กฐ๊ฑด ๋ฐ์ํฉ๋๋ค. ๊ทธ๋์ ์ค๋ฌด ์ ์์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
๋ชจ๋ ์ฐ๊ด๊ด๊ณ๋ LAZY๋ก ์ ์ธํ๊ณ , ํ์ํ ๊ณณ์์๋ง ๋ช ์์ ์ผ๋ก ํจ๊ป ๊ฐ์ ธ์จ๋ค.
์ฃผ์ํ ์ : JPA ๋ช
์ธ์ @ManyToOne๊ณผ @OneToOne์ ๊ธฐ๋ณธ๊ฐ์ EAGER, @OneToMany์ @ManyToMany์ ๊ธฐ๋ณธ๊ฐ์ LAZY์
๋๋ค. ์ฆ ์๋ฌด๊ฒ๋ ์ ์ฐ๋ฉด ToOne ๊ด๊ณ๋ ์กฐ์ฉํ EAGER๊ฐ ๋ฉ๋๋ค. fetch = FetchType.LAZY๋ฅผ ๋ช
์ํ๋ ์ต๊ด์ด ํ์์
๋๋ค.
ํด๊ฒฐ์ฑ โ fetch join
@Query("select o from Order o join fetch o.member")
List<Order> findAllWithMember();
fetch join์ JPQL์์ ์ฐ๊ด ์ํฐํฐ๋ฅผ SQL ์กฐ์ธ์ผ๋ก ํจ๊ป SELECT ํ๋ผ๊ณ ์ง์ํฉ๋๋ค. ๊ฒฐ๊ณผ๋ ์ฟผ๋ฆฌ 1๋ฒ. ๊ฐ์ฅ ์ง๊ด์ ์ด๊ณ ๊ฐ๋ ฅํ ๋ฌด๊ธฐ์ ๋๋ค. ToOne ๊ด๊ณ๋ ์กฐ์ธํด๋ ํ ์๊ฐ ๋์ง ์์ผ๋ฏ๋ก ์ฌ๋ฌ ๊ฐ๋ฅผ ์ฐ๋ฌ์ fetch join ํด๋ ์์ ํ ํธ์ ๋๋ค.
ํด๊ฒฐ์ฑ โก @EntityGraph
@EntityGraph(attributePaths = {"member", "delivery"})
List<Order> findByStatus(OrderStatus status);
Spring Data JPA์ ๋ฉ์๋ ์ด๋ฆ ์ฟผ๋ฆฌ์๋ fetch ์ ๋ต์ ๋ถ์ผ ์ ์๋ ๋ฐฉ์์ ๋๋ค. JPA ํ์ค์ ์ํฐํฐ ๊ทธ๋ํ(fetch graph/load graph)๋ฅผ ํ์ฉํ๋ฉฐ, ๋ด๋ถ์ ์ผ๋ก๋ LEFT OUTER JOIN์ด ์์ฑ๋ฉ๋๋ค. JPQL์ ์ง์ ์ฐ์ง ์์๋ ๋๋ ๊น๋ํจ์ด ์ฅ์ ์ ๋๋ค.
ํด๊ฒฐ์ฑ โข ๋ฐฐ์น ํ์น(Batch Fetch)
spring:
jpa:
properties:
hibernate:
default_batch_fetch_size: 100
์ด ์ค์ ์ ์ง์ฐ ๋ก๋ฉ์ด ๋ฐ์ํ๋ ์๊ฐ, ์์์ฑ ์ปจํ
์คํธ์ ์์ง ์ด๊ธฐํ๋์ง ์์ ๊ฐ์ ์ข
๋ฅ์ ํ๋ก์/์ปฌ๋ ์
์๋ณ์๋ค์ ๋ชจ์ WHERE id IN (?, ?, ...)์ผ๋ก ํ ๋ฒ์ ๊ฐ์ ธ์ต๋๋ค. ํ์ 100๋ช
์ ์ฃผ๋ฌธ์ ์ถ๋ ฅํ ๋ ํ์ ์กฐํ ์ฟผ๋ฆฌ๊ฐ 100๋ฒ์ด ์๋๋ผ 1๋ฒ(๋ฐฐ์น ํฌ๊ธฐ 100 ๊ธฐ์ค)์ผ๋ก ์ค์ด๋ญ๋๋ค. ๊ฐ๋ณ ํ๋๋ ์ปฌ๋ ์
์๋ @BatchSize(size = 100)์ผ๋ก ๋ฐ๋ก ์ง์ ํ ์๋ ์์ต๋๋ค.
๋ฐฐ์น ํ์น์ ๋งค๋ ฅ์ ์ฝ๋ ๋ณ๊ฒฝ ์์ด ์ ์ญ ์ ์ฉ๋๋ค๋ ์ , ๊ทธ๋ฆฌ๊ณ ์ปฌ๋ ์ fetch join์ด ๊ฐ์ง ํ์ด์ง ๋ฌธ์ (4์ฅ์์ ๋ค๋ฃธ)๋ฅผ ํผํ ์ ์๋ค๋ ์ ์ ๋๋ค. ํฌ๊ธฐ๋ ๋ณดํต 100~1000 ๋ฒ์์์ ์ ํ๋ฉฐ, DB๋ง๋ค IN ์ ํ๋ผ๋ฏธํฐ ๊ฐ์ ํ๊ณ์ ์คํ ๊ณํ ํน์ฑ์ด ๋ค๋ฅด๋ ์ธก์ ์ผ๋ก ์ ํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
ํด๊ฒฐ์ฑ โฃ @Fetch(FetchMode.SUBSELECT)
Hibernate ๊ณ ์ ๊ธฐ๋ฅ์ผ๋ก, ์ปฌ๋ ์ ์ ์ด๊ธฐํํ ๋ ์ฒซ ์ฟผ๋ฆฌ๋ฅผ ์๋ธ์ฟผ๋ฆฌ๋ก ๋ค์ ์ฌ์ฉํด
WHERE order_id IN (SELECT id FROM orders WHERE ...) ํํ๋ก ๋ชจ๋ ์ปฌ๋ ์
์ ํ ๋ฒ์ ๊ฐ์ ธ์ต๋๋ค. ๋ค๋ง ์๋ณธ ์ฟผ๋ฆฌ๊ฐ ๋ณต์กํ๊ฑฐ๋ ๋ฌด๊ฑฐ์ฐ๋ฉด ์๋ธ์ฟผ๋ฆฌ๋ก ํ ๋ฒ ๋ ์คํ๋๋ ์
์ด๋ผ ์ํฉ์ ๋ด์ผ ํฉ๋๋ค.
| ๊ธฐ๋ฒ | ์ฟผ๋ฆฌ ์ | ์ฅ์ | ์ฃผ์์ |
|---|---|---|---|
| fetch join | 1 | ๊ฐ์ฅ ํ์ค, ๋ช ์์ | ์ปฌ๋ ์ + ํ์ด์ง ๋ถ๊ฐ, ๋ค์ค bag ๋ถ๊ฐ |
| @EntityGraph | 1 | ๋ฉ์๋ ์ด๋ฆ ์ฟผ๋ฆฌ์ ๊ฒฐํฉ ์ฌ์ | fetch join๊ณผ ๊ฐ์ ํ๊ณ |
| ๋ฐฐ์น ํ์น | 1 + โN/๋ฐฐ์นโ | ์ ์ญ ์ค์ , ํ์ด์ง๊ณผ ๊ณต์กด | ์ฟผ๋ฆฌ ์๊ฐ ์์ ํ 1์ ์๋ |
| SUBSELECT | 2 | ์ปฌ๋ ์ ์ผ๊ด ๋ก๋ฉ | ์๋ณธ ์ฟผ๋ฆฌ๊ฐ ๋ฌด๊ฑฐ์ฐ๋ฉด ๋น์ฉ ์ฌ๋ฐ์ |
๐งบ 4์ฅ. ์ปฌ๋ ์ fetch join์ ํจ์ : ํ์ด์ง๊ณผ MultipleBag
ToOne ๊ด๊ณ์ fetch join์ ์ฐ๋ฑ์์ด์ง๋ง, OneToMany ์ปฌ๋ ์ ์ fetch joinํ๋ ์๊ฐ ์ฌ์ ์ด ๋ฌ๋ผ์ง๋๋ค. ์ฃผ๋ฌธ 1๊ฑด์ ์ํ 3๊ฐ๊ฐ ์๋ค๋ฉด SQL ์กฐ์ธ ๊ฒฐ๊ณผ๋ 3ํ์ด ๋ฉ๋๋ค. ์ด๋ฅธ๋ฐ ๋ฐ์ดํฐ ๋ปฅํ๊ธฐ(์นดํ ์์ ๊ณฑ)์ ๋๋ค.
์ค๋ณต ํ ๋ฌธ์
Hibernate 5๊น์ง๋ JPQL์ select distinct o๋ฅผ ๋ถ์ฌ ์ ํ๋ฆฌ์ผ์ด์
๋ ๋ฒจ์์ ๊ฐ์ ์ํฐํฐ ์ค๋ณต์ ์ ๊ฑฐํด์ผ ํ์ต๋๋ค. Hibernate 6๋ถํฐ๋ fetch join์ผ๋ก ์ธํ ๋ฃจํธ ์ํฐํฐ ์ค๋ณต์ ์๋์ผ๋ก ์ ๊ฑฐํ๋ฏ๋ก DISTINCT๊ฐ ํ์๋ ์๋๋๋ค. ๊ทธ๋ฌ๋ DB์์ ๋์ด์ค๋ ํ ์ ์์ฒด๋ ์ฌ์ ํ ๋์ด๋๋ค๋ ์ฌ์ค์ ์์ผ๋ฉด ์ ๋ฉ๋๋ค.
ํ์ด์ง + ์ปฌ๋ ์ fetch join = ๋ฉ๋ชจ๋ฆฌ ํญํ
@Query("select o from Order o join fetch o.items")
Page<Order> findAllWithItems(Pageable pageable); // ์ํ!
SQL์ LIMIT์ 'ํ' ๋จ์๋ก ์๋ฅด๋๋ฐ, ์ปฌ๋ ์
์กฐ์ธ ๊ฒฐ๊ณผ๋ '์ฃผ๋ฌธ'์ด ์๋๋ผ '์ฃผ๋ฌธร์ํ' ํ์
๋๋ค. ๊ทธ๋์ DB์์ ์๋ผ ๋ฒ๋ฆฌ๋ฉด ์ฃผ๋ฌธ ํ๋์ ์ํ ๋ชฉ๋ก์ด ์ค๊ฐ์ ์๋ฆด ์ ์์ต๋๋ค. Hibernate๋ ์ด๋ฅผ ๋ง๊ธฐ ์ํด LIMIT ์์ด ์ ์ฒด ๊ฒฐ๊ณผ๋ฅผ ๋ฉ๋ชจ๋ฆฌ๋ก ๊ฐ์ ธ์จ ๋ค ์ ํ๋ฆฌ์ผ์ด์
์์ ํ์ด์งํฉ๋๋ค. ์ด๋ ๋ก๊ทธ์ ๊ฒฝ๊ณ ๊ฐ ๋จ์ต๋๋ค(Hibernate 5์ HHH000104, Hibernate 6์ HHH90003004: "firstResult/maxResults specified with collection fetch; applying in memory").
ํ ์ด๋ธ์ ์ฃผ๋ฌธ์ด 100๋ง ๊ฑด์ด๋ฉด 100๋ง ๊ฑด ร ์ํ ์๋งํผ์ ํ์ด ๋ฉ๋ชจ๋ฆฌ์ ์ฌ๋ผ์ต๋๋ค. ๊ฐ๋ฐ DB์์๋ ๋ฉ์ฉกํ๋ค๊ฐ ์ด์์์ OutOfMemoryError๋ฅผ ๋ด๋ ์ ํ์ ์ธ ์ํํญํ์ด์ฃ . ์์ ์คํจํ๊ฒ ๋ง๋ค๊ณ ์ถ๋ค๋ฉด
hibernate.query.fail_on_pagination_over_collection_fetch=true๋ฅผ ์ผ ๋๋ฉด ๊ฒฝ๊ณ ๋์ ์์ธ๊ฐ ๋ฐ์ํด ์กฐ๊ธฐ์ ๋ฐ๊ฒฌํ ์ ์์ต๋๋ค.
์ปฌ๋ ์ fetch join + Pageable
โ ์ ์ฒด ํ์ ๋ฉ๋ชจ๋ฆฌ๋ก ๋ก๋ฉ
โ ๊ฒฝ๊ณ ๋ก๊ทธ ๋ฌด์ํ๋ฉด ์ด์ ์ฅ์
ToOne๋ง fetch join + ํ์ด์ง
์ปฌ๋ ์ ์
default_batch_fetch_size๋ก IN ์ฟผ๋ฆฌ ๋ก๋ฉโ ํ์ด์ง๋น ์ฟผ๋ฆฌ 2~3๊ฐ๋ก ์์
MultipleBagFetchException
List ํ์
์ปฌ๋ ์
์ Hibernate ๋ด๋ถ์ ์ผ๋ก ์์ยท์ค๋ณต์ ํ์ฉํ๋ bag์ผ๋ก ์ทจ๊ธ๋ฉ๋๋ค. ๋ ๊ฐ ์ด์์ bag์ ๋์์ fetch joinํ๋ฉด ์นดํ
์์ ๊ณฑ ๋๋ฌธ์ ๊ฒฐ๊ณผ๋ฅผ ์ฌ๋ฐ๋ฅด๊ฒ ๋ถ๋ฆฌํ ์ ์์ด์ Hibernate๊ฐ MultipleBagFetchException์ ๋์ง๋๋ค. ํํ ์ฐํ์ฑ
์ Set์ผ๋ก ๋ฐ๊พธ๋ ๊ฒ์ธ๋ฐ, ์์ธ๋ ์ฌ๋ผ์ง์ง๋ง ์นดํ
์์ ๊ณฑ์ ๊ทธ๋๋ก ๋จ์ ํ ์๊ฐ ๊ณฑ์
์ผ๋ก ํญ์ฆํฉ๋๋ค(์ํ 10๊ฐ ร ์ฟ ํฐ 10๊ฐ = 100ํ). ๊ทผ๋ณธ ํด๊ฒฐ์ ์ปฌ๋ ์
ํ๋๋ง fetch joinํ๊ณ ๋๋จธ์ง๋ ๋ฐฐ์น ํ์น๋ก ๊ฐ์ ธ์ค๊ฑฐ๋, ์ฟผ๋ฆฌ๋ฅผ ๋๋ ์คํํ๋ ๊ฒ์
๋๋ค.
โณ 5์ฅ. ์ง์ฐ ๋ก๋ฉ๊ณผ ํ๋ก์, ๊ทธ๋ฆฌ๊ณ OSIV ๋ ผ์
ํ๋ก์์ ์ ์ฒด
LAZY ์ฐ๊ด์ ๊ฐ์ง ์ํฐํฐ๋ฅผ ๋ก๋ฉํ๋ฉด, ์ฐ๊ด ํ๋์๋ ์ง์ง ์ํฐํฐ ๋์ ํ๋ก์ ๊ฐ์ฒด(์ํฐํฐ๋ฅผ ์์ํ ๋ฐ์ดํธ์ฝ๋ ์์ฑ ํด๋์ค)๊ฐ ๋ค์ด๊ฐ๋๋ค. ํ๋ก์๋ ์๋ณ์๋ง ์๊ณ ์๋ค๊ฐ, ID ์ธ์ ๋ฉ์๋๊ฐ ์ฒ์ ํธ์ถ๋๋ ์๊ฐ ์์์ฑ ์ปจํ
์คํธ์ ์ด๊ธฐํ๋ฅผ ์์ฒญํด SQL์ ์คํํฉ๋๋ค. ๊ทธ๋์ order.getMember().getId()๋ ๋ณดํต ์ฟผ๋ฆฌ๋ฅผ ๋ฐ์์ํค์ง ์์ง๋ง getName()์ ๋ฐ์์ํต๋๋ค.
ํ๋ก์ ๋๋ฌธ์ ์๊ธฐ๋ ๋ฏธ๋ฌํ ๋ฌธ์ ๋ ์์ต๋๋ค. getClass() ๋น๊ต๊ฐ ๊นจ์ง๊ณ , equals()์์ ํ๋๋ฅผ ์ง์ ์ ๊ทผํ๋ฉด ์ด๊ธฐํ๋์ง ์์ ๊ฐ์ด ๋ณด์ผ ์ ์์ต๋๋ค. ์ํฐํฐ์ equals๋ฅผ ๊ตฌํํ ๋ getter๋ฅผ ์ฌ์ฉํ๊ณ instanceof๋ก ๋น๊ตํ๋ ๊ด๋ก๊ฐ ์ด ๋๋ฌธ์
๋๋ค.
LazyInitializationException
ํธ๋์ญ์
(์ ํํ๋ ์์์ฑ ์ปจํ
์คํธ)์ด ๋ซํ ๋ค ํ๋ก์๋ฅผ ์ด๊ธฐํํ๋ ค ํ๋ฉด ์ด ์์ธ๊ฐ ๋ฉ๋๋ค. ํํ ์ปจํธ๋กค๋ฌ๋ JSON ์ง๋ ฌํ ๋จ๊ณ์์ ํฐ์ง์ฃ . ํด๊ฒฐ์ฑ
์ผ๋ก EAGER ์ ํ์ด๋ hibernate.enable_lazy_load_no_trans=true๋ฅผ ์ฐ๋ ์ฌ๋ก๊ฐ ์๋๋ฐ, ํ์๋ ์ง์ฐ ๋ก๋ฉ๋ง๋ค ์์ ์ธ์
๊ณผ ์ปค๋ฅ์
์ ์๋ก ์ฌ๋ ๋ฐฉ์์ด๋ผ N+1์ ๋ ๋น์ธ๊ฒ ๋ง๋๋ ์ํฐํจํด์ผ๋ก ์๋ ค์ ธ ์์ต๋๋ค. ์ฌ๋ฐ๋ฅธ ํด๊ฒฐ์ ์๋น์ค ๊ณ์ธต ์์์ ํ์ํ ๋ฐ์ดํฐ๋ฅผ ๋ชจ๋ ๋ก๋ฉ(fetch join, ๋ฐฐ์น ํ์น)ํ๊ณ DTO๋ก ๋ณํํด ๋ด๋ณด๋ด๋ ๊ฒ์
๋๋ค.
OSIV(Open Session In View)
Spring Boot๋ spring.jpa.open-in-view๊ฐ ๊ธฐ๋ณธ๊ฐ true์ด๋ฉฐ, ์ด ์ํ๋ก ๊ธฐ๋ํ๋ฉด ๊ฒฝ๊ณ ๋ก๊ทธ๋ฅผ ๋จ๊น๋๋ค. OSIV๊ฐ ์ผ์ ธ ์์ผ๋ฉด ์์์ฑ ์ปจํ
์คํธ๊ฐ HTTP ์์ฒญ ์์๋ถํฐ ์๋ต ์๋ฃ๊น์ง ์ ์ง๋์ด, ๋ทฐ๋ ์ปจํธ๋กค๋ฌ์์๋ ์ง์ฐ ๋ก๋ฉ์ด ๋์ํฉ๋๋ค.
LazyInitializationException ๊ฑฑ์ ์ด ์ค๊ณ , ๊ฐ๋ฐ ์๋๊ฐ ๋น ๋ฆ ๋๋ค. ํธ๋ํฝ์ด ์ ์ ๊ด๋ฆฌ์ ๋๊ตฌ๋ ์ฌ๋ด ์์คํ ์์๋ ์ค์ฉ์ ์ธ ์ ํ์ผ ์ ์์ต๋๋ค.
์ง์ฐ ๋ก๋ฉ์ด ์ผ์ด๋๋ ์๊ฐ ์ปค๋ฅ์ ์ ์ป์ผ๋ฉด, ์๋ต์ด ๋๋ ๋๊น์ง ๊ทธ ์ปค๋ฅ์ ์ ๋ถ์ก๊ณ ์์ต๋๋ค. ์ธ๋ถ API ํธ์ถ์ฒ๋ผ ๋๋ฆฐ ์์ ์ด ๋ผ๋ฉด ์ปค๋ฅ์ ํ์ด ๊ณ ๊ฐ๋ ์ ์๊ณ , ์ด๋์ ์ฟผ๋ฆฌ๊ฐ ๋๊ฐ์ง ์์ธกํ๊ธฐ ์ด๋ ค์์ง๋๋ค.
ํธ๋ํฝ์ด ๋ง์ API ์๋ฒ๋ผ๋ฉด open-in-view: false๋ก ๋๊ณ , "ํธ๋์ญ์
์์์ ํ์ํ ๋ชจ๋ ๊ฒ์ ๋ก๋ฉํ๋ค"๋ ๊ท์น์ ์งํค๋ ๊ฒ์ด ์ผ๋ฐ์ ์ผ๋ก ๊ถ์ฅ๋ฉ๋๋ค. ์กฐํ ๋ก์ง์ด ๋ณต์กํ๋ฉด ํ๋ฉด ์ ์ฉ ์กฐํ ์๋น์ค(OrderQueryService ๋ฑ)๋ฅผ ๋ถ๋ฆฌํด ๊ด๋ฆฌํ๋ฉด ๊ตฌ์กฐ๋ ๊น๋ํด์ง๋๋ค.
๐ 6์ฅ. ์ฝ๊ธฐ ์ ์ฉ ์ต์ ํ์ DTO ํ๋ก์ ์
์น ์๋น์ค ํธ๋ํฝ์ ๋๋ค์๋ ์กฐํ์ ๋๋ค. ์กฐํ๋ง ํ ๊ฑฐ๋ผ๋ฉด ๋ณ๊ฒฝ ๊ฐ์ง์ฉ ์ค๋ ์ท, flush ๋น๊ต ๊ฐ์ ๋น์ฉ์ ๋ผ ์ด์ ๊ฐ ์์ต๋๋ค.
@Transactional(readOnly = true)
Spring์์ ์ฝ๊ธฐ ์ ์ฉ ํธ๋์ญ์
์ ์ ์ธํ๋ฉด, Hibernate๋ฅผ ์ฐ๋ ๊ฒฝ์ฐ ์ธ์
์ flush ๋ชจ๋๋ฅผ MANUAL๋ก ์ค์ ํด ์๋ flush๋ฅผ ๋ง๊ณ , Spring 5.1 ์ดํ์๋ ์ธ์
์ ๊ธฐ๋ณธ ์ฝ๊ธฐ ์ ์ฉ(default read-only)์ผ๋ก ์ค์ ํฉ๋๋ค. ์ฝ๊ธฐ ์ ์ฉ์ผ๋ก ๋ก๋ฉ๋ ์ํฐํฐ๋ ์ค๋
์ท์ ์ ์งํ์ง ์์ผ๋ฏ๋ก ๋ฉ๋ชจ๋ฆฌ์ flush ๋น์ฉ์ด ์ ์ฝ๋ฉ๋๋ค. ๋ํ JDBC ์ปค๋ฅ์
์ setReadOnly(true) ํํธ๊ฐ ์ ๋ฌ๋ ์ ์์ด, ๋๋ผ์ด๋ฒ๋ ๋ผ์ฐํ
DataSource ๊ตฌ์ฑ์ ๋ฐ๋ผ ์ฝ๊ธฐ ๋ณต์ ๋ณธ์ผ๋ก ๋ณด๋ด๋ ๋ฐ์๋ ํ์ฉ๋ฉ๋๋ค.
@Service
@Transactional(readOnly = true) // ํด๋์ค ๊ธฐ๋ณธ๊ฐ์ ์ฝ๊ธฐ ์ ์ฉ
public class OrderService {
public OrderDetail getOrder(Long id) { ... }
@Transactional // ์ฐ๊ธฐ ๋ฉ์๋๋ง ๋ฐ๋ก ์ด๊ธฐ
public Long placeOrder(OrderCommand cmd) { ... }
}
์ฟผ๋ฆฌ ๋จ์ ์ฝ๊ธฐ ์ ์ฉ ํํธ
@QueryHints(@QueryHint(name = "org.hibernate.readOnly", value = "true"))
List<Product> findByCategory(String category);
ํธ๋์ญ์
์ ์ฒด๊ฐ ์๋๋ผ ํน์ ์ฟผ๋ฆฌ ๊ฒฐ๊ณผ๋ง ์ฝ๊ธฐ ์ ์ฉ์ผ๋ก ๋ก๋ฉํ๊ณ ์ถ์ ๋ ์๋๋ค. ๋๋ ์กฐํ ํ ์ผ๋ถ๋ง ์์ ํ๋ ํผํฉ ๋ก์ง์ ์ ์ฉํฉ๋๋ค. ์์ ๋ณ๊ฒฝ๋ ์ผ์ด ์๋ ์ํฐํฐ(์ฝ๋ ํ
์ด๋ธ ๋ฑ)๋ผ๋ฉด ํด๋์ค์ @Immutable์ ๋ถ์ฌ Hibernate๊ฐ ๋ณ๊ฒฝ ๊ฐ์ง๋ฅผ ํ์ง ์๋๋ก ํ ์ ์์ต๋๋ค.
DTO ํ๋ก์ ์ : ํ์ํ ์ปฌ๋ผ๋ง ์๋น
์ํฐํฐ๋ฅผ ํต์งธ๋ก ์กฐํํ๋ฉด ๋ชจ๋ ์ปฌ๋ผ์ ๊ฐ์ ธ์ค๊ณ ์์์ฑ ์ปจํ ์คํธ์ ๋ฑ๋กํฉ๋๋ค. ํ๋ฉด์ ์ด๋ฆ๊ณผ ๊ฐ๊ฒฉ๋ง ํ์ํ๋ค๋ฉด, ์ฒ์๋ถํฐ ๊ทธ ๋ ์ปฌ๋ผ๋ง SELECTํ๋ ํธ์ด ํจ์ฌ ํจ์จ์ ์ ๋๋ค.
public record ProductSummary(Long id, String name, int price) {}
@Query("""
select new com.shop.dto.ProductSummary(p.id, p.name, p.price)
from Product p
where p.category = :category
""")
List<ProductSummary> findSummaries(@Param("category") String category);
select new๋ก DTO ์์ฑ. ์์์ฑ ์ปจํ
์คํธ์ ๋ฑ๋ก๋์ง ์์ ๊ด๋ฆฌ ๋น์ฉ 0. ํจํค์ง๋ช
์ ํฌํจํ ์ ์ฒด ์ด๋ฆ์ด ํ์ํฉ๋๋ค.Projections.constructor ๋ฑ์ผ๋ก ํ์
์์ ํ DTO ์กฐํ๋ฅผ ๊ตฌ์ฑํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค.โ๏ธ 7์ฅ. ์ฐ๊ธฐ ์ฑ๋ฅ: ๋๋ INSERTยทUPDATE๋ฅผ ๋น ๋ฅด๊ฒ
ํ์ 10๋ง ๋ช
์๊ฒ ์ฟ ํฐ์ ๋ฐ๊ธํ๋ ๋ฐฐ์น๋ฅผ ์๊ฐํด ๋ด
์๋ค. saveAll()๋ก ๋จ์ํ๊ฒ ์ง๋ฉด INSERT 10๋ง ๋ฒ์ด ํ ์ค์ฉ ๋คํธ์ํฌ๋ฅผ ํ๊ณ ๊ฐ๋๋ค. ์ด ์๋ณต์ ์ค์ด๋ ๊ฒ์ด ํต์ฌ์
๋๋ค.
JDBC ๋ฐฐ์น ํ์ฑํ
spring:
jpa:
properties:
hibernate:
jdbc:
batch_size: 50
order_inserts: true
order_updates: true
batch_versioned_data: true
hibernate.jdbc.batch_size๋ฅผ ์ง์ ํ๋ฉด ๊ฐ์ SQL ๋ฌธ์ฅ์ ๋ฌถ์ด addBatch()/executeBatch()๋ก ๋ณด๋
๋๋ค. ์ฌ๊ธฐ์ ๊ฐ์ SQL์ด ์ค์ํฉ๋๋ค. ๋ถ๋ชจ-์์ ์ํฐํฐ๋ฅผ ๋ฒ๊ฐ์ ์ ์ฅํ๋ฉด ๋ฌธ์ฅ์ด ๊ณ์ ๋ฐ๋์ด ๋ฐฐ์น๊ฐ ๋๊ธฐ๋๋ฐ, order_inserts/order_updates๊ฐ ์ํฐํฐ ํ์
๋ณ๋ก ๋ฌธ์ฅ์ ์ ๋ ฌํด ๋ฐฐ์น ํจ์จ์ ๋์ฌ ์ค๋๋ค. batch_versioned_data๋ @Version์ด ์๋ ์ํฐํฐ์ UPDATE๋ ๋ฐฐ์น ์ฒ๋ฆฌํ๋๋ก ํฉ๋๋ค(๋๋ผ์ด๋ฒ๊ฐ ์ ํํ ๊ฐฑ์ ํ ์๋ฅผ ๋ฐํํด์ผ ํจ).
IDENTITY ์ ๋ต์ ํจ์
MySQL์์ ํํ ์ฐ๋
@GeneratedValue(strategy = GenerationType.IDENTITY)๋ AUTO_INCREMENT๋ก ํค๋ฅผ ๋ง๋ญ๋๋ค. ๋ฌธ์ ๋ ID๋ฅผ ์๋ ค๋ฉด INSERT๋ฅผ ์ค์ ๋ก ์คํํด์ผ ํ๋ค๋ ์ ์
๋๋ค. ์์ ์ํ๊ฐ ๋๋ ค๋ฉด ID๊ฐ ์์ด์ผ ํ๋ฏ๋ก, Hibernate๋ persist() ์์ ์ ์ฆ์ INSERT๋ฅผ ์คํํ๊ณ , ๊ทธ ๊ฒฐ๊ณผ INSERT์ ๋ํ JDBC ๋ฐฐ์น๊ฐ ๋นํ์ฑํ๋ฉ๋๋ค. Hibernate ๊ณต์ ๋ฌธ์๋ ์ด ์ ์ ๋ช
์ํฉ๋๋ค.
| ์ ๋ต | INSERT ๋ฐฐ์น | ํน์ง |
|---|---|---|
| IDENTITY | ๋ถ๊ฐ | ๊ฐ๋จํ์ง๋ง persist ์ฆ์ INSERT |
| SEQUENCE | ๊ฐ๋ฅ | ์ํ์ค๋ก ID๋ฅผ ๋จผ์ ํ๋ณด, pooled ์ต์ ํ๋ก ํธ์ถ ์ต์ํ |
| TABLE | ๊ฐ๋ฅ | ๋ณ๋ ํ ์ด๋ธ ํ ์ ๊ธ์ผ๋ก ๊ฒฝํฉ์ด ์ฌํด ๋น๊ถ์ฅ |
| ์ ํ๋ฆฌ์ผ์ด์ ์์ฑ(UUID ๋ฑ) | ๊ฐ๋ฅ | DB ์๋ณต ์์, ๋จ ๋๋ค UUID๋ B-tree ์ธ๋ฑ์ค ๋จํธํ ์ ์ |
SEQUENCE์ pooled ์ตํฐ๋ง์ด์
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "order_seq")
@SequenceGenerator(name = "order_seq", sequenceName = "order_seq", allocationSize = 50)
private Long id;
allocationSize(JPA ๊ธฐ๋ณธ๊ฐ 50)๊ฐ 1๋ณด๋ค ํฌ๋ฉด Hibernate๋ pooled ๊ณ์ด ์ตํฐ๋ง์ด์ ๋ฅผ ์ฌ์ฉํด ์ํ์ค๋ฅผ ํ ๋ฒ ํธ์ถํ ๋๋ง๋ค 50๊ฐ ๋ฒ์์ ID๋ฅผ ๋ฉ๋ชจ๋ฆฌ์์ ๋๋ ์๋๋ค. 1๋ง ๊ฑด ์ ์ฅ ์ ์ํ์ค ํธ์ถ์ด 1๋ง ๋ฒ์ด ์๋๋ผ ์ฝ 200๋ฒ์
๋๋ค. ์ด๋ DB ์ํ์ค์ INCREMENT BY ๊ฐ๊ณผ allocationSize๋ฅผ ์ผ์น์์ผ์ผ ํฉ๋๋ค. ์ด๊ธ๋๋ฉด ID ์ถฉ๋์ด๋ ์์์น ๋ชปํ ๊ฐ๊ฒฉ์ด ์๊ธธ ์ ์์ต๋๋ค. ์ฌ๋ฌ ์๋ฒ๊ฐ ๋์์ ID๋ฅผ ๋ฐ์ ์ฐ๋ฏ๋ก ID๊ฐ ์๊ฒฉํ ์ฐ์์ ์ด์ง ์๋ค๋ ์ ๋ ๋ฐ์๋ค์ฌ์ผ ํฉ๋๋ค.
MySQL 8.0์ ์ํ์ค ๊ฐ์ฒด๊ฐ ์์ผ๋ฏ๋ก IDENTITY๋ฅผ ์ฐ๋ ๊ฒฝ์ฐ๊ฐ ๋๋ถ๋ถ์
๋๋ค. ์ด๋ ๋๋ INSERT๊ฐ ์ค์ํ๋ค๋ฉด ํด๋น ๊ฒฝ๋ก๋ง JdbcTemplate์ batchUpdate()๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ์์ด ์ค๋ฌด์์ ์์ฃผ ์ฐ์
๋๋ค. MariaDB๋ 10.3๋ถํฐ ์ํ์ค๋ฅผ ์ง์ํฉ๋๋ค.
๋๋ผ์ด๋ฒ ์์ค์ ๋ง์ง๋ง ํ ์
rewriteBatchedStatements=true๋ฅผ JDBC URL์ ์ถ๊ฐํ๋ฉด ๋ฐฐ์น๋ INSERT๋ฅผ INSERT ... VALUES (...),(...),(...) ๋ค์ค ํ ๋ฌธ์ฅ์ผ๋ก ์ฌ์์ฑํด ์ ์กํฉ๋๋ค. ์ด ์ต์
์์ด๋ ๋ฐฐ์น์ฌ๋ ๋ฌธ์ฅ์ ๊ฐ๋ณ์ ์ผ๋ก ๋ณด๋ด ์ด์ ์ด ํฌ๊ฒ ์ค์ด๋ญ๋๋ค.reWriteBatchedInserts=true๋ก ๋น์ทํ๊ฒ ๋ค์ค ํ INSERT๋ก ์ฌ์์ฑํ ์ ์์ต๋๋ค.๋ฐฐ์น ๋ฃจํ์ ์ ์: flush & clear
@Transactional
public void importProducts(List<ProductRow> rows) {
int batchSize = 50; // hibernate.jdbc.batch_size์ ๋ง์ถค
for (int i = 0; i < rows.size(); i++) {
em.persist(Product.from(rows.get(i)));
if ((i + 1) % batchSize == 0) {
em.flush(); // ์์ธ INSERT๋ฅผ ๋ฐฐ์น๋ก ์ ์ก
em.clear(); // 1์ฐจ ์บ์ยท์ค๋
์ท ๋น์ฐ๊ธฐ โ ๋ฉ๋ชจ๋ฆฌ ์ผ์ ์ ์ง
}
}
}
clear() ์์ด 10๋ง ๊ฑด์ persistํ๋ฉด ์์์ฑ ์ปจํ
์คํธ์ 10๋ง ๊ฐ ์ํฐํฐ๊ฐ ์์ฌ ๋ฉ๋ชจ๋ฆฌ๊ฐ ๊ณ์ ๋๊ณ , flush ๋๋ง๋ค ๋น๊ต ๋์์ด ์ปค์ ธ ๋ค๋ก ๊ฐ์๋ก ๋๋ ค์ง๋๋ค. ์ฃผ๊ธฐ์ ์ผ๋ก ๋น์ ์ฃผ๋ ๊ฒ๋ง์ผ๋ก ์ฒ๋ฆฌ ์๊ฐ์ด ์ ํ์ ๊ฐ๊น๊ฒ ์ ์ง๋ฉ๋๋ค. clear ์ดํ์๋ ์ด์ ์ํฐํฐ๊ฐ ์ค์์์ด ๋๋ฏ๋ก, ๊ทธ ๊ฐ์ฒด๋ฅผ ๋ค์ ์์ ํด๋ ๋ฐ์๋์ง ์๋๋ค๋ ์ ์ ์ฃผ์ํ์ธ์.
๋ฒํฌ ์ฐ์ฐ: ์ํฐํฐ๋ฅผ ๊ฑฐ์น์ง ์๋ UPDATE/DELETE
@Modifying(clearAutomatically = true)
@Query("update Product p set p.price = p.price * 1.1 where p.category = :c")
int raisePrice(@Param("c") String category);
"์นดํ
๊ณ ๋ฆฌ ์ ์ฒด ๊ฐ๊ฒฉ 10% ์ธ์"์ฒ๋ผ ์กฐ๊ฑด์ ๋ง๋ ๋ค์ ํ์ ๋๊ฐ์ด ๋ฐ๊พธ๋ ์์
์ด๋ผ๋ฉด, ์ํฐํฐ๋ฅผ ํ๋ํ๋ ๋ก๋ฉํด ๋ณ๊ฒฝ ๊ฐ์ง์ํค๋ ๊ฒ๋ณด๋ค JPQL ๋ฒํฌ UPDATE ํ ๋ฌธ์ฅ์ด ์๋์ ์ผ๋ก ๋น ๋ฆ
๋๋ค. ๋จ, ๋ฒํฌ ์ฐ์ฐ์ ์์์ฑ ์ปจํ
์คํธ๋ฅผ ์ฐํํด DB์ ์ง์ ์คํ๋๋ฏ๋ก, ์ด๋ฏธ ๋ก๋ฉ๋ ์ํฐํฐ๋ ์๋ ๊ฐ์ ๋ค๊ณ ์๊ฒ ๋ฉ๋๋ค. ๋ฒํฌ ์ฐ์ฐ์ ํธ๋์ญ์
์ ๋งจ ์์์ ์คํํ๊ฑฐ๋, ์คํ ํ ์์์ฑ ์ปจํ
์คํธ๋ฅผ ๋น์ฐ๋(clearAutomatically = true) ์ต๊ด์ด ํ์ํฉ๋๋ค.
StatelessSession: ์์ฒฉ ์๋ ์จ์ดํฐ
Hibernate์ StatelessSession์ 1์ฐจ ์บ์, ๋ณ๊ฒฝ ๊ฐ์ง, ์ฐ๊ธฐ ์ง์ฐ, cascade, ์ง์ฐ ๋ก๋ฉ์ด ์๋ ๊ฐ๋ฒผ์ด ์ธ์
์
๋๋ค. ํธ์ถ ์ฆ์ SQL์ด ๋๊ฐ๋ JDBC์ ๊ฐ๊น์ด ๋์์ด์ง๋ง ์ํฐํฐ ๋งคํ์ ๊ทธ๋๋ก ํ์ฉํ ์ ์์ต๋๋ค. ์๋ฐฑ๋ง ๊ฑด ETL์ฒ๋ผ ์ํ ๊ด๋ฆฌ๊ฐ ์คํ๋ ค ์ง์ด ๋๋ ์์
์ ์ด์ธ๋ฆฝ๋๋ค.
๐ฏ 8์ฅ. UPDATE ๋ฌธ์ฅ ๋ค๋ฌ๊ธฐ์ ๋ณ๊ฒฝ ๊ฐ์ง ํ๋
@DynamicUpdate
Hibernate๋ ๊ธฐ๋ณธ์ ์ผ๋ก ๋ชจ๋ ์ปฌ๋ผ์ SET ํ๋ UPDATE๋ฅผ ๋ฏธ๋ฆฌ ๋ง๋ค์ด ์ฌ์ฌ์ฉํฉ๋๋ค. ๋ฌธ์ฅ์ด ํญ์ ๊ฐ์ผ๋ SQL ์บ์ฑ๊ณผ JDBC ๋ฐฐ์น์ ์ ๋ฆฌํ๋ค๋ ํฉ๋ฆฌ์ ์ค๊ณ์
๋๋ค. ๊ทธ๋ฐ๋ฐ ์ปฌ๋ผ์ด ์์ญ ๊ฐ์ด๊ฑฐ๋ ํฐ TEXT ์ปฌ๋ผ์ด ์๋ ํ
์ด๋ธ์์ ํ ํ๋๋ง ๋ฐ๊ฟ ๋๋ ๋ญ๋น๊ฐ ๋ ์ ์์ต๋๋ค. ์ํฐํฐ์ @DynamicUpdate๋ฅผ ๋ถ์ด๋ฉด ๋ณ๊ฒฝ๋ ์ปฌ๋ผ๋ง ํฌํจํ UPDATE๋ฅผ ๋ฐํ์์ ์์ฑํฉ๋๋ค.
์ ์ก ๋ฐ์ดํฐ ๊ฐ์, ๋ณ๊ฒฝ๋์ง ์์ ์ปฌ๋ผ์ ๊ฑธ๋ฆฐ ์ธ๋ฑ์ค/ํธ๋ฆฌ๊ฑฐ ๋ถ๋ด ๊ฐ์, ์๋ก ๋ค๋ฅธ ์ปฌ๋ผ์ ๋์์ ์์ ํ๋ ํธ๋์ญ์ ๊ฐ ๋ฎ์ด์ฐ๊ธฐ ์ํ ๊ฐ์
๋ฌธ์ฅ์ด ๋งค๋ฒ ๋ฌ๋ผ์ง ์ ์์ด ๋ฐฐ์น ํจ์จ๊ณผ ๋ฌธ์ฅ ์บ์ ์ฌ์ฌ์ฉ๋ฅ ์ด ๋จ์ด์ง. ์ปฌ๋ผ์ด ์ ์ ํ ์ด๋ธ์์๋ ์ด๋์ด ๊ฑฐ์ ์์
๋ฐ์ดํธ์ฝ๋ ํฅ์(Bytecode Enhancement)
Hibernate๋ ๋น๋ ์์ ์ ์ํฐํฐ ํด๋์ค ๋ฐ์ดํธ์ฝ๋๋ฅผ ์์ ํ๋ enhancement ๊ธฐ๋ฅ์ ์ ๊ณตํฉ๋๋ค(Maven/Gradle ํ๋ฌ๊ทธ์ธ). ํ์ฑํํ๋ฉด setter ํธ์ถ ์ ๋ณ๊ฒฝ ์ฌ๋ถ๋ฅผ ์ํฐํฐ๊ฐ ์ง์ ๊ธฐ๋ก(inline dirty tracking)ํด flush ๋ ์ ์ฒด ์ค๋
์ท ๋น๊ต๋ฅผ ์๋ตํ ์ ์๊ณ , ๊ธฐ๋ณธ ํ๋์ ์ง์ฐ ๋ก๋ฉ(์: ํฐ BLOB ์ปฌ๋ผ์ @Basic(fetch = LAZY)๋ก ๋ฏธ๋ฃจ๊ธฐ)๋ ๊ฐ๋ฅํด์ง๋๋ค. ๋น๋ ํ์ดํ๋ผ์ธ์ด ๋ณต์กํด์ง๊ณ ํ๋ก์ ๋์์ด ๋ฐ๋๋ ๋ฉด์ด ์์ผ๋, ํจ๊ณผ๋ฅผ ์ธก์ ํ ๋ค ๋์
ํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
OneToOne ์๋ฐฉํฅ์ ์จ์ ์ฟผ๋ฆฌ
์ธ๋ ํค๋ฅผ ๊ฐ์ง ์์ ์ชฝ(mappedBy ์ชฝ)์ @OneToOne์ LAZY๋ก ์ ์ธํด๋ ์ฆ์ ๋ก๋ฉ์ฒ๋ผ ๋์ํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค. ํ๋ก์๋ฅผ ๋ฃ์ผ๋ ค๋ฉด "์ฐ๊ด ๋์์ด ์๋์ง ์๋์ง"๋ฅผ ์์์ผ ํ๋๋ฐ, ์ธ๋ ํค๊ฐ ์๋ ํ
์ด๋ธ์ ์์ผ๋ ์กฐํํด ๋ณด๊ธฐ ์ ์๋ null์ธ์ง ์ ์ ์๊ธฐ ๋๋ฌธ์
๋๋ค. ์ด๋ก ์ธํด ๋ชฉ๋ก ์กฐํ ์ N+1์ด ์๊น๋๋ค. ํด๊ฒฐ์ ์ธ๋ ํค๋ฅผ ์ฃผ๋ก ์กฐํํ๋ ์ชฝ์ ๋๊ฑฐ๋, ๋จ๋ฐฉํฅ์ผ๋ก ๋ฐ๊พธ๊ฑฐ๋, @MapsId๋ก ๊ธฐ๋ณธ ํค๋ฅผ ๊ณต์ ํ๋ ์ค๊ณ๋ฅผ ๊ฒํ ํ๋ ๊ฒ์
๋๋ค.
cascade์ orphanRemoval์ ๋น์ฉ
CascadeType.ALL๊ณผ orphanRemoval = true๋ ํธ๋ฆฌํ์ง๋ง, ๋ถ๋ชจ๋ฅผ ์ญ์ ํ ๋ Hibernate๋ ์์ ์ปฌ๋ ์
์ ๋ก๋ฉํด ํ ๊ฑด์ฉ DELETEํฉ๋๋ค. ์์์ด 1๋ง ๊ฐ๋ผ๋ฉด SELECT ํ DELETE 1๋ง ๋ฒ(๋ฐฐ์น ์ค์ ์ ๋ฌถ์ด๊ธด ํจ)์
๋๋ค. ๋๋ ์ญ์ ๋ ๋ฒํฌ DELETE๋ก ์์๋ถํฐ ์ง์ฐ๊ณ ๋ถ๋ชจ๋ฅผ ์ง์ฐ๋ ๋ฐฉ์์ด ๋น ๋ฆ
๋๋ค. ๋ํ @OneToMany ๋จ๋ฐฉํฅ + @JoinColumn ๋งคํ์ INSERT ํ ์ธ๋ ํค๋ฅผ ๋ณ๋ UPDATE๋ก ์ฑ์ฐ๋ ์ถ๊ฐ ๋ฌธ์ฅ์ด ์๊ธฐ๋ฏ๋ก, ์ฑ๋ฅ ๊ด์ ์์๋ ์๋ฐฉํฅ ๋งคํ(๋ค ์ชฝ์ด ์ธ๋ ํค ๊ด๋ฆฌ)์ด ๊ถ์ฅ๋ฉ๋๋ค.
๐ 9์ฅ. ํ์ด์ง ์ต์ ํ: OFFSET์ ๋ช๊ณผ ํค์ ํ์ด์ง๋ค์ด์
๊ฒ์ํ์ 1ํ์ด์ง๋ ๋น ๋ฅธ๋ฐ 5000ํ์ด์ง๋ ๋๋ฆฌ๋ค? OFFSET ๋ฐฉ์์ ๋ณธ์ง์ ํ๊ณ์
๋๋ค. LIMIT 20 OFFSET 100000์ DB๊ฐ ์์ 100,000ํ์ ์ฝ๊ณ ๋ฒ๋ฆฐ ๋ค 20ํ์ ๋๋ ค์ค๋ค๋ ๋ป์
๋๋ค. ๋ค ํ์ด์ง๋ก ๊ฐ์๋ก ์ฝ๋ ์์ด ์ ํ์ผ๋ก ๋์ด๋ฉ๋๋ค.
ํค์ (No-Offset) ํ์ด์ง๋ค์ด์
// ๋ง์ง๋ง์ผ๋ก ๋ณธ id๋ณด๋ค ์์ ๊ฒ 20๊ฐ (id ๋ด๋ฆผ์ฐจ์ ๋ชฉ๋ก)
@Query("""
select p from Post p
where p.id < :lastId
order by p.id desc
""")
List<Post> findNext(@Param("lastId") Long lastId, Pageable limit20);
"๋ช ๋ฒ์งธ ํ์ด์ง"๊ฐ ์๋๋ผ "๋ง์ง๋ง์ผ๋ก ๋ณธ ํค ๋ค์๋ถํฐ"๋ฅผ ๋ฌป์ต๋๋ค. ์ ๋ ฌ ์ปฌ๋ผ์ ์ธ๋ฑ์ค๊ฐ ์์ผ๋ฉด DB๋ ํด๋น ์์น๋ก ๋ฐ๋ก ์ด๋ํด 20ํ๋ง ์ฝ์ต๋๋ค. ๋ฌดํ ์คํฌ๋กค, ํผ๋, ๋๋ ๋ฐ์ดํฐ ๋ฐฐ์น ์ํ์ ์ต์ ์
๋๋ค. ์ ๋ ฌ ๊ธฐ์ค์ด ๊ณ ์ ํ์ง ์๋ค๋ฉด(์: ์์ฑ์ผ) (created_at, id)์ฒ๋ผ ๊ณ ์ ์ปฌ๋ผ์ ์กฐํฉํด์ผ ๋๋ฝยท์ค๋ณต์ด ์๊ธฐ์ง ์์ต๋๋ค. ๋จ์ ์ ์์ ํ์ด์ง ๋ฒํธ๋ก ์ ํํ ์ ์๋ค๋ ๊ฒ์
๋๋ค. Spring Data JPA 3.1๋ถํฐ๋ ScrollPosition/Window๋ฅผ ์ด์ฉํ ํค์
๊ธฐ๋ฐ ์คํฌ๋กค API๋ ์ ๊ณต๋ฉ๋๋ค.
COUNT ์ฟผ๋ฆฌ ๋ค์ด์ดํธ
Spring Data์ Page๋ ์ ์ฒด ๊ฐ์๋ฅผ ์ํด COUNT ์ฟผ๋ฆฌ๋ฅผ ์ถ๊ฐ๋ก ์คํํฉ๋๋ค. ๋ณธ ์ฟผ๋ฆฌ์ fetch join์ด๋ ์ฌ๋ฌ ์กฐ์ธ์ด ์์ผ๋ฉด COUNT๋ ๋ฌด๊ฑฐ์์ง๋๋ค.
@Query(value = "...", countQuery = "select count(o) from Order o")๋ก ์กฐ์ธ ์๋ ๋จ์ COUNT๋ฅผ ์ง์ ํฉ๋๋ค.Slice๋ฅผ ๋ฐํ ํ์
์ผ๋ก ์ฐ๋ฉด ์์ฒญ ํฌ๊ธฐ+1๊ฐ๋ฅผ ์กฐํํด "๋ค์ ํ์ด์ง ์กด์ฌ ์ฌ๋ถ"๋ง ํ๋จํ๊ณ COUNT๋ฅผ ์๋ตํฉ๋๋ค.PageableExecutionUtils).๐ง 10์ฅ. 2์ฐจ ์บ์์ ์ฟผ๋ฆฌ ์บ์: ๋์ฅ๊ณ ์ ๋ฏธ๋ฆฌ ๋ด์ ๋๊ธฐ
1์ฐจ ์บ์๊ฐ ์จ์ดํฐ ๊ฐ์ธ ์์ฒฉ์ด๋ผ๋ฉด, 2์ฐจ ์บ์๋ ์ฃผ๋ฐฉ ์ ๊ณต์ฉ ๋์ฅ๊ณ ์ ๋๋ค. ์ธ์ ๊ฐ์ ๊ณต์ ๋๋ฉฐ ์ ํ๋ฆฌ์ผ์ด์ (SessionFactory) ๋ฒ์๋ก ์ด์ ์์ต๋๋ค. ์ํฐํฐ๋ฅผ ID๋ก ์กฐํํ ๋ 1์ฐจ ์บ์ โ 2์ฐจ ์บ์ โ DB ์์๋ก ์ฐพ์ต๋๋ค.
์ค์ ์์ (JCache + Ehcache 3)
// build.gradle
implementation 'org.hibernate.orm:hibernate-jcache'
implementation 'org.ehcache:ehcache::jakarta'
# application.yml
spring:
jpa:
properties:
hibernate:
cache:
use_second_level_cache: true
region.factory_class: jcache
jakarta.persistence.sharedCache.mode: ENABLE_SELECTIVE
// ์ํฐํฐ
@Entity
@Cacheable
@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Category { ... }
2์ฐจ ์บ์์๋ ์ํฐํฐ ๊ฐ์ฒด ์์ฒด๊ฐ ์๋๋ผ ๋ถํด๋ ์ํ(dehydrated state)๊ฐ ์ ์ฅ๋๋ฉฐ, ๊บผ๋ผ ๋ ์ ์ํฐํฐ ์ธ์คํด์ค๋ก ์กฐ๋ฆฝ๋ฉ๋๋ค. ๊ทธ๋์ ์ธ์ ๋ง๋ค ๋ค๋ฅธ ๊ฐ์ฒด๊ฐ ๋ฐํ๋์ด ๋์์ฑ ๋ฌธ์ ๋ฅผ ํผํฉ๋๋ค.
| ๋์์ฑ ์ ๋ต | ์ฉ๋ | ํน์ง |
|---|---|---|
| READ_ONLY | ์ ๋ ์ ๋ฐ๋๋ ๋ฐ์ดํฐ | ๊ฐ์ฅ ๋น ๋ฆ. ์์ ์๋ ์ ์์ธ |
| NONSTRICT_READ_WRITE | ๊ฐ๋ ๋ฐ๋๊ณ ์ฝ๊ฐ์ ๋ถ์ผ์น ํ์ฉ | ์ ๊ธ ์์ด ๋ฌดํจํ, ์งง์ ์๊ฐ ์ ๊ฐ ๋ ธ์ถ ๊ฐ๋ฅ |
| READ_WRITE | ์์ฃผ ์ฝ๊ณ ๊ฐ๋ ์์ | ์ํํธ ๋ฝ์ผ๋ก ์ผ๊ด์ฑ ๊ฐํ |
| TRANSACTIONAL | JTA ํธ๋์ญ์ ์บ์ | XA ์ง์ ์บ์ ํ๋ก๋ฐ์ด๋ ํ์ |
์ฟผ๋ฆฌ ์บ์๋ ์ ์คํ๊ฒ
hibernate.cache.use_query_cache=true๋ก ์ฟผ๋ฆฌ ์บ์๋ฅผ ์ผ๋ฉด JPQL๊ณผ ํ๋ผ๋ฏธํฐ ์กฐํฉ์ ๊ฒฐ๊ณผ(์ํฐํฐ๋ผ๋ฉด ID ๋ชฉ๋ก)๋ฅผ ์บ์ํฉ๋๋ค. ํ์ง๋ง ์ฟผ๋ฆฌ ๊ฒฐ๊ณผ๋ ๊ด๋ จ ํ
์ด๋ธ์ ๋จ ํ ๊ฑด์ด๋ผ๋ ๋ณ๊ฒฝ์ด ์๊ธฐ๋ฉด ๋ฌดํจํ๋ฉ๋๋ค(ํ
์ด๋ธ๋ณ ๊ฐฑ์ ํ์์คํฌํ๋ก ํ๋จ). ์ฐ๊ธฐ๊ฐ ์ฆ์ ํ
์ด๋ธ์์๋ ์ ์ค๋ฅ ์ด ๋ฎ๊ณ ๋ฌดํจํ ์ค๋ฒํค๋๋ง ๋์ด๋ฉ๋๋ค. ๋ ์ํฐํฐ ๊ฒฐ๊ณผ๋ฅผ ์บ์ํ ๋ ํด๋น ์ํฐํฐ๊ฐ 2์ฐจ ์บ์์ ์์ผ๋ฉด ID ๋ชฉ๋ก๋ง ์ป๊ณ ์ํฐํฐ๋ ํ๋์ฉ DB์์ ์กฐํํด ์คํ๋ ค N+1์ด ๋ ์ ์์ต๋๋ค.
2์ฐจ ์บ์์ ์ด์์ ์ธ ๋ฐ์ดํฐ๋ ์์ฃผ ์ฝํ๊ณ , ๋๋ฌผ๊ฒ ๋ฐ๋๋ฉฐ, ID๋ก ์กฐํ๋๋ ๋ฐ์ดํฐ์ ๋๋ค. ๊ตญ๊ฐ ์ฝ๋, ์นดํ ๊ณ ๋ฆฌ, ์ํ ์ต์ ์ ์ ๊ฐ์ ์ฐธ์กฐ ๋ฐ์ดํฐ๊ฐ ๋ํ์ ์ ๋๋ค.
๐ 11์ฅ. ์ปค๋ฅ์ ํ: ์ฃผ๋ฐฉ ์ถ์ ๋ฌธ์ ๊ฐ์
์๋ฌด๋ฆฌ SQL์ ๋ค๋ฌ์ด๋ ์ปค๋ฅ์ ์ ์ป์ผ๋ ค๊ณ ์ค ์ ์๋ค๋ฉด ์์ฉ์์ต๋๋ค. Spring Boot์ ๊ธฐ๋ณธ ์ปค๋ฅ์ ํ์ HikariCP์ ๋๋ค.
| ์ค์ | ๊ธฐ๋ณธ๊ฐ | ์๋ฏธ |
|---|---|---|
| maximumPoolSize | 10 | ํ์ ์ต๋ ์ปค๋ฅ์ ์ |
| minimumIdle | maximumPoolSize์ ๋์ผ | ์ ํด ์ํ๋ก ์ ์งํ ์ต์ ์. ๊ณ ์ ํฌ๊ธฐ ํ ๊ถ์ฅ |
| connectionTimeout | 30000ms | ์ปค๋ฅ์ ์ ๊ธฐ๋ค๋ฆฌ๋ ์ต๋ ์๊ฐ |
| idleTimeout | 600000ms | ์ ํด ์ปค๋ฅ์ ์ ๊ฑฐ ์๊ฐ(minimumIdle < max์ผ ๋) |
| maxLifetime | 1800000ms | ์ปค๋ฅ์ ์ต๋ ์๋ช . DB์ wait_timeout๋ณด๋ค ๋ช ์ด ์ด์ ์งง๊ฒ |
| leakDetectionThreshold | 0(๋นํ์ฑ) | ์ง์ ์๊ฐ ์ด์ ๋ฐํ๋์ง ์์ผ๋ฉด ๋์ ๊ฒฝ๊ณ ๋ก๊ทธ |
ํ์ ํด์๋ก ์ข๋ค? ์๋์
HikariCP ์ํค์ "About Pool Sizing" ๋ฌธ์๋
connections = (core_count ร 2) + effective_spindle_count๋ผ๋ PostgreSQL ์ปค๋ฎค๋ํฐ ์ถ์ ๊ณต์์ ์ถ๋ฐ์ ์ผ๋ก ์๊ฐํ๋ฉฐ, ์์ ํ์ด ์คํ๋ ค ์ฒ๋ฆฌ๋์ด ๋์ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค๊ณ ์ค๋ช
ํฉ๋๋ค. DB ์๋ฒ์ CPU ์ฝ์ด ์๋ณด๋ค ํจ์ฌ ๋ง์ ์ฟผ๋ฆฌ๊ฐ ๋์์ ์คํ๋๋ฉด ์ปจํ
์คํธ ์ค์์นญ๊ณผ ์ ๊ธ ๊ฒฝํฉ์ผ๋ก ์ ์ฒด๊ฐ ๋๋ ค์ง๊ธฐ ๋๋ฌธ์
๋๋ค. ์๋ฒ ์ธ์คํด์ค๊ฐ 10๋์ด๊ณ ๊ฐ์ ํ 50์ด๋ฉด DB ์
์ฅ์์๋ ์ปค๋ฅ์
500๊ฐ๋ผ๋ ์ ๋ ๊ณ์ฐ์ ๋ฃ์ด์ผ ํฉ๋๋ค.
์ปค๋ฅ์ ์ ์ ์๊ฐ์ ์ค์ด๋ ์ต๊ด
autoCommit=false์ hibernate.connection.provider_disables_autocommit=true๋ฅผ ํจ๊ป ์ฐ๋ฉด, Hibernate๊ฐ ํธ๋์ญ์
์์ ์ autocommit ํ์ธ์ ์ํด ์ปค๋ฅ์
์ ์ฆ์ ์ป์ง ์์ ์ค์ ์ฒซ SQL ์์ ๊น์ง ํ๋์ ๋ฆ์ถ ์ ์์ต๋๋ค.Connection is not available, request timed out after 30000ms ์์ธ๊ฐ ๋ณด์ธ๋ค๋ฉด ํ ํฌ๊ธฐ๋ฅผ ๋๋ฆฌ๊ธฐ ์ ์ ๋จผ์ โ ๋๋ฆฐ ์ฟผ๋ฆฌ โก ๊ธด ํธ๋์ญ์
โข ์ปค๋ฅ์
๋์ โฃ OSIV ์ฌ๋ถ๋ฅผ ํ์ธํ์ธ์. HikariCP ๋ฉํธ๋ฆญ(active, idle, pending)์ Micrometer๋ก ์์งํด ๋์๋ณด๋์ ๋์ ๋๋ฉด ๋ณ๋ชฉ ์์น๊ฐ ํ๋์ ๋ณด์
๋๋ค.
๐ง 12์ฅ. ์ฟผ๋ฆฌ ์คํ ๊ณํ ์บ์์ JDBC ์ธ๋ถ ํ๋
์ฟผ๋ฆฌ ํ๋ ์บ์์ IN ์ ํจ๋ฉ
Hibernate๋ JPQL์ SQL๋ก ๋ฒ์ญํ ๊ฒฐ๊ณผ๋ฅผ ์ฟผ๋ฆฌ ํ๋ ์บ์์ ์ ์ฅํฉ๋๋ค(์ต๋ ํฌ๊ธฐ hibernate.query.plan_cache_max_size, ๊ธฐ๋ณธ 2048). ๊ทธ๋ฐ๋ฐ where id in :ids์ ๋ฆฌ์คํธ ํฌ๊ธฐ๊ฐ 3, 4, 5... ๋ก ๋งค๋ฒ ๋ฌ๋ผ์ง๋ฉด SQL ๋ฌธ์์ด์ด ์ ๋ถ ๋ฌ๋ผ์ ธ ์บ์ ํญ๋ชฉ์ด ํญ์ฆํ๊ณ , DB ์ชฝ ์คํ ๊ณํ ์บ์ ํจ์จ๋ ๋จ์ด์ง๋๋ค.
spring.jpa.properties.hibernate.query.in_clause_parameter_padding: true
์ด ์ค์ ์ IN ์ ํ๋ผ๋ฏธํฐ ์๋ฅผ 2์ ๊ฑฐ๋ญ์ ๊ณฑ(2, 4, 8, 16...)์ผ๋ก ๋ง์ถ๊ณ ๋จ๋ ์๋ฆฌ๋ฅผ ๋ง์ง๋ง ๊ฐ์ผ๋ก ์ฑ์๋๋ค. ํ๋ผ๋ฏธํฐ 5๊ฐ๋ 8๊ฐ ์๋ฆฌ๋ก ๋ฐ์ธ๋ฉ๋๋ฏ๋ก ์๋ก ๋ค๋ฅธ SQL ๋ฌธ์ฅ ์๊ฐ ํฌ๊ฒ ์ค์ด๋ญ๋๋ค.
๋ฌธ์์ด ์ฐ๊ฒฐ ๋์ ๋ฐ์ธ๋ ํ๋ผ๋ฏธํฐ
JPQL์ ๊ฐ์ ๋ฌธ์์ด๋ก ์ด์ด ๋ถ์ด๋ฉด SQL ์ธ์ ์
์ํ์ ๋ฌผ๋ก , ๊ฐ๋ง๋ค ๋ค๋ฅธ ์ฟผ๋ฆฌ๋ก ์ธ์๋์ด ํ๋ ์บ์๊ฐ ๋ฌด๋ ฅํ๋ฉ๋๋ค. ํญ์ :name์ด๋ Criteria/QueryDSL ํ๋ผ๋ฏธํฐ๋ฅผ ์ฐ์ธ์.
fetch size์ ์คํธ๋ฆฌ๋ฐ
hibernate.jdbc.fetch_size ๋๋ ์ฟผ๋ฆฌ ํํธ๋ก ์ง์ ํ๋ fetch size๋ ๊ฒฐ๊ณผ๋ฅผ ํ ๋ฒ์ ๋ช ํ์ฉ ๋๋ผ์ด๋ฒ๊ฐ ๊ฐ์ ธ์ฌ์ง ๊ฒฐ์ ํฉ๋๋ค. Oracle ๋๋ผ์ด๋ฒ ๊ธฐ๋ณธ์ 10ํ์ด๋ผ ๋๋ ์กฐํ์์ ์๋ณต์ด ๋ง์์ง๋ฏ๋ก ๋๋ฆฌ๋ฉด ํจ๊ณผ๊ฐ ํฝ๋๋ค. ๋ฐ๋๋ก PostgreSQL ๋๋ผ์ด๋ฒ๋ autocommit์ด ๊บผ์ ธ ์์ ๋๋ง fetch size์ ๋ฐ๋ฅธ ์ปค์ ๊ธฐ๋ฐ ์กฐํ๋ฅผ ํ๊ณ , MySQL Connector/J๋ ๊ธฐ๋ณธ์ ์ผ๋ก ๊ฒฐ๊ณผ ์ ์ฒด๋ฅผ ๋ฉ๋ชจ๋ฆฌ๋ก ์ฝ๋๋ค๋ ์ฐจ์ด๊ฐ ์์ต๋๋ค(MySQL์ useCursorFetch=true๋ fetch size Integer.MIN_VALUE ์คํธ๋ฆฌ๋ฐ ๋ฑ ๋ณ๋ ๋ฐฉ์). ๋๋ ๋ฐ์ดํฐ๋ Spring Data์ Stream<T> ๋ฐํ + ์ฝ๊ธฐ ์ ์ฉ ํธ๋์ญ์
+ ์ฃผ๊ธฐ์ detach ์กฐํฉ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ผ์ ํ๊ฒ ์ ์งํ ์ ์์ต๋๋ค.
๐๏ธ 13์ฅ. ๊ฒฐ๊ตญ์ DB: ์ธ๋ฑ์ค์ ์คํ ๊ณํ
JPA ํ๋์ ์ด์ฌํ ํด๋ ์์ฑ๋ SQL์ด ํ ์ค์บ์ ํ๋ค๋ฉด ์๋ฏธ๊ฐ ๋ฐ๊ฐ๋ฉ๋๋ค. ORM์ SQL์ ๋์ ์จ ์ค ๋ฟ, ์คํ ๊ณํ๊น์ง ์ฑ ์์ง์ง ์์ต๋๋ค.
type=ALL(ํ ์ค์บ), PostgreSQL์ Seq Scan์ด ํฐ ํ
์ด๋ธ์์ ๋ณด์ด๋ฉด ์์ฌํฉ๋๋ค.where order_id = ?)๊ฐ ๋๋ฆฌ๋ค๋ฉด 1์์๋ก ํ์ธํ์ธ์. MySQL InnoDB๋ FK์ ์ธ๋ฑ์ค๋ฅผ ์๊ตฌํด ์๋ ์์ฑํฉ๋๋ค.@Table(indexes = @Index(columnList = "member_id, created_at"))์ฒ๋ผ ์ํฐํฐ์ ์ธ๋ฑ์ค๋ฅผ ๊ธฐ์ ํ ์ ์์ง๋ง, ์ด๊ฒ์ ์คํค๋ง ์๋ ์์ฑ ์์๋ง ๋ฐ์๋ฉ๋๋ค. ์ด์ ํ๊ฒฝ์์๋ ddl-auto๋ฅผ none์ด๋ validate๋ก ๋๊ณ FlywayยทLiquibase ๊ฐ์ ๋ง์ด๊ทธ๋ ์ด์
๋๊ตฌ๋ก ์คํค๋ง์ ์ธ๋ฑ์ค๋ฅผ ๊ด๋ฆฌํ๋ ๊ฒ์ด ํ์ค์
๋๋ค.
where function('date', o.createdAt) = :d๋ lower(m.email)์ฒ๋ผ ์ปฌ๋ผ์ ํจ์๋ก ๊ฐ์ธ๋ฉด ์ผ๋ฐ ์ธ๋ฑ์ค๋ฅผ ํ์ฉํ์ง ๋ชปํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค. ๋ฒ์ ์กฐ๊ฑด(createdAt >= :start and createdAt < :end)์ผ๋ก ๋ฐ๊พธ๊ฑฐ๋, DB๊ฐ ์ง์ํ๋ฉด ํจ์ ๊ธฐ๋ฐ ์ธ๋ฑ์ค๋ฅผ ๊ณ ๋ คํ์ธ์.
๐ 14์ฅ. ๋์์ฑ ์ ์ด์ ์ฑ๋ฅ์ ์ค๋ค๋ฆฌ๊ธฐ
์ฑ๋ฅ ์ต์ ํ๋ ์ ํฉ์ฑ์ ํฌ์ํ์ง ์๋ ๋ฒ์์์๋ง ์๋ฏธ๊ฐ ์์ต๋๋ค. JPA๊ฐ ์ ๊ณตํ๋ ๋ ๊ฐ์ง ์ ๊ธ ๋ฐฉ์์ ์ฑ๋ฅ ํน์ฑ์ด ์ ๋ฐ๋์ ๋๋ค.
์ํฐํฐ์ ๋ฒ์ ํ๋๋ฅผ ๋๊ณ UPDATE ์
where id=? and version=?๋ก ํ์ธํฉ๋๋ค. ์ถฉ๋ ์ OptimisticLockException. ์ ๊ธ ๋๊ธฐ๊ฐ ์์ด ์ถฉ๋์ด ๋๋ฌธ ํ๊ฒฝ์์ ์ฒ๋ฆฌ๋์ด ๋์ต๋๋ค. ๋์ ์ถฉ๋ ์ ์ฌ์๋ ๋ก์ง์ด ํ์ํฉ๋๋ค.SELECT ... FOR UPDATE๋ก ํ์ ์ ๊ธ๋๋ค. ์ฌ๊ณ ์ฐจ๊ฐ์ฒ๋ผ ์ถฉ๋์ด ์ฆ์ ๊ณณ์ ํ์คํ์ง๋ง, ์ ๊ธ ๋๊ธฐ๋ก ์ฒ๋ฆฌ๋์ด ๋จ์ด์ง๊ณ ๋ฐ๋๋ฝ ์ํ์ด ์์ต๋๋ค. jakarta.persistence.lock.timeout ํํธ๋ก ๋๊ธฐ ์๊ฐ์ ์ ํํ์ธ์.์ ์ฐฉ์ ์ฟ ํฐ์ฒ๋ผ ํ๋์ ํ์ ๊ฒฝํฉ์ด ๋ชฐ๋ฆฌ๋ ๊ฒฝ์ฐ๋ ์ ๊ธ ์ ๋ต๋ง์ผ๋ก ํ๊ณ๊ฐ ์์ด,
update coupon set remain = remain - 1 where id = ? and remain > 0 ๊ฐ์ ์์์ ๋ฒํฌ UPDATE๋ Redis ๋ฑ ์ธ๋ถ ์นด์ดํฐ๋ฅผ ํจ๊ป ์ฐ๊ธฐ๋ ํฉ๋๋ค. ํต์ฌ์ "ํธ๋์ญ์
์ ์งง๊ฒ, ์ ๊ธ์ ๋ฆ๊ฒ ์ก๊ณ ๋นจ๋ฆฌ ๋๋๋ค"์
๋๋ค.
๐งช 15์ฅ. ์ค์ ์ฌ๋ก๋ก ์ฎ์ด ๋ณด๊ธฐ: ์ฃผ๋ฌธ ๋ชฉ๋ก API ํ๋ ์๋๋ฆฌ์ค
์ง๊ธ๊น์ง์ ๊ธฐ๋ฒ์ด ์ค์ ๋ก ์ด๋ป๊ฒ ์กฐํฉ๋๋์ง, ํํ "์ฃผ๋ฌธ ๋ชฉ๋ก ์กฐํ" API๋ฅผ ์๋ก ๋จ๊ณ๋ณ๋ก ๋ฐ๋ผ๊ฐ ๋ด ์๋ค. (์๋ ์ฟผ๋ฆฌ ์๋ ๊ธฐ๋ฒ์ ๋์ ์๋ฆฌ์ ๋ฐ๋ฅธ ๊ณ์ฐ ์์์ ๋๋ค.)
Before: ํ๋ฒํด ๋ณด์ด๋ ์ฝ๋
@GetMapping("/orders")
public Page<OrderResponse> list(Pageable pageable) {
return orderRepository.findAll(pageable)
.map(o -> new OrderResponse(
o.getId(),
o.getMember().getName(), // ToOne ์ง์ฐ ๋ก๋ฉ
o.getDelivery().getAddress(), // ToOne ์ง์ฐ ๋ก๋ฉ
o.getItems().stream() // ์ปฌ๋ ์
์ง์ฐ ๋ก๋ฉ
.map(i -> i.getProduct().getName()) // ์ํ ์ง์ฐ ๋ก๋ฉ
.toList()));
}
ํ์ด์ง ํฌ๊ธฐ 20, ์ฃผ๋ฌธ๋น ์ํ 3๊ฐ, ๋ชจ๋ ๋ค๋ฅธ ํ์ยท์ํ์ด๋ผ ๊ฐ์ ํ๋ฉด: ์ฃผ๋ฌธ ์กฐํ 1 + COUNT 1 + ํ์ 20 + ๋ฐฐ์ก 20 + ์์ดํ ์ปฌ๋ ์ 20 + ์ํ 60 = 122๊ฐ ์ฟผ๋ฆฌ. OSIV๊ฐ ์ผ์ ธ ์์ผ๋ ์ด ๋ชจ๋ ์ง์ฐ ๋ก๋ฉ์ด ์ปจํธ๋กค๋ฌ์์ ์ผ์ด๋๋ฉฐ ์ปค๋ฅ์ ์ ์ฅ๊ณ ์์ต๋๋ค.
After: ๋จ๊ณ๋ณ ๊ฐ์
select o from Order o join fetch o.member join fetch o.delivery โ ํ์ยท๋ฐฐ์ก 40๊ฐ ์ฟผ๋ฆฌ ์ ๊ฑฐ. ํ ์๊ฐ ๋์ง ์์ผ๋ ํ์ด์ง๋ ์์ .default_batch_fetch_size: 100 โ ์์ดํ
์ปฌ๋ ์
20๊ฐ ์ฟผ๋ฆฌ๊ฐ IN ์ฟผ๋ฆฌ 1๊ฐ๋ก, ์ํ 60๊ฐ ์ฟผ๋ฆฌ๊ฐ IN ์ฟผ๋ฆฌ 1๊ฐ๋ก.countQuery = "select count(o) from Order o"๋ก ์กฐ์ธ ์๋ COUNT.@Transactional(readOnly = true) ์๋น์ค๋ก ์ฎ๊ธฐ๊ณ OSIV ๋นํ์ฑํ.๊ฒฐ๊ณผ: ์ฃผ๋ฌธ ์กฐํ 1 + COUNT 1 + ์์ดํ IN 1 + ์ํ IN 1 = 4๊ฐ ์ฟผ๋ฆฌ. 122๊ฐ์์ 4๊ฐ๋ก, ๋ฐ์ดํฐ ์๊ณผ ์๊ด์์ด ํ์ด์ง๋น ์ฟผ๋ฆฌ ์๊ฐ ๊ณ ์ ๋ฉ๋๋ค. ์ฌ๊ธฐ์ ๋ชฉ๋ก ํ๋ฉด์ด ํ์ํ ์ปฌ๋ผ์ด ์ ๋ค๋ฉด DTO ํ๋ก์ ์ ์ผ๋ก ์ ํํด ์์์ฑ ์ปจํ ์คํธ ๊ด๋ฆฌ ๋น์ฉ๊น์ง ์์จ ์ ์์ต๋๋ค.
๋ ๋ค๋ฅธ ์ฌ๋ก: ์ผ๊ฐ ์ ์ฐ ๋ฐฐ์น
๋งค์ผ ๋ฐค ์์ญ๋ง ๊ฑด์ ๊ฑฐ๋๋ฅผ ์ง๊ณํด ์ ์ฐ ํ
์ด๋ธ์ ์ ์ฅํ๋ ๋ฐฐ์น๊ฐ ์ ์ ๋๋ ค์ง๋ค๋ฉด, ๋ค์ ์์๋ก ์ ๊ฒํฉ๋๋ค. โ ์๋ณธ ๊ฑฐ๋๋ ํค์
๋ฐฉ์์ผ๋ก ์ฒญํฌ ๋จ์ ์กฐํ(์ฝ๊ธฐ ์ ์ฉ) โก ์ง๊ณ ๊ฒฐ๊ณผ ์ ์ฅ ์ํฐํฐ๋ SEQUENCE ์ ๋ต + batch_size + ์ฒญํฌ๋ง๋ค flush/clear โข MySQL์ด๋ฉด rewriteBatchedStatements=true โฃ ๋จ์ ์ํ ๋ณ๊ฒฝ(์ฒ๋ฆฌ ์๋ฃ ํ๋๊ทธ)์ ๋ฒํฌ UPDATE. Spring Batch๋ฅผ ์ฐ๋ ๊ฒฝ์ฐ JpaPagingItemReader๋ OFFSET ๊ธฐ๋ฐ์ด๋ผ ๋ค๋ก ๊ฐ์๋ก ๋๋ ค์ง ์ ์์ด, ํค์
๋ฐฉ์์ ์ปค์คํ
๋ฆฌ๋๋ ์ปค์ ๊ธฐ๋ฐ ๋ฆฌ๋๋ฅผ ์ ํํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค.
โ 16์ฅ. ํ๋์ ๋ณด๋ ํ๋ ์ฒดํฌ๋ฆฌ์คํธ
| ์์ญ | ์ ๊ฒ ํญ๋ชฉ | ๊ถ์ฅ |
|---|---|---|
| ์ธก์ | SQL ๋ก๊ทธ, ํต๊ณ, ์ฟผ๋ฆฌ ์ ํ ์คํธ | ๊ฐ๋ฐ ํ๊ฒฝ ์์ ํ์ฑํ |
| ์ฐ๊ด๊ด๊ณ | ToOne ๊ธฐ๋ณธ EAGER ๋ฐฉ์น ์ฌ๋ถ | ๋ชจ๋ LAZY ๋ช ์ |
| N+1 | ๋ชฉ๋ก ์กฐํ ์ ๋ฐ๋ณต SQL | ToOne fetch join + ์ปฌ๋ ์ ๋ฐฐ์น ํ์น |
| ํ์ด์ง | ์ปฌ๋ ์ fetch join + ํ์ด์ง | ๊ธ์ง, fail_on_pagination ์ต์ ๊ณ ๋ ค |
| ์กฐํ | ์ฝ๊ธฐ ํธ๋์ญ์ , ์ํฐํฐ ๊ณผ๋ค ๋ก๋ฉ | readOnly, DTO ํ๋ก์ ์ |
| ์ฐ๊ธฐ | ID ์ ๋ต, ๋ฐฐ์น ์ค์ | SEQUENCE+pooled, batch_size, order_inserts |
| ๋๋ ์ฒ๋ฆฌ | ์์์ฑ ์ปจํ ์คํธ ๋น๋ํ | flush/clear, ๋ฒํฌ ์ฐ์ฐ, StatelessSession |
| ์บ์ | ์ฐธ์กฐ ๋ฐ์ดํฐ ๋ฐ๋ณต ์กฐํ | 2์ฐจ ์บ์ ์ ํ ์ ์ฉ, ์ฟผ๋ฆฌ ์บ์ ์ ์ค |
| ์ปค๋ฅ์ | ํ ํฌ๊ธฐ, OSIV, ๊ธด ํธ๋์ญ์ | ์์ ํ, OSIV off, ๋์ ๊ฐ์ง |
| DB | ์คํ ๊ณํ, FK ์ธ๋ฑ์ค | EXPLAIN ์์ ํ์ธ, ๋ง์ด๊ทธ๋ ์ด์ ๋๊ตฌ |
๐ฌ ์์ฃผ ๋ฌป๋ ์ง๋ฌธ
Q. JPA๊ฐ ๋๋ฆฌ๋ MyBatis๋ JdbcTemplate์ผ๋ก ๊ฐ๋ ๊ฒ ๋ซ์ง ์๋์?
๋๋ถ๋ถ์ "JPA๊ฐ ๋๋ฆฌ๋ค"๋ ์ฌ๋ก๋ ORM ์์ฒด๊ฐ ์๋๋ผ N+1, ๊ณผ๋ํ ์ํฐํฐ ๋ก๋ฉ, ์๋ชป๋ ID ์ ๋ต ๊ฐ์ ์ฌ์ฉ ๋ฐฉ์์ ๋ฌธ์ ์ ๋๋ค. ๋ค๋ง ๋ณต์กํ ํต๊ณ ์ฟผ๋ฆฌ๋ ์ด๋๋ INSERT์ฒ๋ผ ORM์ ์ด์ ์ด ์ ์ ์์ญ์ ๋ค์ดํฐ๋ธ ์ฟผ๋ฆฌ๋ JdbcTemplate์ ์์ด ์ฐ๋ ๊ฒ์ด ํฉ๋ฆฌ์ ์ ๋๋ค. ํ๋์ ํ๋ก์ ํธ์์ ๋๊ตฌ๋ฅผ ์ฉ๋๋ณ๋ก ํผ์ฉํ๋ ๊ฒ์ ์ ํ ์ด์ํ์ง ์์ต๋๋ค.
Q. default_batch_fetch_size๋ ์ผ๋ง๋ก ํด์ผ ํ๋์?
์ ๋ต์ ์์ง๋ง 100~1000 ์ฌ์ด์์ ์์ํด ์ธก์ ํ๋ ๊ฒ์ด ์ผ๋ฐ์ ์ ๋๋ค. ๋๋ฌด ํฌ๋ฉด IN ์ ์ด ๊ธธ์ด์ ธ DB์ ํ์ฑยท๊ณํ ๋น์ฉ์ด ์ปค์ง๊ณ , ์ผ๋ถ DB์ ํ๋ผ๋ฏธํฐ ์ ์ ํ(์: Oracle์ IN ๋ชฉ๋ก 1000๊ฐ ์ ํ)์ ๊ฑธ๋ฆด ์ ์์ต๋๋ค. Hibernate 6์ ๋ฐฐ์น ๋ก๋ฉ ์ DB๊ฐ ์ง์ํ๋ฉด ๋ฐฐ์ด ํ๋ผ๋ฏธํฐ๋ฅผ ํ์ฉํ๋ ๋ฑ ๊ตฌํ์ด ๊ฐ์ ๋์์ผ๋ ์ฌ์ฉ ๋ฒ์ ์ ๋ฌธ์๋ฅผ ํ์ธํ์ธ์.
Q. Spring Data์ saveAll()์ด ๋๋ฆฐ ์ด์ ๋?
save()๋ ์ํฐํฐ๊ฐ ์๊ฒ์ธ์ง ํ๋จํด persist ๋๋ merge๋ฅผ ํธ์ถํฉ๋๋ค. ID๋ฅผ ์ง์ ํ ๋นํ๋ ์ํฐํฐ๋ ID๊ฐ ์ด๋ฏธ ์์ผ๋ "์๊ฒ์ด ์๋๋ค"๋ก ํ๋จ๋์ด merge โ SELECT ํ INSERT๊ฐ ๋ฐ์ํฉ๋๋ค. ์ด ๊ฒฝ์ฐ Persistable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํด isNew()๋ฅผ ์ง์ ์ ์(์: ์์ฑ์ผ null ์ฌ๋ถ)ํ๋ฉด ๋ถํ์ํ SELECT๋ฅผ ์์จ ์ ์์ต๋๋ค.
JPA ์ฑ๋ฅ ํ๋์ ํ ๋ฒ ์ตํ ๋๋ฉด ์ด๋ค ํ๋ก์ ํธ์์๋ ๋ฐ๋ก ์จ๋จน์ ์ ์๋ ์ค์ ์ฌ๋ฅ์ ๋๋ค. ์ฌ๋ฅ๋ท ๊ฐ์ ์ฌ๋ฅ ๊ณต์ ํ๋ซํผ์์๋ ๋ ๊ฑฐ์ ์๋น์ค์ ์ฟผ๋ฆฌ ์ต์ ํ๋ ์ฑ๋ฅ ์ง๋จ์ฒ๋ผ ์ด ๋ถ์ผ์ ๊ฒฝํ์ ํ์๋ก ํ๋ ์๋ขฐ๋ฅผ ์ฐพ์๋ณผ ์ ์์ ๋งํผ, ํ์ฅ์์ ์์๊ฐ ๊พธ์คํ ๊ธฐ์ ์ด๊ธฐ๋ ํ์ฃ . ์ค๋ ์ ๋ฆฌํ ์จ์ดํฐ์ ์ฃผ๋ฐฉ ์ด์ผ๊ธฐ๋ฅผ ๋ ์ฌ๋ฆฌ๋ฉฐ, ์ฌ๋ฌ๋ถ์ ์ ํ๋ฆฌ์ผ์ด์ ์์๋ ์ธ๋ฐ์๋ ์๋ณต์ด ์๋์ง SQL ๋ก๊ทธ๋ถํฐ ํ๋ฒ ์ด์ด ๋ณด์ธ์. ๐ท
๐ ์ฐธ๊ณ ์๋ฃ
Hibernate ORM User Guide โ https://docs.jboss.org/hibernate/orm/current/userguide/html_single/Hibernate_User_Guide.html
Spring Data JPA Reference Documentation โ https://docs.spring.io/spring-data/jpa/reference/
Spring Boot Reference: Data Access (open-in-view ๋ฑ) โ https://docs.spring.io/spring-boot/reference/data/sql.html
HikariCP GitHub (Configuration, About Pool Sizing) โ https://github.com/brettwooldridge/HikariCP
MySQL Connector/J Configuration Properties โ https://dev.mysql.com/doc/connector-j/en/connector-j-reference-configuration-properties.html
PostgreSQL JDBC Driver Documentation โ https://jdbc.postgresql.org/documentation/
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.