์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐Ÿณ JPA Hibernate์™€ ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์—ฐ๋™ ์„ฑ๋Šฅ ์ตœ์ ํ™” ๊ธฐ๋ฒ• โ€” N+1 ์ง€์˜ฅ ํƒˆ์ถœ๋ถ€ํ„ฐ ๋ฐฐ์น˜ยท์บ์‹œยท์ปค๋„ฅ์…˜ ํ’€๊นŒ์ง€, ๋А๋ฆฐ ์ฃผ๋ฐฉ์„ ๋ฏธ์А๋žญ์œผ๋กœ ๋ฐ”๊พธ๋Š” ์‹ค์ „ ํŠœ๋‹ ๊ฐ€์ด๋“œ

๐Ÿณ JPA Hibernate์™€ ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์—ฐ๋™ ์„ฑ๋Šฅ ์ตœ์ ํ™” ๊ธฐ๋ฒ• โ€” N+1 ์ง€์˜ฅ ํƒˆ์ถœ๋ถ€ํ„ฐ ๋ฐฐ์น˜ยท์บ์‹œยท์ปค๋„ฅ์…˜ ํ’€๊นŒ์ง€, ๋А๋ฆฐ ์ฃผ๋ฐฉ์„ ๋ฏธ์А๋žญ์œผ๋กœ ๋ฐ”๊พธ๋Š” ์‹ค์ „ ํŠœ๋‹ ๊ฐ€์ด๋“œ

"์ฝ”๋“œ๋Š” ๋ฉ€์ฉกํ•œ๋ฐ ์™œ API๊ฐ€ 3์ดˆ๋‚˜ ๊ฑธ๋ฆฌ์ง€?" ๋ฒ”์ธ์€ ๋Œ€๊ฐœ ๋น„์ฆˆ๋‹ˆ์Šค ๋กœ์ง์ด ์•„๋‹ˆ๋ผ, ์šฐ๋ฆฌ๊ฐ€ ๋ณด์ง€ ๋ชปํ•œ ๊ณณ์—์„œ ์Ÿ์•„์ง€๋Š” SQL์ž…๋‹ˆ๋‹ค.
์˜ค๋Š˜์€ Hibernate๋ผ๋Š” ์›จ์ดํ„ฐ์™€ ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค๋ผ๋Š” ์ฃผ๋ฐฉ ์‚ฌ์ด๋ฅผ ์˜ค๊ฐ€๋Š” ์ฃผ๋ฌธ์„œ๋ฅผ ํ•˜๋‚˜ํ•˜๋‚˜ ์ถ”์ ํ•˜๋ฉฐ, ๋ ˆ์Šคํ† ๋ž‘(์• ํ”Œ๋ฆฌ์ผ€์ด์…˜)์„ ๋น ๋ฅด๊ฒŒ ๋งŒ๋“œ๋Š” ๋ฐฉ๋ฒ•์„ ์ •๋ฆฌํ•ด ๋ด…๋‹ˆ๋‹ค.

์›จ์ดํ„ฐ(Hibernate)์™€ ์ฃผ๋ฐฉ(DB) โŒ N+1: ํ•œ ์ ‘์‹œ์”ฉ ์™•๋ณต ์ฃผ๋ฐฉ DB SELECT ์†๋‹˜ 100๋ช… ํ…Œ์ด๋ธ” ์ฟผ๋ฆฌ 101๋ฒˆ ์™•๋ณต ๐Ÿ’ฆ โœ… ์ตœ์ ํ™”: ์Ÿ๋ฐ˜์— ํ•œ ๋ฒˆ์— ์ฃผ๋ฐฉ DB JOIN ์†๋‹˜ 100๋ช… ํ…Œ์ด๋ธ” ์ฟผ๋ฆฌ 1~2๋ฒˆ์ด๋ฉด ๋ ๐Ÿ˜Ž
๊ฐ™์€ 100๋ช…๋ถ„ ์š”๋ฆฌ๋„ ์™•๋ณต ํšŸ์ˆ˜์— ๋”ฐ๋ผ ์„œ๋น™ ์†๋„๊ฐ€ ์™„์ „ํžˆ ๋‹ฌ๋ผ์ง‘๋‹ˆ๋‹ค.

๐Ÿฝ๏ธ 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์ฐจ ์บ์‹œ๋Š” ํŠธ๋žœ์žญ์…˜์ด ๋๋‚˜๋ฉด ์‚ฌ๋ผ์ง€๋Š” ๋‹จ๋ช… ์บ์‹œ๋ผ์„œ, ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜ ์ „์ฒด ์„ฑ๋Šฅ์„ ๋Œ์–ด์˜ฌ๋ฆฌ๋Š” ์บ์‹œ๊ฐ€ ์•„๋‹™๋‹ˆ๋‹ค.

์—”ํ‹ฐํ‹ฐ์˜ ๋„ค ๊ฐ€์ง€ ์ƒ์•  ๋‹จ๊ณ„

์—”ํ‹ฐํ‹ฐ ์ƒํƒœ ์ „์ด๋„ ๋น„์˜์† new๋กœ ๋ง‰ ์ƒ์„ฑ ์˜์†(๊ด€๋ฆฌ) ๋ณ€๊ฒฝ ์ž๋™ ๊ฐ์ง€ ์ค€์˜์† ์ˆ˜์ฒฉ์—์„œ ์ง€์›Œ์ง ์‚ญ์ œ flush ๋•Œ DELETE persist detach clearยทclose merge remove persist
์„ฑ๋Šฅ ๋ฌธ์ œ์˜ ๋Œ€๋ถ€๋ถ„์€ '์˜์†(๊ด€๋ฆฌ)' ์ƒํƒœ์˜ ์—”ํ‹ฐํ‹ฐ๊ฐ€ ๋„ˆ๋ฌด ๋งŽ๊ฑฐ๋‚˜, ๋„ˆ๋ฌด ์˜ค๋ž˜ ์‚ด์•„ ์žˆ์„ ๋•Œ ์ƒ๊น๋‹ˆ๋‹ค.

๋ณ€๊ฒฝ ๊ฐ์ง€(Dirty Checking)์™€ ์Šค๋ƒ…์ƒท

Hibernate๊ฐ€ update() ๋ฉ”์„œ๋“œ ์—†์ด๋„ ํ•„๋“œ ๊ฐ’ ๋ณ€๊ฒฝ์„ DB์— ๋ฐ˜์˜ํ•˜๋Š” ๋น„๊ฒฐ์€ ์Šค๋ƒ…์ƒท์ž…๋‹ˆ๋‹ค. ์—”ํ‹ฐํ‹ฐ๋ฅผ ์˜์† ์ƒํƒœ๋กœ ๋กœ๋”ฉํ•  ๋•Œ Hibernate๋Š” ๋กœ๋”ฉ ์‹œ์ ์˜ ์ƒํƒœ ๋ฐฐ์—ด์„ ๋ณต์‚ฌํ•ด ๋‘ก๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  flush ์‹œ์ ์— ํ˜„์žฌ ๊ฐ์ฒด ์ƒํƒœ์™€ ์Šค๋ƒ…์ƒท์„ ํ•„๋“œ ๋‹จ์œ„๋กœ ๋น„๊ตํ•ด ๋‹ค๋ฅธ ๊ฒƒ์ด ์žˆ์œผ๋ฉด UPDATE๋ฅผ ๋งŒ๋“ญ๋‹ˆ๋‹ค.

ํŽธ๋ฆฌํ•˜์ง€๋งŒ ๊ณต์งœ๊ฐ€ ์•„๋‹™๋‹ˆ๋‹ค. ์—”ํ‹ฐํ‹ฐ ํ•˜๋‚˜๋‹น ์Šค๋ƒ…์ƒท ๋ฉ”๋ชจ๋ฆฌ๊ฐ€ ์ถ”๊ฐ€๋กœ ๋“ค๊ณ , flush๋งˆ๋‹ค ๊ด€๋ฆฌ ์ค‘์ธ ๋ชจ๋“  ์—”ํ‹ฐํ‹ฐ๋ฅผ ๋น„๊ตํ•ฉ๋‹ˆ๋‹ค. ์—”ํ‹ฐํ‹ฐ 10๋งŒ ๊ฐœ๋ฅผ ํ•œ ํŠธ๋žœ์žญ์…˜์—์„œ ์ฝ์–ด ๋“ค์ด๋ฉด, ์ˆ˜์ •ํ•˜์ง€ ์•Š์•˜๋”๋ผ๋„ ๋ฉ”๋ชจ๋ฆฌ์™€ CPU๋ฅผ ๊ทธ๋งŒํผ ์”๋‹ˆ๋‹ค. ์ด ์‚ฌ์‹ค์ด ์ดํ›„ ๋“ฑ์žฅํ•  '์ฝ๊ธฐ ์ „์šฉ ์ตœ์ ํ™”'์™€ '๋ฐฐ์น˜ ์ฒ˜๋ฆฌ ์‹œ clear'์˜ ๊ทผ๊ฑฐ๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.

์“ฐ๊ธฐ ์ง€์—ฐ๊ณผ flush ํƒ€์ด๋ฐ

persist()๋ฅผ ํ˜ธ์ถœํ•œ๋‹ค๊ณ  ์ฆ‰์‹œ INSERT๊ฐ€ ๋‚˜๊ฐ€์ง€ ์•Š์Šต๋‹ˆ๋‹ค(์˜ˆ์™ธ๋Š” ๋’ค์—์„œ ๋‹ค๋ฃฐ IDENTITY ์ „๋žต). Hibernate๋Š” SQL์„ ์•ก์…˜ ํ์— ์Œ“์•„ ๋‘์—ˆ๋‹ค๊ฐ€ flush ์‹œ์ ์— ํ•œ๊บผ๋ฒˆ์— ๋ณด๋ƒ…๋‹ˆ๋‹ค. ๊ธฐ๋ณธ flush ๋ชจ๋“œ์ธ AUTO์—์„œ flush๋Š” ๋‹ค์Œ ์ƒํ™ฉ์— ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค.

ํŠธ๋žœ์žญ์…˜ ์ปค๋ฐ‹ ์ง์ „
JPQL/HQL ์ฟผ๋ฆฌ ์‹คํ–‰ ์ „, ๊ทธ ์ฟผ๋ฆฌ ๊ฒฐ๊ณผ์— ์˜ํ–ฅ์„ ์ค„ ์ˆ˜ ์žˆ๋Š” ๋Œ€๊ธฐ ์ค‘ ๋ณ€๊ฒฝ์ด ์žˆ์„ ๋•Œ (Hibernate ๋„ค์ดํ‹ฐ๋ธŒ ์ฟผ๋ฆฌ๋Š” ๋™์ž‘์ด ๋” ๋ณด์ˆ˜์ ์ผ ์ˆ˜ ์žˆ์Œ)
๊ฐœ๋ฐœ์ž๊ฐ€ em.flush()๋ฅผ ์ง์ ‘ ํ˜ธ์ถœํ•  ๋•Œ

์“ฐ๊ธฐ ์ง€์—ฐ ๋•๋ถ„์— JDBC ๋ฐฐ์น˜๊ฐ€ ๊ฐ€๋Šฅํ•ด์ง€๊ณ , ๊ฐ™์€ ์—”ํ‹ฐํ‹ฐ๋ฅผ ์—ฌ๋Ÿฌ ๋ฒˆ ์ˆ˜์ •ํ•ด๋„ UPDATE๋Š” ์ตœ์ข… ์ƒํƒœ๋กœ ํ•œ ๋ฒˆ๋งŒ ๋‚˜๊ฐ‘๋‹ˆ๋‹ค. ๋ฐ˜๋Œ€๋กœ ์ฟผ๋ฆฌ ์ค‘๊ฐ„์ค‘๊ฐ„ ์ž๋™ flush๊ฐ€ ์ผ์–ด๋‚˜๋ฉด ๋น„๊ต ๋น„์šฉ์ด ๋ฐ˜๋ณต๋˜๋ฏ€๋กœ, ๋Œ€๋Ÿ‰ ์ฒ˜๋ฆฌ ๋ฃจํ”„ ์•ˆ์—์„œ JPQL์„ ์„ž์–ด ์“ฐ๋ฉด ์˜์™ธ๋กœ ๋А๋ ค์งˆ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๐Ÿ“Œ 1์žฅ ํ•ต์‹ฌ ์š”์•ฝ โ‘  1์ฐจ ์บ์‹œ๋Š” ํŠธ๋žœ์žญ์…˜ ๋ฒ”์œ„ยทID ์กฐํšŒ ํ•œ์ • ์บ์‹œ๋‹ค.
โ‘ก ๋ณ€๊ฒฝ ๊ฐ์ง€๋Š” ์Šค๋ƒ…์ƒท ๋น„๊ต ๋น„์šฉ๊ณผ ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ๋Œ€๊ฐ€๋กœ ์–ป๋Š” ํŽธ๋ฆฌํ•จ์ด๋‹ค.
โ‘ข 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๋Š” ์ฟผ๋ฆฌ๋ฅผ ๋ช‡ ๋ฒˆ ๋‚ ๋ฆฌ๋Š”๊ฐ€"๋ฅผ ์ˆซ์ž๋กœ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์™ธ๋ถ€ ํ”„๋ก์‹œ ๋„๊ตฌ

๐Ÿ•ต๏ธ p6spyJDBC ๋“œ๋ผ์ด๋ฒ„๋ฅผ ๊ฐ์‹ธ์„œ ์‹ค์ œ ์‹คํ–‰๋œ SQL์„ ํŒŒ๋ผ๋ฏธํ„ฐ๊ฐ€ ์ฑ„์›Œ์ง„ ํ˜•ํƒœ๋กœ ๊ธฐ๋กํ•ฉ๋‹ˆ๋‹ค. ์‹คํ–‰ ์‹œ๊ฐ„๋„ ํ•จ๊ป˜ ๋‚˜์™€ ๋А๋ฆฐ ์ฟผ๋ฆฌ๋ฅผ ์ฐพ๊ธฐ ์ข‹์Šต๋‹ˆ๋‹ค.
๐Ÿงช datasource-proxyDataSource๋ฅผ ํ”„๋ก์‹œ๋กœ ๊ฐ์‹ธ ์ฟผ๋ฆฌ ์ˆ˜๋ฅผ ์…€ ์ˆ˜ ์žˆ์–ด, ํ…Œ์ŠคํŠธ ์ฝ”๋“œ์—์„œ "์ด ๋ฉ”์„œ๋“œ๋Š” ์ฟผ๋ฆฌ๊ฐ€ 3๊ฐœ ์ดํ•˜์—ฌ์•ผ ํ•œ๋‹ค"๋Š” ๋‹จ์–ธ์„ ๋งŒ๋“ค ๋•Œ ์œ ์šฉํ•ฉ๋‹ˆ๋‹ค.
๐Ÿ“Š APMPinpoint, Scouter, New Relic ๋“ฑ APM์€ ์šด์˜ ํ™˜๊ฒฝ์—์„œ ํŠธ๋žœ์žญ์…˜๋ณ„ SQL ํ˜ธ์ถœ ์ˆ˜์™€ ์‹œ๊ฐ„์„ ์ถ”์ ํ•ฉ๋‹ˆ๋‹ค. N+1์€ APM ํŠธ๋ ˆ์ด์Šค์—์„œ ๊ฐ™์€ SQL์ด ์ค„์ค„์ด ๋ฐ˜๋ณต๋˜๋Š” ๋ชจ์–‘์œผ๋กœ ๋“œ๋Ÿฌ๋‚ฉ๋‹ˆ๋‹ค.
๐Ÿ—„๏ธ DB ์ธก ๋„๊ตฌMySQL slow query log, PostgreSQL์˜ pg_stat_statements, ๊ทธ๋ฆฌ๊ณ  EXPLAIN/EXPLAIN ANALYZE๋Š” DB ์ž…์žฅ์—์„œ ๋น„์‹ผ ์ฟผ๋ฆฌ๋ฅผ ์•Œ๋ ค ์ค๋‹ˆ๋‹ค.
๐Ÿ’ก ์ฟผ๋ฆฌ ์ˆ˜๋ฅผ ํ…Œ์ŠคํŠธ๋กœ ๊ณ ์ •ํ•˜๋ผ ์„ฑ๋Šฅ ํšŒ๊ท€๋Š” ๋Œ€๊ฐœ "๋ˆ„๊ตฐ๊ฐ€ ์—ฐ๊ด€๊ด€๊ณ„ ํ•˜๋‚˜๋ฅผ ์ถ”๊ฐ€ํ–ˆ๋”๋‹ˆ ์ฟผ๋ฆฌ๊ฐ€ ๋Š˜์—ˆ๋‹ค"๋Š” ์‹์œผ๋กœ ์กฐ์šฉํžˆ ์ฐพ์•„์˜ต๋‹ˆ๋‹ค. ํ•ต์‹ฌ API์— ๋Œ€ํ•ด ์ฟผ๋ฆฌ ์ˆ˜ ๋‹จ์–ธ ํ…Œ์ŠคํŠธ๋ฅผ ๋งŒ๋“ค์–ด ๋‘๋ฉด, ๋ฆฌํŒฉํ„ฐ๋ง ์ค‘ N+1์ด ์žฌ๋ฐœํ•˜๋Š” ์ˆœ๊ฐ„ CI๊ฐ€ ๋นจ๊ฐ„๋ถˆ์„ ์ผœ ์ค๋‹ˆ๋‹ค.

๐Ÿ”ฅ 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 ...)
ํ˜•ํƒœ๋กœ ๋ชจ๋“  ์ปฌ๋ ‰์…˜์„ ํ•œ ๋ฒˆ์— ๊ฐ€์ ธ์˜ต๋‹ˆ๋‹ค. ๋‹ค๋งŒ ์›๋ณธ ์ฟผ๋ฆฌ๊ฐ€ ๋ณต์žกํ•˜๊ฑฐ๋‚˜ ๋ฌด๊ฑฐ์šฐ๋ฉด ์„œ๋ธŒ์ฟผ๋ฆฌ๋กœ ํ•œ ๋ฒˆ ๋” ์‹คํ–‰๋˜๋Š” ์…ˆ์ด๋ผ ์ƒํ™ฉ์„ ๋ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.
์ฃผ๋ฌธ 100๊ฑด + ํšŒ์› ์กฐํšŒ ์‹œ SQL ์ˆ˜ N+1 101 ๋ฐฐ์น˜ 10 11 ๋ฐฐ์น˜ 100 2 fetch join 1 ํšŒ์› 100๋ช…์ด ๋ชจ๋‘ ๋‹ค๋ฅธ ์ตœ์•…์˜ ๊ฒฝ์šฐ ๊ธฐ์ค€ (๋ง‰๋Œ€ ๊ธธ์ด = ์ฟผ๋ฆฌ ์ˆ˜ ๋น„๋ก€)
๋ฐฐ์น˜ ํฌ๊ธฐ 10์ด๋ฉด 1 + โŒˆ100/10โŒ‰ = 11๋ฒˆ, 100์ด๋ฉด 1 + 1 = 2๋ฒˆ์ž…๋‹ˆ๋‹ค.
๊ธฐ๋ฒ•์ฟผ๋ฆฌ ์ˆ˜์žฅ์ ์ฃผ์˜์ 
fetch join1๊ฐ€์žฅ ํ™•์‹ค, ๋ช…์‹œ์ ์ปฌ๋ ‰์…˜ + ํŽ˜์ด์ง• ๋ถˆ๊ฐ€, ๋‹ค์ค‘ bag ๋ถˆ๊ฐ€
@EntityGraph1๋ฉ”์„œ๋“œ ์ด๋ฆ„ ์ฟผ๋ฆฌ์™€ ๊ฒฐํ•ฉ ์‰ฌ์›€fetch join๊ณผ ๊ฐ™์€ ํ•œ๊ณ„
๋ฐฐ์น˜ ํŽ˜์น˜1 + โŒˆN/๋ฐฐ์น˜โŒ‰์ „์—ญ ์„ค์ •, ํŽ˜์ด์ง•๊ณผ ๊ณต์กด์ฟผ๋ฆฌ ์ˆ˜๊ฐ€ ์™„์ „ํžˆ 1์€ ์•„๋‹˜
SUBSELECT2์ปฌ๋ ‰์…˜ ์ผ๊ด„ ๋กœ๋”ฉ์›๋ณธ ์ฟผ๋ฆฌ๊ฐ€ ๋ฌด๊ฑฐ์šฐ๋ฉด ๋น„์šฉ ์žฌ๋ฐœ์ƒ

๐Ÿงบ 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ํ•˜๊ณ  ๋‚˜๋จธ์ง€๋Š” ๋ฐฐ์น˜ ํŽ˜์น˜๋กœ ๊ฐ€์ ธ์˜ค๊ฑฐ๋‚˜, ์ฟผ๋ฆฌ๋ฅผ ๋‚˜๋ˆ  ์‹คํ–‰ํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

โš ๏ธ Set์œผ๋กœ ๋ฐ”๊พธ๋ฉด ํ•ด๊ฒฐ? ํ”ํ•œ ์˜คํ•ด ์˜ˆ์™ธ ๋ฉ”์‹œ์ง€๊ฐ€ ์‚ฌ๋ผ์กŒ๋‹ค๊ณ  ์„ฑ๋Šฅ ๋ฌธ์ œ๊ฐ€ ํ•ด๊ฒฐ๋œ ๊ฒƒ์ด ์•„๋‹™๋‹ˆ๋‹ค. ์ปฌ๋ ‰์…˜ ๋‘ ๊ฐœ๋ฅผ ํ•œ ๋ฒˆ์— ์กฐ์ธํ•˜๋ฉด ํ–‰ ์ˆ˜๋Š” ๋‘ ์ปฌ๋ ‰์…˜ ํฌ๊ธฐ์˜ ๊ณฑ์ด ๋ฉ๋‹ˆ๋‹ค. ๋ฐ์ดํ„ฐ๊ฐ€ ์ปค์งˆ์ˆ˜๋ก ๊ธฐํ•˜๊ธ‰์ˆ˜์ ์œผ๋กœ ๋ฌด๊ฑฐ์›Œ์ง‘๋‹ˆ๋‹ค.

โณ 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 ์š”์ฒญ ์‹œ์ž‘๋ถ€ํ„ฐ ์‘๋‹ต ์™„๋ฃŒ๊นŒ์ง€ ์œ ์ง€๋˜์–ด, ๋ทฐ๋‚˜ ์ปจํŠธ๋กค๋Ÿฌ์—์„œ๋„ ์ง€์—ฐ ๋กœ๋”ฉ์ด ๋™์ž‘ํ•ฉ๋‹ˆ๋‹ค.

๐Ÿ‘ OSIV ON์˜ ํŽธ๋ฆฌํ•จ
LazyInitializationException ๊ฑฑ์ •์ด ์ค„๊ณ , ๊ฐœ๋ฐœ ์†๋„๊ฐ€ ๋น ๋ฆ…๋‹ˆ๋‹ค. ํŠธ๋ž˜ํ”ฝ์ด ์ ์€ ๊ด€๋ฆฌ์ž ๋„๊ตฌ๋‚˜ ์‚ฌ๋‚ด ์‹œ์Šคํ…œ์—์„œ๋Š” ์‹ค์šฉ์ ์ธ ์„ ํƒ์ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
๐Ÿ‘Ž OSIV ON์˜ ๋Œ€๊ฐ€
์ง€์—ฐ ๋กœ๋”ฉ์ด ์ผ์–ด๋‚˜๋Š” ์ˆœ๊ฐ„ ์ปค๋„ฅ์…˜์„ ์–ป์œผ๋ฉด, ์‘๋‹ต์ด ๋๋‚  ๋•Œ๊นŒ์ง€ ๊ทธ ์ปค๋„ฅ์…˜์„ ๋ถ™์žก๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. ์™ธ๋ถ€ 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);
๐Ÿ“ฆ ์ƒ์„ฑ์ž ํ‘œํ˜„์‹JPQL์˜ select new๋กœ DTO ์ƒ์„ฑ. ์˜์†์„ฑ ์ปจํ…์ŠคํŠธ์— ๋“ฑ๋ก๋˜์ง€ ์•Š์•„ ๊ด€๋ฆฌ ๋น„์šฉ 0. ํŒจํ‚ค์ง€๋ช…์„ ํฌํ•จํ•œ ์ „์ฒด ์ด๋ฆ„์ด ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค.
๐ŸชŸ ์ธํ„ฐํŽ˜์ด์Šค ํ”„๋กœ์ ์…˜Spring Data๊ฐ€ getter ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ๊ตฌํ˜„ํ•œ ํ”„๋ก์‹œ๋ฅผ ๋งŒ๋“ค์–ด ์ค๋‹ˆ๋‹ค. ๋‹ซํžŒ(closed) ํ”„๋กœ์ ์…˜์ด๋ฉด ํ•„์š”ํ•œ ์ปฌ๋Ÿผ๋งŒ ์กฐํšŒํ•˜๋„๋ก ์ตœ์ ํ™”๋ฉ๋‹ˆ๋‹ค.
๐Ÿงฎ Tuple/QueryDSL๋™์  ์กฐ๊ฑด์ด ๋งŽ์€ ๊ฒ€์ƒ‰ ํ™”๋ฉด์—์„œ๋Š” QueryDSL์˜ Projections.constructor ๋“ฑ์œผ๋กœ ํƒ€์ž… ์•ˆ์ „ํ•œ DTO ์กฐํšŒ๋ฅผ ๊ตฌ์„ฑํ•˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ์Šต๋‹ˆ๋‹ค.
๐Ÿ“š ์—”ํ‹ฐํ‹ฐ ์กฐํšŒ vs DTO ์กฐํšŒ, ์–ธ์ œ ๋ฌด์—‡์„? ์กฐํšŒ ํ›„ ์ˆ˜์ •ํ•  ๊ณ„ํš์ด ์žˆ์œผ๋ฉด ์—”ํ‹ฐํ‹ฐ๋กœ, ์ˆœ์ˆ˜ ์กฐํšŒ(๋ชฉ๋กยทํ†ต๊ณ„ยท๊ฒ€์ƒ‰)๋ฉด DTO๋กœ ์กฐํšŒํ•˜๋Š” ๊ฒƒ์ด ๊ธฐ๋ณธ ์›์น™์ž…๋‹ˆ๋‹ค. ๋‹ค๋งŒ DTO ์กฐํšŒ๋Š” API ์ŠคํŽ™๊ณผ ๋ฆฌํฌ์ง€ํ† ๋ฆฌ๊ฐ€ ๊ฐ•ํ•˜๊ฒŒ ๋ฌถ์ด๋ฏ€๋กœ, ํ™”๋ฉด ์ „์šฉ ์ฟผ๋ฆฌ ๋ฆฌํฌ์ง€ํ† ๋ฆฌ๋ฅผ ๋”ฐ๋กœ ๋‘๋Š” ๋ฐฉ์‹์ด ์œ ์ง€๋ณด์ˆ˜์— ์œ ๋ฆฌํ•ฉ๋‹ˆ๋‹ค.

โœ๏ธ 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๋ถ€ํ„ฐ ์‹œํ€€์Šค๋ฅผ ์ง€์›ํ•ฉ๋‹ˆ๋‹ค.

๋“œ๋ผ์ด๋ฒ„ ์ˆ˜์ค€์˜ ๋งˆ์ง€๋ง‰ ํ•œ ์ˆ˜

๐Ÿฌ MySQL Connector/JrewriteBatchedStatements=true๋ฅผ JDBC URL์— ์ถ”๊ฐ€ํ•˜๋ฉด ๋ฐฐ์น˜๋œ INSERT๋ฅผ INSERT ... VALUES (...),(...),(...) ๋‹ค์ค‘ ํ–‰ ๋ฌธ์žฅ์œผ๋กœ ์žฌ์ž‘์„ฑํ•ด ์ „์†กํ•ฉ๋‹ˆ๋‹ค. ์ด ์˜ต์…˜ ์—†์ด๋Š” ๋ฐฐ์น˜์—ฌ๋„ ๋ฌธ์žฅ์„ ๊ฐœ๋ณ„์ ์œผ๋กœ ๋ณด๋‚ด ์ด์ ์ด ํฌ๊ฒŒ ์ค„์–ด๋“ญ๋‹ˆ๋‹ค.
๐Ÿ˜ PostgreSQL pgJDBCreWriteBatchedInserts=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ํ–‰์„ ๋Œ๋ ค์ค€๋‹ค๋Š” ๋œป์ž…๋‹ˆ๋‹ค. ๋’ค ํŽ˜์ด์ง€๋กœ ๊ฐˆ์ˆ˜๋ก ์ฝ๋Š” ์–‘์ด ์„ ํ˜•์œผ๋กœ ๋Š˜์–ด๋‚ฉ๋‹ˆ๋‹ค.

ํŽ˜์ด์ง€ ์œ„์น˜๋ณ„ ์ฝ๋Š” ํ–‰ ์ˆ˜(๊ฐœ๋…๋„) ํŽ˜์ด์ง€ ๋ฒˆํ˜ธ โ†’ ์ฝ๋Š” ํ–‰ โ†‘ OFFSET ๋ฐฉ์‹ ํ‚ค์…‹ ๋ฐฉ์‹
OFFSET์€ ๊ฑด๋„ˆ๋›ธ ํ–‰๊นŒ์ง€ ์ฝ์–ด์•ผ ํ•ด ๋น„์šฉ์ด ํŽ˜์ด์ง€ ๋ฒˆํ˜ธ์— ๋น„๋ก€ํ•˜๊ณ , ํ‚ค์…‹์€ ์ธ๋ฑ์Šค๋กœ ๋ฐ”๋กœ ์œ„์น˜๋ฅผ ์ฐพ์•„ ๊ฑฐ์˜ ์ผ์ •ํ•ฉ๋‹ˆ๋‹ค.

ํ‚ค์…‹(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๋„ ๋ฌด๊ฑฐ์›Œ์ง‘๋‹ˆ๋‹ค.

countQuery ๋ถ„๋ฆฌ:
@Query(value = "...", countQuery = "select count(o) from Order o")
๋กœ ์กฐ์ธ ์—†๋Š” ๋‹จ์ˆœ COUNT๋ฅผ ์ง€์ •ํ•ฉ๋‹ˆ๋‹ค.
Slice ์‚ฌ์šฉ: ์ „์ฒด ๊ฐœ์ˆ˜๊ฐ€ ํ•„์š” ์—†๋‹ค๋ฉด Slice๋ฅผ ๋ฐ˜ํ™˜ ํƒ€์ž…์œผ๋กœ ์“ฐ๋ฉด ์š”์ฒญ ํฌ๊ธฐ+1๊ฐœ๋ฅผ ์กฐํšŒํ•ด "๋‹ค์Œ ํŽ˜์ด์ง€ ์กด์žฌ ์—ฌ๋ถ€"๋งŒ ํŒ๋‹จํ•˜๊ณ  COUNT๋ฅผ ์ƒ๋žตํ•ฉ๋‹ˆ๋‹ค.
Spring Data์˜ ์ž๋™ ์ƒ๋žต: ์ฒซ ํŽ˜์ด์ง€์˜ ๊ฒฐ๊ณผ๊ฐ€ ํŽ˜์ด์ง€ ํฌ๊ธฐ๋ณด๋‹ค ์ ๊ฑฐ๋‚˜ ๋งˆ์ง€๋ง‰ ํŽ˜์ด์ง€์ž„์„ ์•Œ ์ˆ˜ ์žˆ์œผ๋ฉด 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์ž์ฃผ ์ฝ๊ณ  ๊ฐ€๋” ์ˆ˜์ •์†Œํ”„ํŠธ ๋ฝ์œผ๋กœ ์ผ๊ด€์„ฑ ๊ฐ•ํ™”
TRANSACTIONALJTA ํŠธ๋žœ์žญ์…˜ ์บ์‹œXA ์ง€์› ์บ์‹œ ํ”„๋กœ๋ฐ”์ด๋” ํ•„์š”

์ฟผ๋ฆฌ ์บ์‹œ๋Š” ์‹ ์ค‘ํ•˜๊ฒŒ

hibernate.cache.use_query_cache=true๋กœ ์ฟผ๋ฆฌ ์บ์‹œ๋ฅผ ์ผœ๋ฉด JPQL๊ณผ ํŒŒ๋ผ๋ฏธํ„ฐ ์กฐํ•ฉ์˜ ๊ฒฐ๊ณผ(์—”ํ‹ฐํ‹ฐ๋ผ๋ฉด ID ๋ชฉ๋ก)๋ฅผ ์บ์‹œํ•ฉ๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ์ฟผ๋ฆฌ ๊ฒฐ๊ณผ๋Š” ๊ด€๋ จ ํ…Œ์ด๋ธ”์— ๋‹จ ํ•œ ๊ฑด์ด๋ผ๋„ ๋ณ€๊ฒฝ์ด ์ƒ๊ธฐ๋ฉด ๋ฌดํšจํ™”๋ฉ๋‹ˆ๋‹ค(ํ…Œ์ด๋ธ”๋ณ„ ๊ฐฑ์‹  ํƒ€์ž„์Šคํƒฌํ”„๋กœ ํŒ๋‹จ). ์“ฐ๊ธฐ๊ฐ€ ์žฆ์€ ํ…Œ์ด๋ธ”์—์„œ๋Š” ์ ์ค‘๋ฅ ์ด ๋‚ฎ๊ณ  ๋ฌดํšจํ™” ์˜ค๋ฒ„ํ—ค๋“œ๋งŒ ๋Š˜์–ด๋‚ฉ๋‹ˆ๋‹ค. ๋˜ ์—”ํ‹ฐํ‹ฐ ๊ฒฐ๊ณผ๋ฅผ ์บ์‹œํ•  ๋•Œ ํ•ด๋‹น ์—”ํ‹ฐํ‹ฐ๊ฐ€ 2์ฐจ ์บ์‹œ์— ์—†์œผ๋ฉด ID ๋ชฉ๋ก๋งŒ ์–ป๊ณ  ์—”ํ‹ฐํ‹ฐ๋Š” ํ•˜๋‚˜์”ฉ DB์—์„œ ์กฐํšŒํ•ด ์˜คํžˆ๋ ค N+1์ด ๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

โš ๏ธ ๋‹ค์ค‘ ์„œ๋ฒ„ ํ™˜๊ฒฝ์˜ ๋กœ์ปฌ ์บ์‹œ Ehcache๋ฅผ ๊ฐ ์„œ๋ฒ„ ๋ฉ”๋ชจ๋ฆฌ์— ๋‘๋Š” ๋กœ์ปฌ ์บ์‹œ๋กœ ์“ฐ๋ฉด, A ์„œ๋ฒ„๊ฐ€ ์ˆ˜์ •ํ•œ ๋‚ด์šฉ์ด B ์„œ๋ฒ„ ์บ์‹œ์—๋Š” ๋‚จ์•„ ์žˆ์Šต๋‹ˆ๋‹ค. ์„œ๋ฒ„๊ฐ€ ์—ฌ๋Ÿฌ ๋Œ€๋ผ๋ฉด ๋ถ„์‚ฐ ์บ์‹œ(Infinispan, Hazelcast ๋“ฑ)๋ฅผ ์“ฐ๊ฑฐ๋‚˜, ์บ์‹œ ๋Œ€์ƒ์„ READ_ONLY์— ๊ฐ€๊นŒ์šด ๋ฐ์ดํ„ฐ๋กœ ์ œํ•œํ•˜๋Š” ๊ฒƒ์ด ์•ˆ์ „ํ•ฉ๋‹ˆ๋‹ค. ์ž์ฃผ ๋ฐ”๋€Œ๋Š” ๋ฐ์ดํ„ฐ๋Š” Spring Cache + Redis์ฒ˜๋Ÿผ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜ ๋ ˆ๋ฒจ์—์„œ ๋ช…์‹œ์ ์œผ๋กœ ์บ์‹œํ•˜๋Š” ์ชฝ์ด ํ†ต์ œํ•˜๊ธฐ ์‰ฝ์Šต๋‹ˆ๋‹ค.

2์ฐจ ์บ์‹œ์— ์ด์ƒ์ ์ธ ๋ฐ์ดํ„ฐ๋Š” ์ž์ฃผ ์ฝํžˆ๊ณ , ๋“œ๋ฌผ๊ฒŒ ๋ฐ”๋€Œ๋ฉฐ, ID๋กœ ์กฐํšŒ๋˜๋Š” ๋ฐ์ดํ„ฐ์ž…๋‹ˆ๋‹ค. ๊ตญ๊ฐ€ ์ฝ”๋“œ, ์นดํ…Œ๊ณ ๋ฆฌ, ์ƒํ’ˆ ์˜ต์…˜ ์ •์˜ ๊ฐ™์€ ์ฐธ์กฐ ๋ฐ์ดํ„ฐ๊ฐ€ ๋Œ€ํ‘œ์ ์ž…๋‹ˆ๋‹ค.

๐Ÿ”Œ 11์žฅ. ์ปค๋„ฅ์…˜ ํ’€: ์ฃผ๋ฐฉ ์ถœ์ž…๋ฌธ์˜ ๊ฐœ์ˆ˜

์•„๋ฌด๋ฆฌ SQL์„ ๋‹ค๋“ฌ์–ด๋„ ์ปค๋„ฅ์…˜์„ ์–ป์œผ๋ ค๊ณ  ์ค„ ์„œ ์žˆ๋‹ค๋ฉด ์†Œ์šฉ์—†์Šต๋‹ˆ๋‹ค. Spring Boot์˜ ๊ธฐ๋ณธ ์ปค๋„ฅ์…˜ ํ’€์€ HikariCP์ž…๋‹ˆ๋‹ค.

์„ค์ •๊ธฐ๋ณธ๊ฐ’์˜๋ฏธ
maximumPoolSize10ํ’€์˜ ์ตœ๋Œ€ ์ปค๋„ฅ์…˜ ์ˆ˜
minimumIdlemaximumPoolSize์™€ ๋™์ผ์œ ํœด ์ƒํƒœ๋กœ ์œ ์ง€ํ•  ์ตœ์†Œ ์ˆ˜. ๊ณ ์ • ํฌ๊ธฐ ํ’€ ๊ถŒ์žฅ
connectionTimeout30000ms์ปค๋„ฅ์…˜์„ ๊ธฐ๋‹ค๋ฆฌ๋Š” ์ตœ๋Œ€ ์‹œ๊ฐ„
idleTimeout600000ms์œ ํœด ์ปค๋„ฅ์…˜ ์ œ๊ฑฐ ์‹œ๊ฐ„(minimumIdle < max์ผ ๋•Œ)
maxLifetime1800000ms์ปค๋„ฅ์…˜ ์ตœ๋Œ€ ์ˆ˜๋ช…. DB์˜ wait_timeout๋ณด๋‹ค ๋ช‡ ์ดˆ ์ด์ƒ ์งง๊ฒŒ
leakDetectionThreshold0(๋น„ํ™œ์„ฑ)์ง€์ • ์‹œ๊ฐ„ ์ด์ƒ ๋ฐ˜ํ™˜๋˜์ง€ ์•Š์œผ๋ฉด ๋ˆ„์ˆ˜ ๊ฒฝ๊ณ  ๋กœ๊ทธ

ํ’€์€ ํด์ˆ˜๋ก ์ข‹๋‹ค? ์•„๋‹ˆ์š”

HikariCP ์œ„ํ‚ค์˜ "About Pool Sizing" ๋ฌธ์„œ๋Š”

connections = (core_count ร— 2) + effective_spindle_count
๋ผ๋Š” PostgreSQL ์ปค๋ฎค๋‹ˆํ‹ฐ ์ถœ์‹  ๊ณต์‹์„ ์ถœ๋ฐœ์ ์œผ๋กœ ์†Œ๊ฐœํ•˜๋ฉฐ, ์ž‘์€ ํ’€์ด ์˜คํžˆ๋ ค ์ฒ˜๋ฆฌ๋Ÿ‰์ด ๋†’์€ ๊ฒฝ์šฐ๊ฐ€ ๋งŽ๋‹ค๊ณ  ์„ค๋ช…ํ•ฉ๋‹ˆ๋‹ค. DB ์„œ๋ฒ„์˜ CPU ์ฝ”์–ด ์ˆ˜๋ณด๋‹ค ํ›จ์”ฌ ๋งŽ์€ ์ฟผ๋ฆฌ๊ฐ€ ๋™์‹œ์— ์‹คํ–‰๋˜๋ฉด ์ปจํ…์ŠคํŠธ ์Šค์œ„์นญ๊ณผ ์ž ๊ธˆ ๊ฒฝํ•ฉ์œผ๋กœ ์ „์ฒด๊ฐ€ ๋А๋ ค์ง€๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค. ์„œ๋ฒ„ ์ธ์Šคํ„ด์Šค๊ฐ€ 10๋Œ€์ด๊ณ  ๊ฐ์ž ํ’€ 50์ด๋ฉด DB ์ž…์žฅ์—์„œ๋Š” ์ปค๋„ฅ์…˜ 500๊ฐœ๋ผ๋Š” ์ ๋„ ๊ณ„์‚ฐ์— ๋„ฃ์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

์ปค๋„ฅ์…˜ ์ ์œ  ์‹œ๊ฐ„์„ ์ค„์ด๋Š” ์Šต๊ด€

๐Ÿšช ํŠธ๋žœ์žญ์…˜์€ ์งง๊ฒŒํŠธ๋žœ์žญ์…˜ ์•ˆ์—์„œ ์™ธ๋ถ€ API ํ˜ธ์ถœ, ํŒŒ์ผ ์—…๋กœ๋“œ, ๋ฉ”์ผ ๋ฐœ์†ก์„ ํ•˜์ง€ ๋งˆ์„ธ์š”. ๊ทธ๋™์•ˆ ์ปค๋„ฅ์…˜์„ ์ฅ๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค.
๐ŸŒ™ OSIV ๋„๊ธฐ5์žฅ์—์„œ ๋ณธ ๊ฒƒ์ฒ˜๋Ÿผ OSIV๋Š” ์‘๋‹ต ๋ Œ๋”๋ง๊นŒ์ง€ ์ปค๋„ฅ์…˜์„ ๋ถ™์žก์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
โš™๏ธ ์ง€์—ฐ ํš๋“HikariCP์˜ 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์„ ๋Œ€์‹  ์จ ์ค„ ๋ฟ, ์‹คํ–‰ ๊ณ„ํš๊นŒ์ง€ ์ฑ…์ž„์ง€์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

๋กœ๊ทธ๋กœ ์‹ค์ œ SQL์„ ํ™•๋ณด: Hibernate๊ฐ€ ๋งŒ๋“  SQL์„ ๊ทธ๋Œ€๋กœ ๋ณต์‚ฌํ•ฉ๋‹ˆ๋‹ค.
EXPLAIN์œผ๋กœ ๊ณ„ํš ํ™•์ธ: MySQL์˜ type=ALL(ํ’€ ์Šค์บ”), PostgreSQL์˜ Seq Scan์ด ํฐ ํ…Œ์ด๋ธ”์—์„œ ๋ณด์ด๋ฉด ์˜์‹ฌํ•ฉ๋‹ˆ๋‹ค.
WHEREยทJOINยทORDER BY ์ปฌ๋Ÿผ ์ธ๋ฑ์Šค ๊ฒ€ํ† : ๋ณตํ•ฉ ์ธ๋ฑ์Šค๋Š” ์„ ๋‘ ์ปฌ๋Ÿผ ์ˆœ์„œ๊ฐ€ ์ค‘์š”ํ•ฉ๋‹ˆ๋‹ค.
์™ธ๋ž˜ ํ‚ค ์ปฌ๋Ÿผ ์ธ๋ฑ์Šค: PostgreSQL์€ FK ์ปฌ๋Ÿผ์— ์ธ๋ฑ์Šค๋ฅผ ์ž๋™์œผ๋กœ ๋งŒ๋“ค์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ์ง€์—ฐ ๋กœ๋”ฉ ์ปฌ๋ ‰์…˜ ์กฐํšŒ(where order_id = ?)๊ฐ€ ๋А๋ฆฌ๋‹ค๋ฉด 1์ˆœ์œ„๋กœ ํ™•์ธํ•˜์„ธ์š”. MySQL InnoDB๋Š” FK์— ์ธ๋ฑ์Šค๋ฅผ ์š”๊ตฌํ•ด ์ž๋™ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค.
์ปค๋ฒ„๋ง ์ธ๋ฑ์Šค ํ™œ์šฉ: DTO ํ”„๋กœ์ ์…˜์œผ๋กœ ํ•„์š”ํ•œ ์ปฌ๋Ÿผ๋งŒ ์กฐํšŒํ•˜๋ฉด, ์ธ๋ฑ์Šค๋งŒ์œผ๋กœ ๊ฒฐ๊ณผ๋ฅผ ๋งŒ๋“œ๋Š” ์ปค๋ฒ„๋ง ์ธ๋ฑ์Šค ํšจ๊ณผ๋ฅผ ๋…ธ๋ฆด ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

@Table(indexes = @Index(columnList = "member_id, created_at"))
์ฒ˜๋Ÿผ ์—”ํ‹ฐํ‹ฐ์— ์ธ๋ฑ์Šค๋ฅผ ๊ธฐ์ˆ ํ•  ์ˆ˜ ์žˆ์ง€๋งŒ, ์ด๊ฒƒ์€ ์Šคํ‚ค๋งˆ ์ž๋™ ์ƒ์„ฑ ์‹œ์—๋งŒ ๋ฐ˜์˜๋ฉ๋‹ˆ๋‹ค. ์šด์˜ ํ™˜๊ฒฝ์—์„œ๋Š” ddl-auto๋ฅผ none์ด๋‚˜ validate๋กœ ๋‘๊ณ  FlywayยทLiquibase ๊ฐ™์€ ๋งˆ์ด๊ทธ๋ ˆ์ด์…˜ ๋„๊ตฌ๋กœ ์Šคํ‚ค๋งˆ์™€ ์ธ๋ฑ์Šค๋ฅผ ๊ด€๋ฆฌํ•˜๋Š” ๊ฒƒ์ด ํ‘œ์ค€์ž…๋‹ˆ๋‹ค.
๐Ÿ“š ํ•จ์ˆ˜์— ๊ฐ์‹ผ ์ปฌ๋Ÿผ์€ ์ธ๋ฑ์Šค๋ฅผ ๋ชป ํƒ„๋‹ค JPQL์—์„œ where function('date', o.createdAt) = :d๋‚˜ lower(m.email)์ฒ˜๋Ÿผ ์ปฌ๋Ÿผ์„ ํ•จ์ˆ˜๋กœ ๊ฐ์‹ธ๋ฉด ์ผ๋ฐ˜ ์ธ๋ฑ์Šค๋ฅผ ํ™œ์šฉํ•˜์ง€ ๋ชปํ•˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ์Šต๋‹ˆ๋‹ค. ๋ฒ”์œ„ ์กฐ๊ฑด(createdAt >= :start and createdAt < :end)์œผ๋กœ ๋ฐ”๊พธ๊ฑฐ๋‚˜, DB๊ฐ€ ์ง€์›ํ•˜๋ฉด ํ•จ์ˆ˜ ๊ธฐ๋ฐ˜ ์ธ๋ฑ์Šค๋ฅผ ๊ณ ๋ คํ•˜์„ธ์š”.

๐Ÿ”’ 14์žฅ. ๋™์‹œ์„ฑ ์ œ์–ด์™€ ์„ฑ๋Šฅ์˜ ์ค„๋‹ค๋ฆฌ๊ธฐ

์„ฑ๋Šฅ ์ตœ์ ํ™”๋Š” ์ •ํ•ฉ์„ฑ์„ ํฌ์ƒํ•˜์ง€ ์•Š๋Š” ๋ฒ”์œ„์—์„œ๋งŒ ์˜๋ฏธ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. JPA๊ฐ€ ์ œ๊ณตํ•˜๋Š” ๋‘ ๊ฐ€์ง€ ์ž ๊ธˆ ๋ฐฉ์‹์€ ์„ฑ๋Šฅ ํŠน์„ฑ์ด ์ •๋ฐ˜๋Œ€์ž…๋‹ˆ๋‹ค.

๐Ÿ•Š๏ธ ๋‚™๊ด€์  ์ž ๊ธˆ (@Version)
์—”ํ‹ฐํ‹ฐ์— ๋ฒ„์ „ ํ•„๋“œ๋ฅผ ๋‘๊ณ  UPDATE ์‹œ where id=? and version=?๋กœ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค. ์ถฉ๋Œ ์‹œ OptimisticLockException. ์ž ๊ธˆ ๋Œ€๊ธฐ๊ฐ€ ์—†์–ด ์ถฉ๋Œ์ด ๋“œ๋ฌธ ํ™˜๊ฒฝ์—์„œ ์ฒ˜๋ฆฌ๋Ÿ‰์ด ๋†’์Šต๋‹ˆ๋‹ค. ๋Œ€์‹  ์ถฉ๋Œ ์‹œ ์žฌ์‹œ๋„ ๋กœ์ง์ด ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค.
๐Ÿ›ก๏ธ ๋น„๊ด€์  ์ž ๊ธˆ (@Lock(PESSIMISTIC_WRITE))
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: ๋‹จ๊ณ„๋ณ„ ๊ฐœ์„ 

ToOne fetch join:
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๊ฐœ๋กœ.
COUNT ๋ถ„๋ฆฌ: countQuery = "select count(o) from Order o"๋กœ ์กฐ์ธ ์—†๋Š” COUNT.
์„œ๋น„์Šค ๊ณ„์ธต + readOnly: ์กฐํšŒ ๋กœ์ง๊ณผ DTO ๋ณ€ํ™˜์„ @Transactional(readOnly = true) ์„œ๋น„์Šค๋กœ ์˜ฎ๊ธฐ๊ณ  OSIV ๋น„ํ™œ์„ฑํ™”.

๊ฒฐ๊ณผ: ์ฃผ๋ฌธ ์กฐํšŒ 1 + COUNT 1 + ์•„์ดํ…œ IN 1 + ์ƒํ’ˆ IN 1 = 4๊ฐœ ์ฟผ๋ฆฌ. 122๊ฐœ์—์„œ 4๊ฐœ๋กœ, ๋ฐ์ดํ„ฐ ์–‘๊ณผ ์ƒ๊ด€์—†์ด ํŽ˜์ด์ง€๋‹น ์ฟผ๋ฆฌ ์ˆ˜๊ฐ€ ๊ณ ์ •๋ฉ๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์— ๋ชฉ๋ก ํ™”๋ฉด์ด ํ•„์š”ํ•œ ์ปฌ๋Ÿผ์ด ์ ๋‹ค๋ฉด DTO ํ”„๋กœ์ ์…˜์œผ๋กœ ์ „ํ™˜ํ•ด ์˜์†์„ฑ ์ปจํ…์ŠคํŠธ ๊ด€๋ฆฌ ๋น„์šฉ๊นŒ์ง€ ์—†์•จ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ฃผ๋ฌธ ๋ชฉ๋ก API ์ฟผ๋ฆฌ ์ˆ˜ ๋ณ€ํ™” 122 ๊ฐœ์„  ์ „ 4 ๊ฐœ์„  ํ›„ ํŽ˜์ด์ง€ 20๊ฑด ยท ์ฃผ๋ฌธ๋‹น ์ƒํ’ˆ 3๊ฐœ ๊ฐ€์ •์˜ ๊ณ„์‚ฐ ์˜ˆ์‹œ

๋˜ ๋‹ค๋ฅธ ์‚ฌ๋ก€: ์•ผ๊ฐ„ ์ •์‚ฐ ๋ฐฐ์น˜

๋งค์ผ ๋ฐค ์ˆ˜์‹ญ๋งŒ ๊ฑด์˜ ๊ฑฐ๋ž˜๋ฅผ ์ง‘๊ณ„ํ•ด ์ •์‚ฐ ํ…Œ์ด๋ธ”์— ์ €์žฅํ•˜๋Š” ๋ฐฐ์น˜๊ฐ€ ์ ์  ๋А๋ ค์ง„๋‹ค๋ฉด, ๋‹ค์Œ ์ˆœ์„œ๋กœ ์ ๊ฒ€ํ•ฉ๋‹ˆ๋‹ค. โ‘  ์›๋ณธ ๊ฑฐ๋ž˜๋Š” ํ‚ค์…‹ ๋ฐฉ์‹์œผ๋กœ ์ฒญํฌ ๋‹จ์œ„ ์กฐํšŒ(์ฝ๊ธฐ ์ „์šฉ) โ‘ก ์ง‘๊ณ„ ๊ฒฐ๊ณผ ์ €์žฅ ์—”ํ‹ฐํ‹ฐ๋Š” SEQUENCE ์ „๋žต + batch_size + ์ฒญํฌ๋งˆ๋‹ค flush/clear โ‘ข MySQL์ด๋ฉด rewriteBatchedStatements=true โ‘ฃ ๋‹จ์ˆœ ์ƒํƒœ ๋ณ€๊ฒฝ(์ฒ˜๋ฆฌ ์™„๋ฃŒ ํ”Œ๋ž˜๊ทธ)์€ ๋ฒŒํฌ UPDATE. Spring Batch๋ฅผ ์“ฐ๋Š” ๊ฒฝ์šฐ JpaPagingItemReader๋Š” OFFSET ๊ธฐ๋ฐ˜์ด๋ผ ๋’ค๋กœ ๊ฐˆ์ˆ˜๋ก ๋А๋ ค์งˆ ์ˆ˜ ์žˆ์–ด, ํ‚ค์…‹ ๋ฐฉ์‹์˜ ์ปค์Šคํ…€ ๋ฆฌ๋”๋‚˜ ์ปค์„œ ๊ธฐ๋ฐ˜ ๋ฆฌ๋”๋ฅผ ์„ ํƒํ•˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ์Šต๋‹ˆ๋‹ค.

โœ… 16์žฅ. ํ•œ๋ˆˆ์— ๋ณด๋Š” ํŠœ๋‹ ์ฒดํฌ๋ฆฌ์ŠคํŠธ

์˜์—ญ์ ๊ฒ€ ํ•ญ๋ชฉ๊ถŒ์žฅ
์ธก์ •SQL ๋กœ๊ทธ, ํ†ต๊ณ„, ์ฟผ๋ฆฌ ์ˆ˜ ํ…Œ์ŠคํŠธ๊ฐœ๋ฐœ ํ™˜๊ฒฝ ์ƒ์‹œ ํ™œ์„ฑํ™”
์—ฐ๊ด€๊ด€๊ณ„ToOne ๊ธฐ๋ณธ EAGER ๋ฐฉ์น˜ ์—ฌ๋ถ€๋ชจ๋‘ LAZY ๋ช…์‹œ
N+1๋ชฉ๋ก ์กฐํšŒ ์‹œ ๋ฐ˜๋ณต SQLToOne 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 ์ƒ์‹œ ํ™•์ธ, ๋งˆ์ด๊ทธ๋ ˆ์ด์…˜ ๋„๊ตฌ
๐Ÿ ์ตœ์ข… ์ •๋ฆฌ JPA ์„ฑ๋Šฅ ์ตœ์ ํ™”๋Š” ๋งˆ๋ฒ• ๊ฐ™์€ ์„ค์ • ํ•˜๋‚˜๊ฐ€ ์•„๋‹ˆ๋ผ "์ฟผ๋ฆฌ ์ˆ˜๋ฅผ ์ค„์ด๊ณ (N+1), ์ฟผ๋ฆฌ ํฌ๊ธฐ๋ฅผ ์ค„์ด๊ณ (ํ”„๋กœ์ ์…˜ยทํŽ˜์ด์ง•), ์™•๋ณต์„ ๋ฌถ๊ณ (๋ฐฐ์น˜), ๊ด€๋ฆฌ ๋น„์šฉ์„ ์ค„์ด๊ณ (readOnlyยทclear), ์ž์›์„ ์•„๋ผ๋Š”(์ปค๋„ฅ์…˜ยท์บ์‹œ)" ๋‹ค์„ฏ ๊ฐˆ๋ž˜์˜ ์Šต๊ด€์ž…๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๊ทธ ๋ชจ๋“  ํŒ๋‹จ์˜ ์ถœ๋ฐœ์ ์€ ์ธก์ •์ž…๋‹ˆ๋‹ค.

๐Ÿ’ฌ ์ž์ฃผ ๋ฌป๋Š” ์งˆ๋ฌธ

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 ๋กœ๊ทธ๋ถ€ํ„ฐ ํ•œ๋ฒˆ ์—ด์–ด ๋ณด์„ธ์š”. ๐Ÿท

#JPA#Hibernate6#N+1#fetchjoin#๋ฐฐ์น˜์ฒ˜๋ฆฌ#2์ฐจ์บ์‹œ#HikariCP#SpringDataJPA

๐Ÿ“Ž ์ฐธ๊ณ  ์ž๋ฃŒ

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
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.