🍽 요리와 코딩💻

이번 포스팅에서는 EntityGraph의 사용에 대해 알아보려고 한다.

Entity구성은 다음과 같다

@Entity
class Team(
    var title: String,
) {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // DB에서 자동으로 ID increment
    @Column(name = "team_id")
    var id: Long = 0L
    
    // Onwer Entity를 Player로 지정, Lazy type fetch, Persistence 전이 타입
    @OneToMany(mappedBy="team", cascade=[CascaseType.ALL], fetch = FetchType.LAZY) 
    var players : MutableList<Player> = mutableListOf()
}

@Entity
class Player(
    var name : String,
    
    @ManyToOne
    @JoinColumn(name = "team_id") // 외래키 매핑을 위한 설정
    var game: Game
) {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // DB에서 자동으로 ID increment
    @Column(name = "player_id")
    var id: Long = 0L
    
    var count : Long
}

Game <--> Player 엔티티가 1:N으로 설정되어 있다.

현재 Team의 players는 LAZY type으로 가져오게 되어있는데,

하나의 team.players 조회시 다음과 같이 2개의 query가 생성된다.

select 
team0_.team_id as team_id1_3_0_, 
team0_.name as name2_3_0_ 
from 
team team0_ 
where 
team0_.team_id=?

select 
players0_.team_id as team_id4_1_0_, 
players0_.player_id as player_i1_1_0_, 
players0_.player_id as player_i1_1_1_, 
players0_.count as count2_1_1_, 
players0_.name as name3_1_1_, 
players0_.team_id as team_id4_1_1_ 
from 
player players0_ 
where 
players0_.team_id=?

다른 사람들의 글들을 보니, 여기에서 N + 1개의 Query문이 발생한다고 하던데,

Fetch type을 EAGER, LAZY로 변경하고 다른 옵션들을 만져보아도

Query문은 동일하게 2개만 발생하는 것을 확인할 수 있었다.

(아직 JPA ORM과 친숙하지 않아서 못다루는 것 일수도 있다..)

하지만 하나의 request에 대해 2개의 쿼리문이 생기는 것도 이상적이지는 않기에,

하나의 left outer join Query 를 만들어 보자.

Team Repository에 다음과 같이 @EntityGraph를 설정한다.

interface TeamRepository : CrudRepository<Team, Long> {
    @EntityGraph(attributePaths = ["players"])
    override fun findById(id: Long): Optional<Team>
}

변경 후에는 다음과 같이 Query가 나가게 된다.

select 
team0_.team_id as team_id1_3_0_, 
team0_.name as name2_3_0_, 
players1_.team_id as team_id4_1_1_, 
players1_.player_id as player_i1_1_1_, 
players1_.player_id as player_i1_1_2_, 
players1_.count as count2_1_2_, 
players1_.name as name3_1_2_, 
players1_.team_id as team_id4_1_2_ 
from 
team team0_ 
left outer join 
player players1_ 
on 
team0_.team_id=players1_.team_id 
where 
team0_.team_id=?

이로 인해 fetch type EAGER와도 비슷한 결과를 얻을 수 있다.

오늘은 여기까지..

틀린 내용에 대한 지적은 언제든지 환영입니다

최근에 서버 개발을 하는 와중에.. 큰 실수를 저질러 버렸다.

서버의 구성 요건이 아래와 같았다.

1. 서버가 여러 개의 인스턴스에서 동작하는 것을 가정

2. 동시다발적인 요청에도 문제가 없도록 설계

여기에서 1번은 어느정도 감안을 했지만 2번을 어떻게 처리해야 할 지 생각지도 못했다

아는 사람에게는 보이겠지만.. 내공이 부족하여 못보고 지나갔던 탓인것 같다..

이를 처리하기 위해서는 Database의 동시성을 해결해야 하는데

1. Read/Write에서 Lock을 걸어주거나

2. insert / update query를 할 때 database 를 바로 참조하도록 해야 하는 것이었다.

즉, Controller가 사용하는 Service function에서

@Transactional이 걸려있다고 해서 Database의 동시성을 만족할 수 없고,

별도의 설정을 해 주거나 Query를 날려야 하는 것이었다.

Entity구성은 다음과 같다

@Entity
class Team(
    var title: String,
) {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // DB에서 자동으로 ID increment
    @Column(name = "team_id")
    var id: Long = 0L
    
    // Onwer Entity를 Player로 지정, Lazy type fetch, Persistence 전이 타입
    @OneToMany(mappedBy="team", cascade=[CascaseType.ALL], fetch = FetchType.LAZY) 
    var players : MutableList<Player> = mutableListOf()
}

@Entity
class Player(
    var name : String,
    
    @ManyToOne
    @JoinColumn(name = "team_id") // 외래키 매핑을 위한 설정
    var game: Game
) {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // DB에서 자동으로 ID increment
    @Column(name = "player_id")
    var id: Long = 0L
    
    var count : Long
}

Game <--> Player 엔티티가 1:N으로 설정되어 있다.

Game이 MappedBy를 Player의 "team" field로 명시 해 줌으로써 Player가 Owner로 등록.

Player table에 대해서는 아래 Query문과 같이 Foreign Key를 생성하게 된다.

alter table player add constraint FKdvd6ljes11r44igawmpm1mc5s foreign key (team_id) references team

여기에서 Player 생성 시 Team의 total_player_number를 생각해보자.

당연히 플레이어가 생성될 때 마다 1씩 증가되어야 할 것이다.

하지만, 여러 Client가 동시에 Player를 생성하고, Database가 Lock이 되지 않을때를 가정해보자.

2개의 Client에서 각각 Player를 생성하려고 한다.

또한, 각각의 Client에서 Team 정보를 읽을 때 total_player_number가 0이었다.

이 때, 동시에 request가 발생하게 되면 2개의 Player가 생성되었지만

Team의 total_player_number는 1이 될 가능성이 존재한다.

첫번째 Player로 인해 total_player_number가 1로 증가하지만,

두번 째 Player 저장 당시 이미 읽어온 team의 해당 필드 값이 0이기 때문에

1 -> 2로 변하는 것이 아니라 1 -> 1로 덮어씌워 질 수 있기 때문이다.

동시성을 고려하지 않았을 때 Query 문

select 
team0_.team_id as team_id1_3_0_, 
team0_.name as name2_3_0_, 
team0_.total_player_number as total_pl3_3_0_, 
players1_.team_id as team_id4_1_1_, 
players1_.player_id as player_i1_1_1_, 
players1_.player_id as player_i1_1_2_, 
players1_.count as count2_1_2_, 
players1_.name as name3_1_2_, 
players1_.team_id as team_id4_1_2_ 
from 
team team0_ 
left outer join 
player players1_ 
on 
team0_.team_id=players1_.team_id 
where team0_.team_id=?

insert into player 
(player_id, count, name, team_id) 
values 
(null, ?, ?, ?)

update team 
set 
name=?, 
total_player_number=? 
where 
team_id=?

Team repository를 다음과 같이 변경해서 Pessimistic Lock을 걸어주었다.

interface TeamRepository : JpaRepository<Team, Long> {
    @Lock(LockModeType.PESSIMISTIC_WRITE)	// 비관적 Lock (Read / Write 모두)
    @EntityGraph(attributePaths = ["players"])
    override fun findById(id: Long): Optional<Team>
}

동시성을 고려했을 때 Query 문

select 
team0_.team_id as team_id1_3_0_, 
team0_.name as name2_3_0_, 
team0_.total_player_number as total_pl3_3_0_, 
players1_.team_id as team_id4_1_1_, 
players1_.player_id as player_i1_1_1_, 
players1_.player_id as player_i1_1_2_, 
players1_.count as count2_1_2_, 
players1_.name as name3_1_2_, 
players1_.team_id as team_id4_1_2_ 
from 
team team0_ 
left outer join 
player players1_ 
on 
team0_.team_id=players1_.team_id 
where 
team0_.team_id=? 
for update		/* Database lock을 위해 for update 라는 구문이 추가 됨 */

insert into player 
(player_id, count, name, team_id) 
values 
(null, ?, ?, ?)

update team 
set 
name=?, 
total_player_number=? 
where 
team_id=?

다른건 동일하지만, select 문에서 뒤에 ~ for update 가 붙어있다.

이는 동시성 제어를 위해 특정 row에 READ / WRITE Lock이 걸려있다는 말이다 (배타적 Lock).

만약, Read는 자유롭게 하되, Write에서만 Lock을 걸고싶다면 PESSIMISTIC_READ 를 사용하면 된다.

다음 포스팅에서 직접 테스트를 해보도록 하겠다.