- "I use JPA because it's convenient as an ORM."
- I know that using save() performs a save.
- I'm not really sure about the persistence context.
Mastering JPA for Working Developers
Persistence Context ~ QueryDSL · Lv.2
🧠 Lv.2 · From Persistence Context to Practical Patterns
From Pain → Salvation Learning Method · JPA in Practice
You can use save(), but if you can't explain
'why', you will fail.
For those who have performed CRUD with JdbcTemplate but get stuck when asked, "What is the persistence context?" Through the “Suffering → Salvation” learning method—where you first experience the pain of 35 lines of pure JDBC before realizing the greatness of JPA—you will become a developer who can explain even the internal workings.
Simple Query
JDBC 35 lines
JPA 3 lines
Target Audience
Those who have used JdbcTemplate but do not know about the Persistence Context
Methodology
Pain → Salvation — 5 weeks, 41 lectures of direct experience and realization
Result
Explaining the 'why' behind Persistence Context, N+1, and QueryDSL
Why do you get stuck again?
Most JPA courses only teach you 'how'.
"Just add @Entity and use save()." If you follow that, it works. But interviewers will ask, "What is the operating principle of the persistence context?" or "How did you resolve the N+1 problem?"
save()만 알아요
They stop at "Just add @Entity and use save()."
내부를 몰라요
They cannot explain the principles of the persistence context, N+1, and dirty checking.
JDBC를 안 겪었어요
Without the pain of writing 35 lines of JDBC code, you won't appreciate the value of JPA.
This course intentionally inflicts pain first. Only those who have manually written 35 lines of JDBC code can explain why a persistence context is necessary.
🧠 Understanding JPA through Metaphors
Core concepts, explained so you'll never forget them once you've heard them.
Persistence Context, Write-Behind, Lazy Loading, Dynamic Queries, N+1, Relationships — I will show you not just the code, but the "what and why" through metaphors.
영속성컨텍스트
"What is a persistence context?"
It is explained as a secretary who works through first-level caching and change detection.
쓰기지연
"When is the INSERT executed?"
Answer that it sends them all at once, just like batching deliveries.
지연로딩
"How does lazy loading work?"
It explains that the fake employee (proxy) loads when real work arises.
동적쿼리
"How did you write the dynamic queries?"
Assemble QueryDSL like Lego safely at compile time.
N+1
"How did you solve the N+1 problem?"
Answer with three methods, including Fetch Join.
연관관계
"Why did you design @ManyToOne that way?"
It explains that the object-table mismatch is resolved through mapping.
Pain → Salvation · 5 Weeks
You have to experience it firsthand for it to be etched into your bones.
You shouldn't learn save() first. Every week, you will personally experience the journey from "pain to salvation." After enduring the 35-line hell and N+1 explosions, the principles will flow naturally during interviews.
1주차
I wrote 35 lines of code for a single SELECT statement using JDBC.
After that pain, I experience the revolution of 3 lines of persistence context.
2주차
Data has been corrupted due to missing EnumType and the use of merge().
EnumType.STRING and change detection provide a safe defense.
3주차
11 queries were executed to retrieve 10 members.
I experienced reducing it to just one line with a Fetch Join.
4주차
I copy-pasted createdAt into every entity.
BaseEntity in one go to inherit common fields.
5주차
A JPQL string typo caused a runtime failure.
QueryDSL catches it at compile time.
Before / After
The same questions and answers determine whether you pass or fail.
- "After trying it myself with JDBC, the mismatch between objects and tables was difficult."
- "I found that the persistence context's first-level cache and dirty checking solved this."
- I answer the N+1 problem with three methods, including Fetch Join.
Lv.1 What's next
I can handle CRUD, but I get stuck again during interviews.
I created CRUD with JdbcTemplate. However, the common pattern of failure begins again.
1
I built CRUD with JdbcTemplate
2
Questioning "Why do I have to write SQL as a string?"
3
Interviewer: "What is the persistence context?" "...What?"
4
Failed because I couldn't explain it since I've never used it 😵
Backend Developer Roadmap
This course is the core of the roadmap, Lv.2.
If you have solidified your Spring Boot foundations in Lv.1, it is now time to master JPA, the most widely used tool in practical application.
Lv.0
데이터베이스 핵심 개념
Build a solid foundation before starting Spring.
Lv.1
Spring Boot 입문
Build APIs with Spring and prepare for interviews.
Lv.2
현업 개발자의 JPA 완전 정복 (이 강의)
From Persistence Context to QueryDSL.
Lv.3
6주 완성 백엔드 이력서 돋보이는 법 ↗
Once you have equipped yourself with practical weapons, it's time to differentiate your resume and pass the screening process.
By any chance
Has this ever happened to you?
Have you ever been speechless when asked to "explain the persistence context"?
"Have you ever solved the N+1 problem?" and only being able to give one answer?
Curriculum
5 weeks, 41 lectures · From Persistence Context to QueryDSL.
Persistence Context → Entity Mapping → Relationships/Proxies → Inheritance/Value Types → QueryDSL. Experience every concept through the journey of "Pain → Salvation." Click on a section to view the detailed table of contents.
섹션 1. 🦸 1주차 · 영속성 컨텍스트, JDBC 고통 → 구원
- 1😱 The Pain of Pure JDBC: 35 Lines for a Single SELECT
- 2🦸 Persistence Context: The Savior Who Ended the Pain
- 3📦 First-Level Cache: The Secret to Minimizing DB Access
- 4🔍 Dirty Checking: I know what you changed
- 5📮 Transactional Write-Behind: Batching for a Single Shot
섹션 2. 🏷️ 2주차 · 엔티티 매핑과 Spring Data JPA
- 6🏷️ Complete Understanding of @Entity, @Table, and @Column
- 7🔑 Primary Key Mapping Strategies
- 8🚽 Flush: The moment the water goes down
- 9👻 Detached State: When the Secretary Goes Home
- 10🎁 Spring Data JPA + The Pitfalls of save() and merge()
섹션 3. 🌍 3주차 · 연관관계와 프록시·지연 로딩
- 11🌍 Object World vs. Table World
- 12↔️ Unidirectional/Bidirectional Mapping and the Rule of the Owner
- 13⚡ Eager Loading vs. Lazy Loading: Why is LAZY the default?
- 14🎭 Proxy: The fake object that enables lazy loading
- 15👨👦 CASCADE & Orphan Removal
섹션 4. 🧬 4주차 · 상속 매핑과 값 타입
- 16🧬 Inheritance Mapping: Joined vs. Single Table Strategy
- 17📋 @MappedSuperclass: Common fields with BaseEntity
- 18💳 Practice: Payment Domain Inheritance + AttributeConverter
- 19🎁 Value Types: Embedded and Immutable Objects
- 20📚 Limitations and Alternatives of Value Type Collections
섹션 5. 🏗️ 5주차 · QueryDSL 실무
- 21🏗️ Project Environment Setup and the Secret of Q-Classes
- 22🔎 Basic Syntax: Search, Sorting, Paging, and Aggregation
- 23🔗 Joins and Fetch Joins: The Solution to N+1
- 24🚦 Dynamic Query: BooleanBuilder · Multi-Parameter
- 25⚡ Performance Optimization: DTO Projections and Bulk Operations
Recommended for
If you can handle CRUD but can't explain what's happening internally.
Who this is for
🙋
Those who have performed CRUD with JdbcTemplate but do not know about the "Persistence Context"
🤔
Those who know save() but don't know "what happens internally"
🧑💻
Those who cannot find the N+1 problem when it occurs in their own code
🎯
Those who want to answer the question "Explain the persistence context" based on actual experience
Those who need to align their expectations
- Those who are completely new to Spring and JPA (Lv.1 is recommended first)
- Those who are unfamiliar with Java syntax itself
- Those who insist on using only pure SQL without an ORM
Note before taking the course
Lv.2 — You can start if you have experience at the Lv.1 level.
01
Experience handling Spring even just a little (Recommended to have completed Lv.1 Spring Boot Introduction).
02
MySQL CRUD experience.
03
IntelliJ Community (Free) is sufficient — works on both Windows and Mac, installation guides provided for each OS.
What you will be able to do after taking this course
By the end of this course, you will be able to do these four things.
Explains the internal operations of the persistence context, including the first-level cache and dirty checking.
Solve the N+1 problem using three methods, including Fetch Join.
Association mapping resolves the object-table paradigm mismatch.
QueryDSL is used to create type-safe dynamic queries at compile time.
Why this course?
Directly taught by a current developer who has reached the final interview stages at Coupang and Yanolja.
A 6-year developer who reached the final interviews at Coupang and Yanolja, and an instructor with a story of switching between 24 companies, teaches you directly.
Former Viva Republica (Toss) Server Developer — Explaining the "Why" from a field-proven perspective.
This is not a lecture that ends with just teaching you "how"; it connects concepts to hands-on experience and even interview answers.
I support students until the end by operating a developer career success community (KakaoTalk/Discord).
Student Benefits
If you leave a course review, you will receive a JPA interview question workbook.
🎁 Special Benefits for Students
We will organize the lecture content into a [Lv.2] JPA Interview Question Workbook (Notion link).
A Notion workbook for self-practice, featuring frequently asked interview questions and model answers on topics such as Persistence Context, N+1 problems, and QueryDSL.
JPA Interview Workbook
Notion Link Provided
Course Review Verification
How to receive — Please verify your course review in the community. The verification method is detailed in the very last lecture of the curriculum, 🎁 EVENT 🎁 How to verify your course review.
🎟 EVENT 2 — Submit the Google Form via the information link to receive a 15% discount coupon.
💻 EVENT 3 — JetBrains Collaboration Benefit: IntelliJ 3-month free trial (Promotion code HYUNJOONPARKxJB, for new JetBrains users). Please check the community announcement for the expiration date.
💬 KakaoTalk Channel Benefits
If you add the Dingko Dingko KakaoTalk channel, you will receive a 15% discount coupon.
💻 Scan QR code on PC
📱 채널 추가하고 쿠폰 받기 →
On mobile, just one tap and you're there
※ Discounts cannot be combined
FAQ
Expand and check only the parts you are curious about.
JPA를 처음 보는데 들어도 되나요?
This course is Lv.2. It assumes you have experience performing CRUD with JdbcTemplate or have a level of proficiency equivalent to Lv.1 Spring Boot Introduction. If you are completely new to JPA, we recommend starting from Lv.1.
따라하기 강의랑 뭐가 다른가요?
I intentionally inflict pain first. Only after you've manually written 35 lines of code for a single SELECT using pure JDBC and experienced the hell of 11 queries exploding due to N+1, will you truly appreciate the greatness of three lines of persistence context and a single line of Fetch Join. This experience will form the basis of interview answers that begin with, "I've actually experienced this myself."
실습 환경은 어떻게 되나요?
We use IntelliJ. The Community (free) version is sufficient, and it is available for both Windows and Mac. Learning materials (Notion, PDF) and project code will be shared.
이 강의를 들으면 어디까지 할 수 있나요?
Master JPA's most frequently used features in practice, including persistence context, associations, proxies, inheritance mapping, value types, and QueryDSL. This is Level 2 of the Backend Roadmap, the next step after Level 1 (Introduction to Spring Boot).
Don't just memorize it; explain the persistence context down to the 'why'.
You must experience the pain of 35 lines of JDBC to see the revolution of 3 lines of JPA. You must go through the hell of N+1 to have Fetch Join engraved in your bones. Five weeks later, you will be giving answers that start with, "I’ve actually experienced this myself."
I am enjoying the lectures. Subjectively speaking, this is the easiest course to understand.
It explains JPA very easily and provides a clear explanation of the paradigm mismatch between objects and database tables along with relevant examples. Rather than just listing various JPA features, it recommends specific features to use and those to avoid, providing practical advice on how they are typically used in real-world development. For those already familiar with JPA in a professional setting, it serves as a great refresher course; for those using it for the first time or considering its adoption, it can be used as a guidebook to build services without much difficulty.
This course is designed to introduce and allow you to practice everything from the basics of JPA to production-level code. It doesn't stop at simple usage; by learning the internal working principles, I feel I was able to build an even more solid foundation! Thank you for the excellent lecture!
Great things about this course - It teaches JPA very well with a focus on practical application. - Theories are explained through analogies, which helped me understand them quickly. Points to note when taking the course - You won't remember much if you just listen. That's why I think it's important to listen to one lecture, type along with the materials, and ensure you understand before moving on. Areas for improvement - There are occasional typos in the videos. For example, "polymorphism" is written as "diversity," and there are cases where words like "builder.and" are incorrectly displayed as "builder.end" in the subtitles.
I used to just add annotations without really knowing how they worked internally, but by going back and forth between the test code and the actual implementation, I was able to better understand how it works logically and why we use JPA!
![[Backend/Exception Handling Scenario/Aggregation Optimization] Backend Portfolio and Practical Experience Enhancement Strategy. All-in-One PART1Course Thumbnail](https://cdn.inflearn.com/public/courses/335091/cover/1a19a4de-ec2e-4e26-a84e-28691e777020/335091.jpg?w=420)
![[Spring AI in Practice] Creating Your Own 24-Hour Code Reviewer & Automatic Grading AgentCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/340163/cover/01kd87fc1wdcg20nnkcngd9wap?w=420)
![2026 Coding Test All-in-One [JAVA]Course Thumbnail](https://cdn.inflearn.com/public/files/courses/339641/cover/01kaycw3h9vr2qs2ed5j6p2f9m?w=420)
![[From JSP to Spring Boot] The Unwavering Path to SpringBootCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/334897/cover/01k2j21p3rz09cqh5s0frefaa5?w=420)
![[Java Advanced Practical Project] Spring Core + H2 Based Food Truck Kiosk System DevelopmentCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/336594/cover/01k8hetsq20rg69zw5ve0q5729?w=420)
![[Season 1] Spring AI in Practice: Developing a Premium Reservation AI AgentCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/339732/cover/01kb2qr7zw5gf0724jvv4rndns?w=420)
![[Season 2] Spring AI in Practice: Developing Multi-AI Agent SystemsCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/339915/cover/01kbqgcec3hb576vxxdf9ch76y?w=420)