02E. ๋ฆฌํฌ์งํฐ๋ฆฌ
02E. ๋ฆฌํฌ์งํฐ๋ฆฌ ๊ด๋ จ
์ด๋ฒ ์ฅ์์๋ JPA๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํด ๋ณด์.
๋ฆฌํฌ์งํฐ๋ฆฌ
์ํฐํฐ๋ง์ผ๋ก๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ฑฐ๋ ์กฐํ ํ ์ ์๋ค. ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ฅผ ์ํด์๋ ์ค์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ฐ๋ํ๋ JPA ๋ฆฌํฌ์งํฐ๋ฆฌ๊ฐ ํ์ํ๋ค.
๋ฆฌํฌ์งํฐ๋ฆฌ๋?
๋ฆฌํฌ์งํฐ๋ฆฌ๋ ์ํฐํฐ์ ์ํด ์์ฑ๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค ํ
์ด๋ธ์ ์ ๊ทผํ๋ ๋ฉ์๋๋ค(์: findAll
, save
๋ฑ)์ ์ฌ์ฉํ๊ธฐ ์ํ ์ธํฐํ์ด์ค์ด๋ค. ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ฅผ ์ํด์๋ ํ
์ด๋ธ์ ์ด๋ค ๊ฐ์ ๋ฃ๊ฑฐ๋ ๊ฐ์ ์กฐํํ๋ ๋ฑ์ CRUD(Create, Read, Update, Delete)๊ฐ ํ์ํ๋ค. ์ด ๋ ์ด๋ฌํ CRUD๋ฅผ ์ด๋ป๊ฒ ์ฒ๋ฆฌํ ์ง ์ ์ํ๋ ๊ณ์ธต์ด ๋ฐ๋ก ๋ฆฌํฌ์งํฐ๋ฆฌ์ด๋ค.
๋ค์๊ณผ ๊ฐ์ด QuestionRepository
์ธํฐํ์ด์ค๋ฅผ ์์ฑํ์.
ํ์ผ๋ช :
/sbb/src/main/java/com/mysite/sbb/
QuestionRepository.java
package com.mysite.sbb;
import org.springframework.data.jpa.repository.JpaRepository;
public interface QuestionRepository extends JpaRepository<Question, Integer> {
}
QuestionRepository
๋ ๋ฆฌํฌ์งํฐ๋ฆฌ๋ก ๋ง๋ค๊ธฐ ์ํด JpaRepository ์ธํฐํ์ด์ค๋ฅผ ์์ํ๋ค. JpaRepository๋ฅผ ์์ํ ๋๋ ์ ๋ค๋ฆญ์ค ํ์
์ผ๋ก <Question, Integer>
์ฒ๋ผ ๋ฆฌํฌ์งํฐ๋ฆฌ์ ๋์์ด ๋๋ ์ํฐํฐ์ ํ์
(Question)๊ณผ ํด๋น ์ํฐํฐ์ PK์ ์์ฑ ํ์
(Integer)์ ์ง์ ํด์ผ ํ๋ค. ์ด๊ฒ์ JpaRepository๋ฅผ ์์ฑํ๊ธฐ ์ํ ๊ท์น์ด๋ค.
Question ์ํฐํฐ์ PK(Primary Key) ์์ฑ์ธ
id
์ ํ์ ์Integer
์ด๋ค.
๋ง์ฐฌ๊ฐ์ง๋ก AnswerRepository
๋ ๋ค์๊ณผ ๊ฐ์ด ์์ฑํ์.
ํ์ผ๋ช :
/sbb/src/main/java/com/mysite/sbb/
AnswerRepository.java
package com.mysite.sbb;
import org.springframework.data.jpa.repository.JpaRepository;
public interface AnswerRepository extends JpaRepository<Answer, Integer> {
}
์ด์ QuestionRepository
, AnswerRepository๋ฅผ
์ด์ฉํ์ฌ question
, answer
ํ
์ด๋ธ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ฑฐ๋ ์กฐํํ ์ ์๋ค.
๋ฐ์ดํฐ ์ ์ฅํ๊ธฐ
์์ฑํ ๋ฆฌํฌ์งํฐ๋ฆฌ๋ฅผ ํ ์คํธํ๊ธฐ ์ํด์ JUnit ๊ธฐ๋ฐ์ ์คํ๋ง๋ถํธ์ ํ ์คํธ ํ๋ ์์ํฌ๋ฅผ ์ฌ์ฉํด ๋ณด์.
ํ์ผ๋ช :
/sbb/src/test/java/com/mysite/sbb/
SbbApplicationTests.java
package com.mysite.sbb;
import java.time.LocalDateTime;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {
@Autowired
private QuestionRepository questionRepository;
@Test
void testJpa() {
Question q1 = new Question();
q1.setSubject("sbb๊ฐ ๋ฌด์์ธ๊ฐ์?");
q1.setContent("sbb์ ๋ํด์ ์๊ณ ์ถ์ต๋๋ค.");
q1.setCreateDate(LocalDateTime.now());
this.questionRepository.save(q1); // ์ฒซ๋ฒ์งธ ์ง๋ฌธ ์ ์ฅ
Question q2 = new Question();
q2.setSubject("์คํ๋ง๋ถํธ ๋ชจ๋ธ ์ง๋ฌธ์
๋๋ค.");
q2.setContent("id๋ ์๋์ผ๋ก ์์ฑ๋๋์?");
q2.setCreateDate(LocalDateTime.now());
this.questionRepository.save(q2); // ๋๋ฒ์งธ ์ง๋ฌธ ์ ์ฅ
}
}
@SpringBootTest
์ ๋ํ
์ด์
์ SbbApplicationTests
ํด๋์ค๊ฐ ์คํ๋ง๋ถํธ ํ
์คํธ ํด๋์ค์์ ์๋ฏธํ๋ค. ๊ทธ๋ฆฌ๊ณ @Autowired
์ ๋ํ
์ด์
์ ์คํ๋ง์ DI ๊ธฐ๋ฅ์ผ๋ก questionRepository
๊ฐ์ฒด๋ฅผ ์คํ๋ง์ด ์๋์ผ๋ก ์์ฑํด ์ค๋ค.
DI(Dependency Injection) - ์คํ๋ง์ด ๊ฐ์ฒด๋ฅผ ๋์ ์์ฑํ์ฌ ์ฃผ์ ํ๋ค.
@Autowired
๊ฐ์ฒด๋ฅผ ์ฃผ์
ํ๊ธฐ ์ํด ์ฌ์ฉํ๋ ์คํ๋ง์ ์ ๋ํ
์ด์
์ด๋ค. ๊ฐ์ฒด๋ฅผ ์ฃผ์
ํ๋ ๋ฐฉ์์๋ @Autowired
์ธ์ Setter ๋๋ ์์ฑ์๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ์์ด ์๋ค. ์ํ์ฐธ์กฐ ๋ฌธ์ ์ ๊ฐ์ ์ด์ ๋ก @Autowired
๋ณด๋ค๋ ์์ฑ์๋ฅผ ํตํ ๊ฐ์ฒด ์ฃผ์
๋ฐฉ์์ด ๊ถ์ฅ๋๋ค. ํ์ง๋ง ํ
์คํธ ์ฝ๋์ ๊ฒฝ์ฐ์๋ ์์ฑ์๋ฅผ ํตํ ๊ฐ์ฒด์ ์ฃผ์
์ด ๋ถ๊ฐ๋ฅํ๋ฏ๋ก ํ
์คํธ ์ฝ๋ ์์ฑ์์๋ง @Autowired
๋ฅผ ์ฌ์ฉํ๊ณ ์ค์ ์ฝ๋ ์์ฑ์์๋ ์์ฑ์๋ฅผ ํตํ ๊ฐ์ฒด ์ฃผ์
๋ฐฉ์์ ์ฌ์ฉํ๊ฒ ๋ค.
testJpa
๋ฉ์๋ ์์ @Test
์ ๋ํ
์ด์
์ testJpa
๋ฉ์๋๊ฐ ํ
์คํธ ๋ฉ์๋์์ ๋ํ๋ธ๋ค. ์ ํด๋์ค๋ฅผ JUnit์ผ๋ก ์คํํ๋ฉด @Test
์ ๋ํ
์ด์
์ด ๋ถ์ ๋ฉ์๋๊ฐ ์คํ๋๋ค.
JUnit์ ํ ์คํธ์ฝ๋๋ฅผ ์์ฑํ๊ณ ์์ฑํ ํ ์คํธ์ฝ๋๋ฅผ ์คํํ๊ธฐ ์ํด ์ฌ์ฉํ๋ ์๋ฐ์ ํ ์คํธ ํ๋ ์์ํฌ์ด๋ค.
testJpa
๋ฉ์๋์ ๋ด์ฉ์ ์ ์ ์ดํด๋ณด์. testJpa
๋ฉ์๋๋ q1
, q2
๋ผ๋ Question
์ํฐํฐ ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ณ QuestionRepository
๋ฅผ ์ด์ฉํ์ฌ ๊ทธ ๊ฐ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ์ฅํ๋ ์ฝ๋์ด๋ค.
ํ์ง๋ง ๋ก์ปฌ์๋ฒ๊ฐ ์ด๋ฏธ ๊ตฌ๋์ค์ด๋ผ๋ฉด The file is locked: nio:/Users/pahkey/local.mv.db
์ ๋น์ทํ ์ค๋ฅ๊ฐ ๋ฐ์ํ ๊ฒ์ด๋ค. H2 ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ ํ์ผ ๊ธฐ๋ฐ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ด๊ธฐ ๋๋ฌธ์ ์ด๋ฏธ ๋ก์ปฌ์๋ฒ๊ฐ ์ ์ ํ๊ณ ์๊ธฐ ๋๋ฌธ์ ์ด๋ฌํ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ ๊ฒ์ด๋ค. ๋ฐ๋ผ์ ํ
์คํธ๋ฅผ ํ๊ธฐ ์ํด์๋ ๋ก์ปฌ ์๋ฒ๋ฅผ ์ค์งํด์ผ ํ๋ค.
๋ก์ปฌ์๋ฒ๋ฅผ ์ค์งํ๊ณ ๋ค์ ํ ์คํธ๋ฅผ ์คํํด ๋ณด์. ๊ทธ๋ฌ๋ฉด ๋ค์๊ณผ ๊ฐ์ JUnit ํ๋ฉด์ด ๋ํ๋๊ณ ์ค๋ฅ์์ด ์ ์คํ๋ ๊ฒ์ด๋ค.
์ค์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๊ฐ์ด ์ ๋ค์ด๊ฐ๋์ง ํ์ธํด ๋ณด๊ธฐ ์ํด ๋ค์ ๋ก์ปฌ์๋ฒ๋ฅผ ์์ํ๊ณ H2 ์ฝ์์ ์ ์ํ์ฌ ๋ค์ ์ฟผ๋ฆฌ๋ฌธ์ ์คํํด ๋ณด์.
SELECT * FROM QUESTION
id
๋ Question
์ํฐํฐ์ ๊ธฐ๋ณธ ํค(Primary Key)์ด๋ค. id
๋ ์์์ ์ํฐํฐ๋ฅผ ์์ฑํ ๋ ์ค์ ํ๋๋๋ก ๋ฐ์ดํฐ๋ฅผ ์์ฑํ ๋ ์์ฑ๊ฐ์ด ์๋์ผ๋ก 1์ฉ ์ฆ๊ฐํ๋ ๊ฒ์ ํ์ธํ ์ ์๋ค.
Question ์ํฐํฐ์ id๋
@GeneratedValue
์ค์ ์ ํ๋ค.
๋ฐ์ดํฐ ์กฐํํ๊ธฐ
์ด๋ฒ์๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ ์กฐํํด ๋ณด์.
findAll
์์ฑํ ํ ์คํธ ์ฝ๋๋ฅผ ๋ค์์ฒ๋ผ ์์ ํด ๋ณด์.
ํ์ผ๋ช :
/sbb/src/test/java/com/mysite/sbb/
SbbApplicationTests.java
package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {
@Autowired
private QuestionRepository questionRepository;
@Test
void testJpa() {
List<Question> all = this.questionRepository.findAll();
assertEquals(2, all.size());
Question q = all.get(0);
assertEquals("sbb๊ฐ ๋ฌด์์ธ๊ฐ์?", q.getSubject());
}
}
question
ํ
์ด๋ธ์ ์ ์ฅ๋ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ์กฐํํ๊ธฐ ์ํด์ ๋ฆฌํฌ์งํฐ๋ฆฌ์ findAll
๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
findAll
์ ๋ฐ์ดํฐ๋ฅผ ์กฐํํ ๋ ์ฌ์ฉํ๋ ๋ฉ์๋์ด๋ค.
์ฐ๋ฆฌ๋ ์ด 2๊ฑด์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ธฐ ๋๋ฌธ์ ๋ฐ์ดํฐ์ ์ฌ์ด์ฆ๋ 2๊ฐ ๋์ด์ผ ํ๋ค. ๋ฐ์ดํฐ ์ฌ์ด์ฆ๊ฐ 2์ธ์ง ํ์ธํ๊ธฐ ์ํด JUnit์ assertEquals
๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค. assertEquals
๋ assertEquals(๊ธฐ๋๊ฐ, ์ค์ ๊ฐ)
์ ๊ฐ์ด ์ฌ์ฉํ๊ณ ๊ธฐ๋๊ฐ๊ณผ ์ค์ ๊ฐ์ด ๋์ผํ์ง๋ฅผ ์กฐ์ฌํ๋ค. ๋ง์ฝ ๊ธฐ๋๊ฐ๊ณผ ์ค์ ๊ฐ์ด ๋์ผํ์ง ์๋ค๋ฉด ํ
์คํธ๋ ์คํจ๋ก ์ฒ๋ฆฌ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ฐ๋ฆฌ๊ฐ ์ ์ฅํ ์ฒซ๋ฒ์งธ ๋ฐ์ดํฐ์ ์ ๋ชฉ์ด "sbb๊ฐ ๋ฌด์์ธ๊ฐ์?"์ ์ผ์นํ๋์ง๋ ํ
์คํธํ๋ค.
ํ
์คํธ๋ฅผ ์ํด์๋ ๋ก์ปฌ ์๋ฒ๋ฅผ ์ค์งํ๊ณ ๋ค์ํ๋ฒ [Run -> Run As -> JUnit Test]
์ ์คํํ๋ฉด ๋๋ค. ํ
์คํธ๋ ์ ํต๊ณผ๋ ๊ฒ์ด๋ค.
์ฐ๋ฆฌ๋ ํธ์์ testJpa
๋ฉ์๋ ํ๋๋ง์ ๊ฐ์ง๊ณ JPA์ ์ฌ๋ฌ๊ธฐ๋ฅ์ ํ
์คํธํ ๊ฒ์ด๋ค.
findById
์ด๋ฒ์๋ Question
์ํฐํฐ์ Id๊ฐ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์กฐํํด ๋ณด์. ํ
์คํธ ์ฝ๋๋ฅผ ๋ค์๊ณผ ๊ฐ์ด ์์ ํ์.
ํ์ผ๋ช :
/sbb/src/test/java/com/mysite/sbb/
SbbApplicationTests.java
package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {
@Autowired
private QuestionRepository questionRepository;
@Test
void testJpa() {
Optional<Question> oq = this.questionRepository.findById(1);
if(oq.isPresent()) {
Question q = oq.get();
assertEquals("sbb๊ฐ ๋ฌด์์ธ๊ฐ์?", q.getSubject());
}
}
}
id ๊ฐ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์กฐํํ๊ธฐ ์ํด์๋ ๋ฆฌํฌ์งํฐ๋ฆฌ์ findById
๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค. ํ์ง๋ง findById
์ ๋ฆฌํด ํ์
์ Question
์ด ์๋ Optional
์์ ์ฃผ์ํ์. Optional
์ null
์ฒ๋ฆฌ๋ฅผ ์ ์ฐํ๊ฒ ์ฒ๋ฆฌํ๊ธฐ ์ํด ์ฌ์ฉํ๋ ํด๋์ค๋ก ์์ ๊ฐ์ด isPresent
๋ก null
์ด ์๋์ง๋ฅผ ํ์ธํ ํ์ get์ผ๋ก ์ค์ Question
๊ฐ์ฒด ๊ฐ์ ์ป์ด์ผ ํ๋ค.
findBySubject
์ด๋ฒ์๋ Question ์ํฐํฐ์ subject ๊ฐ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์กฐํํด ๋ณด์.
ํ์ง๋ง ์์ฝ๊ฒ๋ Question
๋ฆฌํฌ์งํฐ๋ฆฌ๋ findBySubject
์ ๊ฐ์ ๋ฉ์๋๋ฅผ ๊ธฐ๋ณธ์ ์ผ๋ก ์ ๊ณตํ์ง๋ ์๋๋ค. findBySubject ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด ๋ค์์ฒ๋ผ QuestionRepository
์ธํฐํ์ด์ค๋ฅผ ๋ณ๊ฒฝํด์ผ ํ๋ค.
ํ์ผ๋ช :
/sbb/src/main/java/com/mysite/sbb/
QuestionRepository.java
package com.mysite.sbb;
import org.springframework.data.jpa.repository.JpaRepository;
public interface QuestionRepository extends JpaRepository<Question, Integer> {
Question findBySubject(String subject);
}
๊ทธ๋ฌ๋ฉด ๋ค์์ฒ๋ผ ์ ๋ชฉ์ผ๋ก ํ ์ด๋ธ ๋ฐ์ดํฐ๋ฅผ ์กฐํํ ์ ์๋ค.
ํ์ผ๋ช :
/sbb/src/test/java/com/mysite/sbb/
SbbApplicationTests.java
package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {
@Autowired
private QuestionRepository questionRepository;
@Test
void testJpa() {
Question q = this.questionRepository.findBySubject("sbb๊ฐ ๋ฌด์์ธ๊ฐ์?");
assertEquals(1, q.getId());
}
}
ํ
์คํธ ์ฝ๋๋ฅผ ์คํํด ๋ณด๋ฉด ํ
์คํธ๋ ์์ฃผ ์ ํต๊ณผ๋๋ค. ์๋ง ์ฌ๋ฌ๋ถ์ ๋ค์๊ณผ ๊ฐ์ ์ง๋ฌธ๊ณผ ํจ๊ป ํฐ ํผ๋์ด ์ฐพ์ ์ฌ์ง๋ ๋ชจ๋ฅธ๋ค. "์ธํฐํ์ด์ค์ findBySubject
๋ผ๋ ๋ฉ์๋๋ฅผ ์ ์ธ๋ง ํ๊ณ ๊ตฌํ์ ํ์ง ์์๋๋ฐ ๋๋์ฒด ์ด๋ป๊ฒ ์คํ์ด ๋๋ ๊ฑฐ์ง?"
์ด๋ฌํ ๋ง๋ฒ์ JpaRepository๋ฅผ ์์ํ QuestionRepository
๊ฐ์ฒด๊ฐ ์์ฑ๋ ๋ ๋ฒ์ด์ง๋ค. (DI์ ์ํด ์คํ๋ง์ด ์๋์ผ๋ก QuestionRepository
๊ฐ์ฒด๋ฅผ ์์ฑํ๋ค. ์ด ๋ ํ๋ก์ ํจํด์ด ์ฌ์ฉ๋๋ค๊ณ ํ๋ค.) ๋ฆฌํฌ์งํฐ๋ฆฌ ๊ฐ์ฒด์ ๋ฉ์๋๊ฐ ์คํ๋ ๋ JPA๊ฐ ํด๋น ๋ฉ์๋๋ช
์ ๋ถ์ํ์ฌ ์ฟผ๋ฆฌ๋ฅผ ๋ง๋ค๊ณ ์คํํ๋ค.
์ฆ, ์ฌ๋ฌ๋ถ์ findBy
+ ์ํฐํฐ์ ์์ฑ๋ช
(์:findBySubject
)๊ณผ ๊ฐ์ ๋ฆฌํฌ์งํฐ๋ฆฌ ๋ฉ์๋๋ฅผ ์์ฑํ๋ฉด ํด๋น ์์ฑ์ ๊ฐ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์กฐํํ ์ ์๋ค.
findBySubject
๋ฉ์๋๋ฅผ ํธ์ถํ ๋ ์ค์ ์ด๋ค ์ฟผ๋ฆฌ๊ฐ ์คํ๋๋์ง ์ดํด๋ณด์. ์คํ๋๋ ์ฟผ๋ฆฌ๋ฅผ ๋ก๊ทธ์์ ๋ณด๋ ค๋ฉด application.properties
ํ์ผ์ ๋ค์๊ณผ ๊ฐ์ด ์์ ํด์ผ ํ๋ค.
ํ์ผ๋ช :
/sbb/src/main/resources/
application.properties
# DATABASE
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
spring.datasource.url=jdbc:h2:~/local
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
# JPA
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.show_sql=true
๊ทธ๋ฆฌ๊ณ ๋ค์ํ๋ฒ ํ ์คํธ์ฝ๋๋ฅผ ์คํํด ๋ณด์. ๊ทธ๋ฌ๋ฉด ๋ค์๊ณผ ๊ฐ์ด ์ฝ์๋ก๊ทธ์์ ์คํ๋ ์ฟผ๋ฆฌ๋ฅผ ํ์ธํ ์ ์๋ค.
findBySubjectAndContent
์ด๋ฒ์๋ ์ ๋ชฉ๊ณผ ๋ด์ฉ์ ํจ๊ป ์กฐํํด ๋ณด์. ๋ ๊ฐ์ ์์ฑ์ And ์กฐ๊ฑด์ผ๋ก ์กฐํํ ๋๋ ๋ฆฌํฌ์งํฐ๋ฆฌ์ ๋ค์๊ณผ ๊ฐ์ ๋ฉ์๋๋ฅผ ์ถ๊ฐํด์ผ ํ๋ค.
ํ์ผ๋ช :
/sbb/src/main/java/com/mysite/sbb/
QuestionRepository.java
package com.mysite.sbb;
import org.springframework.data.jpa.repository.JpaRepository;
public interface QuestionRepository extends JpaRepository<Question, Integer> {
Question findBySubject(String subject);
Question findBySubjectAndContent(String subject, String content);
}
๊ทธ๋ฆฌ๊ณ ํ ์คํธ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ์ด ์์ฑํ์.
ํ์ผ๋ช :
/sbb/src/test/java/com/mysite/sbb/
SbbApplicationTests.java
package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {
@Autowired
private QuestionRepository questionRepository;
@Test
void testJpa() {
Question q = this.questionRepository.findBySubjectAndContent(
"sbb๊ฐ ๋ฌด์์ธ๊ฐ์?", "sbb์ ๋ํด์ ์๊ณ ์ถ์ต๋๋ค.");
assertEquals(1, q.getId());
}
}
ํ ์คํธ๋ ์ ํต๊ณผ๋ ๊ฒ์ด๋ค. ๊ทธ๋ฆฌ๊ณ ์ค์ ์ฟผ๋ฆฌ๋ ๋ค์๊ณผ ๊ฐ์ด ์คํ๋๋ ๊ฒ์ ์ฝ์ ๋ก๊ทธ์์ ํ์ธํ ์ ์๋ค.
SELECT
question0_.id as id1_1_,
question0_.content as content2_1_,
question0_.create_date as create_d3_1_,
question0_.subject as subject4_1_
from
question question0_
WHERE
question0_.subject=?
AND question0_.content=?
subject
, content
์ปฌ๋ผ์ด AND
์กฐ๊ฑด์ผ๋ก WHERE
๋ฌธ์ ์ฌ์ฉ๋์๋ค.
์ด๋ ๋ฏ ๋ฆฌํฌ์งํฐ๋ฆฌ์ ๋ฉ์๋๋ช
์ ๋ฐ์ดํฐ๋ฅผ ์กฐํํ๋ ์ฟผ๋ฆฌ๋ฌธ์ WHERE
์กฐ๊ฑด์ ๊ฒฐ์ ํ๋ ์ญํ ์ ํ๋ค. ์ฌ๊ธฐ์๋ findBySubject
, findBySubjectAndContent
๋ ๊ฐ๋ง ์์๋ดค์ง๋ง ์๋นํ ๋ง์ ์กฐํฉ์ ์ฌ์ฉํ ์ ์๋ค.
๊ทธ๊ฒ๋ค์ ๋ํด์ ๊ฐ๋จํ๊ฒ ํ๋ก ์ ๋ฆฌํด ๋ณด์๋ค.
ํญ๋ชฉ | ์์ | ์ค๋ช |
---|---|---|
And | findBySubjectAndContent(String subject, String content) | ์ฌ๋ฌ ์ปฌ๋ผ์ and ๋ก ๊ฒ์ |
Or | findBySubjectOrContent(String subject, String content) | ์ฌ๋ฌ ์ปฌ๋ผ์ or ๋ก ๊ฒ์ |
Between | findByCreateDateBetween(LocalDateTime fromDate, LocalDateTime toDate) | ์ปฌ๋ผ์ between์ผ๋ก ๊ฒ์ |
LessThan | findByIdLessThan(Integer id) | ์์ ํญ๋ชฉ ๊ฒ์ |
GreaterThanEqual | findByIdGraterThanEqual(Integer id) | ํฌ๊ฑฐ๋ ๊ฐ์ ํญ๋ชฉ ๊ฒ์ |
Like | findBySubjectLike(String subject) | LIKE ๊ฒ์ |
In | findBySubjectIn(String[] subjects) | ์ฌ๋ฌ ๊ฐ์ค์ ํ๋์ธ ํญ๋ชฉ ๊ฒ์ |
OrderBy | findBySubjectOrderByCreateDateAsc(String subject) | ๊ฒ์ ๊ฒฐ๊ณผ๋ฅผ ์ ๋ ฌํ์ฌ ์ ๋ฌ |
๋จ, ์๋ต ๊ฒฐ๊ณผ๊ฐ ์ฌ๋ฌ๊ฑด์ธ ๊ฒฝ์ฐ์๋ ๋ฆฌํฌ์งํฐ๋ฆฌ ๋ฉ์๋์ ๋ฆฌํด ํ์ ์
Question
์ด ์๋List<Question>
์ผ๋ก ํด์ผ ํ๋ค.
๋ณด๋ค ์์ธํ ๋ด์ฉ์ ์ฟผ๋ฆฌ ์์ฑ ๊ท์น์ ๋ํ ๋ค์์ ๊ณต์๋ฌธ์๋ฅผ ์ฐธ๊ณ ํ์.
- https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#jpa.query-methods.query-creation
findBySubjectLike
์ด๋ฒ์๋ ์ ๋ชฉ์ ํน์ ๋ฌธ์์ด์ด ํฌํจ๋์ด ์๋ ๋ฐ์ดํฐ๋ฅผ ์กฐํํด ๋ณด์. Question ๋ฆฌํฌ์งํฐ๋ฆฌ๋ฅผ ๋ค์๊ณผ ๊ฐ์ด ์์ ํ์.
ํ์ผ๋ช :
/sbb/src/main/java/com/mysite/sbb/
QuestionRepository.java
package com.mysite.sbb;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
public interface QuestionRepository extends JpaRepository<Question, Integer> {
Question findBySubject(String subject);
Question findBySubjectAndContent(String subject, String content);
List<Question> findBySubjectLike(String subject);
}
ํ ์คํธ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ์ด ์์ ํ์.
ํ์ผ๋ช :
/sbb/src/test/java/com/mysite/sbb/
SbbApplicationTests.java
package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {
@Autowired
private QuestionRepository questionRepository;
@Test
void testJpa() {
List<Question> qList = this.questionRepository.findBySubjectLike("sbb%");
Question q = qList.get(0);
assertEquals("sbb๊ฐ ๋ฌด์์ธ๊ฐ์?", q.getSubject());
}
}
ํ ์คํธ๋ ์ ํต๊ณผ๋ ๊ฒ์ด๋ค. Like ๊ฒ์์ ์ํด์๋ findBySubjectLike ๋ฉ์๋์ ์ ๋ ฅ ๋ฌธ์์ด๋ก "sbb%"์ ๊ฐ์ด "%"๋ฅผ ์ ์ด์ฃผ์ด์ผ ํ๋ค. % ํ๊ธฐ๋ ๋ค์๊ณผ ๊ฐ์ ์๋ฏธ๋ฅผ ๊ฐ๋๋ค.
sbb%
: "sbb"๋ก ์์ํ๋ ๋ฌธ์์ด%sbb
: "sbb"๋ก ๋๋๋ ๋ฌธ์์ด%sbb%
: "sbb"๋ฅผ ํฌํจํ๋ ๋ฌธ์์ด
๋ฐ์ดํฐ ์์ ํ๊ธฐ
์ด๋ฒ์๋ ์ง๋ฌธ ๋ฐ์ดํฐ๋ฅผ ์์ ํ๋ ํ ์คํธ ์ฝ๋๋ฅผ ์์ฑํด ๋ณด์.
ํ์ผ๋ช :
/sbb/src/test/java/com/mysite/sbb/
SbbApplicationTests.java
package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {
@Autowired
private QuestionRepository questionRepository;
@Test
void testJpa() {
Optional<Question> oq = this.questionRepository.findById(1);
assertTrue(oq.isPresent());
Question q = oq.get();
q.setSubject("์์ ๋ ์ ๋ชฉ");
this.questionRepository.save(q);
}
}
assertTrue
(๊ฐ)์ ๊ฐ์ดtrue
์ธ์ง๋ฅผ ํ ์คํธํ๋ค.
์ง๋ฌธ ๋ฐ์ดํฐ๋ฅผ ์กฐํํ ๋ค์ subject๋ฅผ "์์ ๋ ์ ๋ชฉ" ์ด๋ผ๋ ๊ฐ์ผ๋ก ์์ ํ๋ค. ๋ณ๊ฒฝ๋ Question
๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ธฐ ์ํด์๋ this.questionRepository.save(q)
์ฒ๋ผ ๋ฆฌํฌ์งํฐ๋ฆฌ์ save
๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
ํ
์คํธ๋ฅผ ์ํํด ๋ณด๋ฉด ์ฝ์ ๋ก๊ทธ์์ ๋ค์๊ณผ ๊ฐ์ UPDATE
๋ฌธ์ด ์คํ๋์์์ ํ์ธํ ์ ์์ ๊ฒ์ด๋ค.
UPDATE
question
SET
content=?,
create_date=?,
subject=?
WHERE
id=?
๋ฐ์ดํฐ ์ญ์ ํ๊ธฐ
์ด์ด์ ๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ๋ ๊ฒ๋ ์ค์ตํด ๋ณด์. ์ฌ๊ธฐ์๋ ์ฒซ ๋ฒ์งธ ์ง๋ฌธ์ ์ญ์ ํด ๋ณด์.
ํ์ผ๋ช :
/sbb/src/test/java/com/mysite/sbb/
SbbApplicationTests.java
package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {
@Autowired
private QuestionRepository questionRepository;
@Test
void testJpa() {
assertEquals(2, this.questionRepository.count());
Optional<Question> oq = this.questionRepository.findById(1);
assertTrue(oq.isPresent());
Question q = oq.get();
this.questionRepository.delete(q);
assertEquals(1, this.questionRepository.count());
}
}
๋ฆฌํฌ์งํฐ๋ฆฌ์ count()
๋ฉ์๋๋ ํด๋น ๋ฆฌํฌ์งํฐ๋ฆฌ์ ์ด ๋ฐ์ดํฐ๊ฑด์๋ฅผ ๋ฆฌํดํ๋ค.
Question
๋ฆฌํฌ์งํฐ๋ฆฌ์ delete
๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ๋ค. ์ญ์ ํ๊ธฐ ์ ์๋ ๋ฐ์ดํฐ ๊ฑด์๊ฐ 2, ์ญ์ ํ ํ์๋ ๋ฐ์ดํฐ ๊ฑด์๊ฐ 1์ธ์ง๋ฅผ ํ
์คํธํ๋ค. ํ
์คํธ๋ ์ ํต๊ณผ๋ ๊ฒ์ด๋ค.
๋ต๋ณ ๋ฐ์ดํฐ ์์ฑ ํ ์ ์ฅํ๊ธฐ
์ด๋ฒ์๋ ๋ต๋ณ(Answer
) ๋ฐ์ดํฐ๋ฅผ ์์ฑํ๊ณ ์ ์ฅํด ๋ณด์.
ํ์ผ๋ช :
/sbb/src/test/java/com/mysite/sbb/
SbbApplicationTests.java
package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.time.LocalDateTime;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {
@Autowired
private QuestionRepository questionRepository;
@Autowired
private AnswerRepository answerRepository;
@Test
void testJpa() {
Optional<Question> oq = this.questionRepository.findById(2);
assertTrue(oq.isPresent());
Question q = oq.get();
Answer a = new Answer();
a.setContent("๋ค ์๋์ผ๋ก ์์ฑ๋ฉ๋๋ค.");
a.setQuestion(q); // ์ด๋ค ์ง๋ฌธ์ ๋ต๋ณ์ธ์ง ์๊ธฐ์ํด์ Question ๊ฐ์ฒด๊ฐ ํ์ํ๋ค.
a.setCreateDate(LocalDateTime.now());
this.answerRepository.save(a);
}
}
๋ต๋ณ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ฅผ ์ํด์๋ ๋ต๋ณ ๋ฆฌํฌ์งํฐ๋ฆฌ๊ฐ ํ์ํ๋ฏ๋ก AnswerRepository
๊ฐ์ฒด๋ฅผ @Autowired
๋ก ์ฃผ์
ํ๋ค. ๋ต๋ณ ๋ฐ์ดํฐ๋ฅผ ์์ฑํ๋ ค๋ฉด ์ง๋ฌธ ๋ฐ์ดํฐ๊ฐ ํ์ํ๋ฏ๋ก ์ฐ์ ์ง๋ฌธ ๋ฐ์ดํฐ๋ฅผ ๊ตฌํด์ผ ํ๋ค. id๊ฐ 2์ธ ์ง๋ฌธ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์จ ๋ค์ Answer ์ํฐํฐ์ question
์์ฑ์ ๋ฐฉ๊ธ ๊ฐ์ ธ์จ ์ง๋ฌธ ๋ฐ์ดํฐ๋ฅผ ๋์
ํด(a.setQuestion(q)
) ๋ต๋ณ ๋ฐ์ดํฐ๋ฅผ ์์ฑํ๋ค. Answer
์ํฐํฐ์๋ ์ด๋ค ์ง๋ฌธ์ ํด๋นํ๋ ๋ต๋ณ์ธ์ง ์ฐ๊ฒฐํ ๋ชฉ์ ์ผ๋ก question
์์ฑ์ด ํ์ํ๋ค.
ํ ์คํธ๋ฅผ ์ํํด ๋ณด์. ๋ต๋ณ ๋ฐ์ดํฐ๊ฐ ์ ์์ฑ๋ ๊ฒ์ด๋ค.
๋ต๋ณ ์กฐํํ๊ธฐ
Answer
๋ Question
์ํฐํฐ์ ๋ง์ฐฌ๊ฐ์ง๋ก id ์์ฑ์ด ๊ธฐ๋ณธ ํค์ด๋ฏ๋ก ๊ฐ์ด ์๋์ผ๋ก ์์ฑ๋๋ค. ๋ค์์ฒ๋ผ id ๊ฐ์ ์ด์ฉํด ๋ฐ์ดํฐ๋ฅผ ์กฐํํด ๋ณด์.
ํ์ผ๋ช :
/sbb/src/test/java/com/mysite/sbb/
SbbApplicationTests.java
package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {
@Autowired
private QuestionRepository questionRepository;
@Autowired
private AnswerRepository answerRepository;
@Test
void testJpa() {
Optional<Answer> oa = this.answerRepository.findById(1);
assertTrue(oa.isPresent());
Answer a = oa.get();
assertEquals(2, a.getQuestion().getId());
}
}
id ๊ฐ์ด 1์ธ ๋ต๋ณ์ ์กฐํํ๋ค. ๊ทธ๋ฆฌ๊ณ ๊ทธ ๋ต๋ณ์ ์ง๋ฌธ id๊ฐ 2์ธ์ง๋ ํ ์คํธํด ๋ณด์๋ค.
๋ต๋ณ์ ์ฐ๊ฒฐ๋ ์ง๋ฌธ ์ฐพ๊ธฐ vs ์ง๋ฌธ์ ๋ฌ๋ฆฐ ๋ต๋ณ ์ฐพ๊ธฐ
์์์ ๊ตฌ์ฑํ Answer
์ํฐํฐ์ question
์์ฑ์ ์ด์ฉํ๋ฉด "๋ต๋ณ์ ์ฐ๊ฒฐ๋ ์ง๋ฌธ"์ ์กฐํํ ์ ์๋ค.
a.getQuestion()
๋ต๋ณ์ ์ฐ๊ฒฐ๋ ์ง๋ฌธ ์ฐพ๊ธฐ๋ Answer
์ํฐํฐ์ question
์์ฑ์ด ์ ์๋์ด ์์ด์ ๋งค์ฐ ์ฝ๋ค. ๊ทธ๋ฐ๋ฐ ๋ฐ๋์ ๊ฒฝ์ฐ๋ ๊ฐ๋ฅํ ๊น? ์ฆ, ์ง๋ฌธ์์ ๋ต๋ณ์ ์ฐพ์์ ์์๊น?
๋ค์๊ณผ ๊ฐ์ด ์ง๋ฌธ ์ํฐํฐ์ ์ ์ํ answerList
๋ฅผ ์ฌ์ฉํ๋ฉด ์ญ์ ์ฝ๊ฒ ๊ตฌํ ์ ์๋ค.
ํ์ผ๋ช :
/sbb/src/test/java/com/mysite/sbb/
SbbApplicationTests.java
package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {
@Autowired
private QuestionRepository questionRepository;
@Test
void testJpa() {
Optional<Question> oq = this.questionRepository.findById(2);
assertTrue(oq.isPresent());
Question q = oq.get();
List<Answer> answerList = q.getAnswerList();
assertEquals(1, answerList.size());
assertEquals("๋ค ์๋์ผ๋ก ์์ฑ๋ฉ๋๋ค.", answerList.get(0).getContent());
}
}
์ง๋ฌธ ๊ฐ์ฒด๋ก๋ถํฐ ๋ต๋ณ ๋ฆฌ์คํธ๋ฅผ ๊ตฌํ๋ ํ ์คํธ์ฝ๋์ด๋ค. id๊ฐ 2์ธ ์ง๋ฌธ์ ๋ต๋ณ์ ํ ๊ฐ ๋ฑ๋กํ์ผ๋ฏ๋ก ์์ ๊ฐ์ด ๊ฒ์ฆํ ์ ์๋ค. ํ์ง๋ง ์ ์ฝ๋๋ฅผ ์คํํ๋ฉด ๋ค์๊ณผ ๊ฐ์ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค.
org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.mysite.sbb.Question.answerList, could not initialize proxy - no Session
(... ์๋ต ...)
์๋ํ๋ฉด Question
๋ฆฌํฌ์งํฐ๋ฆฌ๊ฐ findById๋ฅผ
ํธ์ถํ์ฌ Question
๊ฐ์ฒด๋ฅผ ์กฐํํ๊ณ ๋๋ฉด DB์ธ์
์ด ๋์ด์ง๊ธฐ ๋๋ฌธ์ด๋ค. ๊ทธ ์ดํ์ ์คํ๋๋ q.getAnswerList()
๋ฉ์๋๋ ์ธ์
์ด ์ข
๋ฃ๋์ด ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค. ๋ต๋ณ ๋ฐ์ดํฐ ๋ฆฌ์คํธ๋ q ๊ฐ์ฒด๋ฅผ ์กฐํํ ๋ ๊ฐ์ ธ์ค์ง ์๊ณ q.getAnswerList()
๋ฉ์๋๋ฅผ ํธ์ถํ๋ ์์ ์ ๊ฐ์ ธ์ค๊ธฐ ๋๋ฌธ์ด๋ค.
์ด๋ ๊ฒ ํ์ํ ์์ ์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค๋ ๋ฐฉ์์ Lazy ๋ฐฉ์์ด๋ผ๊ณ ํ๋ค. ์ด์ ๋ฐ๋๋ก q ๊ฐ์ฒด๋ฅผ ์กฐํํ ๋ ๋ต๋ณ ๋ฆฌ์คํธ๋ฅผ ๋ชจ๋ ๊ฐ์ ธ์ค๋ ๋ฐฉ์์ Eager ๋ฐฉ์์ด๋ผ๊ณ ํ๋ค.
@OneToMany
,@ManyToOne
์ ๋ํ ์ด์ ์ ์ต์ ์ผ๋กfetch=FetchType.LAZY
๋๋fetch=FetchType.EAGER
์ฒ๋ผ ๊ฐ์ ธ์ค๋ ๋ฐฉ์์ ์ค์ ํ ์ ์๋๋ฐ ์ด ์ฑ ์์๋ ๋ฐ๋ก ์ง์ ํ์ง ์๊ณ ํญ์ ๋ํดํธ ๊ฐ์ ์ฌ์ฉํ ๊ฒ์ด๋ค.
์ฌ์ค ์ด ๋ฌธ์ ๋ ํ
์คํธ ์ฝ๋์์๋ง ๋ฐ์ํ๋ค. ์ค์ ์๋ฒ์์ JPA ํ๋ก๊ทธ๋จ๋ค์ ์คํํ ๋๋ DB ์ธ์
์ด ์ข
๋ฃ๋์ง ์๊ธฐ ๋๋ฌธ์ ์์ ๊ฐ์ ์ค๋ฅ๊ฐ ๋ฐ์ํ์ง ์๋๋ค. ํ
์คํธ ์ฝ๋๋ฅผ ์ํํ ๋ ์์ ๊ฐ์ ์ค๋ฅ๋ฅผ ๋ฐฉ์งํ ์ ์๋ ๊ฐ์ฅ ๊ฐ๋จํ ๋ฐฉ๋ฒ์ ๋ค์์ฒ๋ผ @Transactional
์ ๋ํ
์ด์
์ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค. @Transactional
์ ๋ํ
์ด์
์ ์ฌ์ฉํ๋ฉด ๋ฉ์๋๊ฐ ์ข
๋ฃ๋ ๋๊น์ง DB ์ธ์
์ด ์ ์ง๋๋ค.
package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;
@SpringBootTest
class SbbApplicationTests {
@Autowired
private QuestionRepository questionRepository;
@Transactional
@Test
void testJpa() {
Optional<Question> oq = this.questionRepository.findById(2);
assertTrue(oq.isPresent());
Question q = oq.get();
List<Answer> answerList = q.getAnswerList();
assertEquals(1, answerList.size());
assertEquals("๋ค ์๋์ผ๋ก ์์ฑ๋ฉ๋๋ค.", answerList.get(0).getContent());
}
}
์์ ๊ฐ์ด testJpa
๋ฉ์๋์ @Transactional
์ ๋ํ
์ด์
์ ์ถ๊ฐํ๋ฉด ์ค๋ฅ์์ด ์ ์ํ๋ ๊ฒ์ด๋ค.