[Spring] 다대다 관계 업데이트

[DoohyunHwang97]

@PFCJeong @davin111

val songArtists : HashSet<SongArtistEntity> = HashSet()
                    for (artistName in songInfo.artists) {
                        val artistEntity = artistRepository.findByName(artistName)
                        if (artistEntity == null) {
                            if (artist.get().name == artistName) {
                                songArtists.add(SongArtistEntity(song = song.get(), artist = artist.get()))
                            } else {
                                val newEntity = ArtistEntity(name = artistName)
                                artistRepository.save(newEntity)
                                songArtists.add(SongArtistEntity(song = song.get(), artist = newEntity))
                            }
                        } else {
                            songArtists.add(SongArtistEntity(song = song.get(), artist = artistEntity))
                        }
                    }
                    // 기존의 연결관계는 끊고 업데이트를 하는 것인지
                    song.get().artists = songArtists.toMutableList()
                    // save()를 해줘야 변경이 적용이 되는지?
                    songRepository.save(song.get())

안녕하세요 질문이 다시 생겨서 다시 올립니다
두가지 질문이 있습니다.

1. save()를 하지 않았을 때 반영이 되지 않았는데 변경감지를 생각하면 save 없이도 반영이 되어야 하는 것이 아닌가요?
2. 다대다 관계에서 관계 또한 다른 필드를 업데이트하듯이 하면 되는 것인가요?
   2번은 Attention이라는 노래에서 Doja 랑 Weeknd 이렇게 조회되었는데 기존의 Attention - Weeknd 관계를 끊지 않은 것으로 보여집니다.
   
   감사합니다 (__)

[PFCJeong]

안녕하세요~

1. 변경감지는 트랜잭션 안에서만 적용됩니다. 트랜잭션 안에서 해당코드가 실행되는지 확인부탁드릴게요~
2. 제가 전체적인 컨텍스트를 몰라서, 위 코드만 보고서는 정확히 어떤 질문인지 이해하기가 어렵네요ㅠ. 다대다 관계에서 역시 다른 필드를 업데이트하듯 프로퍼티 값으 변경해주시면 됩니다.

song.artists += songAritsts

[DoohyunHwang97]

@PFCJeong 아 제가 설명을 잘 못했네요ㅠ
위 코드대로라면 기존의 리스트에 덧붙이는 느낌인데 기존에 있던 songArtistEntity들은 어떻게 되나요?
만약에 song 에 연결된 아티스트가 바뀌었다면 어떻게 해야하는지 궁금합니다.
예를 들어 song 의 artist를 weeknd 에서 doja 로 바꾸어서 업데이트하려할 때 어떤 방식으로 동작하는지 궁금합니다.

[DoohyunHwang97]

@PFCJeong

override fun insertAlbums(albumInfos: List<BatchAlbumInfo>) {
        albumInfos.forEach { albumInfo ->
            TransactionTemplate(txManager).executeWithoutResult {
                val artist = threads.submit<ArtistEntity> {
                    val artistEntity = artistRepository.findByName(albumInfo.artist)
                    if (artistEntity == null) {
                        val newEntity = ArtistEntity(name = albumInfo.artist)
                        artistRepository.save(newEntity)
                        newEntity
                    } else {
                        artistEntity
                    }
                }

                val album = threads.submit<AlbumEntity?> {
                    val albumEntity = albumRepository.findByTitle(albumInfo.title)
                    if (albumEntity == null) {
                        val newEntity = AlbumEntity(title = albumInfo.title, image = albumInfo.image, artist = artist.get())
                        albumRepository.save(newEntity)
                        newEntity
                    } else {
                        albumEntity.image = albumInfo.image
                        albumEntity.artist = artist.get()
                        albumEntity
                    }
                }

                for (songInfo in albumInfo.songs) {
                    val song = threads.submit<SongEntity> {
                        val songEntities = songRepository.findAllByTitle(songInfo.title)

                        if (songEntities == null) {
                            val newEntity = SongEntity(
                                    title = songInfo.title,
                                    duration = songInfo.duration,
                                    album = album.get())
                            newEntity
                        } else if ( songEntities.size != 1 ) {
                            songEntities.forEach {
                                if (it.album == album.get()) {
                                    it.duration = songInfo.duration
                                    it.album = album.get()
                                    return@submit it
                                }
                            }
                            val newEntity = SongEntity(
                                    title = songInfo.title,
                                    duration = songInfo.duration,
                                    album = album.get())
                            newEntity
                        } else {
                            val songEntity = songEntities.first();
                            songEntity.duration = songInfo.duration
                            songEntity.album = album.get()
                            songEntity
                        }
                    }

                    val songArtists : HashSet<SongArtistEntity> = HashSet()
                    for (artistName in songInfo.artists) {
                        val artistEntity = artistRepository.findByName(artistName)
                        if (artistEntity == null) {
                            if (artist.get().name == artistName) {
                                songArtists.add(SongArtistEntity(song = song.get(), artist = artist.get()))
                            } else {
                                val newEntity = ArtistEntity(name = artistName)
                                artistRepository.save(newEntity)
                                songArtists.add(SongArtistEntity(song = song.get(), artist = newEntity))
                            }
                        } else {
                            songArtists.add(SongArtistEntity(song = song.get(), artist = artistEntity))
                        }
                    }
                    song.get().artists.clear()
//                    val artists = song.get().artists
////                    artists.forEach {
////                        if (!songArtists.contains(it)) {
////                            artists.remove(it)
////                        }
////                    }
////
////                    songArtists.forEach {
////                        if (!artists.contains(it)) {
////                            artists.add(it)
////                        }
////                    }
                    song.get().artists = songArtists.toMutableList()
                    songRepository.save(song.get())
                }
            }
        }
    }

전체 코드는 이렇게 됩니다!
지금 트랜잭션이 정상적으로 처리되는지도 의문인게 song.get().artists 를 조회하려했을 때

org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role

처럼 에러가 났습니다. 트랜잭션 템플릿 안에 수행했는데 영속성 컨텍스트 문제가 생기는지 의문입니다 ㅜ

[PFCJeong]

오 전체적인 코드를 보여주셔서 이제 이해가 가네요. 감사합니다 (_ _)

제가 세미나에서 강조했듯이, 트랜잭션-영속성 컨텍스트-스레드는 한 몸입니다. 우리가 사용하는 JPA의 모든 기능은 스레드 단위로 동작합니다.
현재 겪고 계시는 문제는 코드에서 위 속성을 고려하지 않지 않았기 때문입니다.

1. 지금 코드를 보면 현재 스레드에서 트랜잭션을 열었는데요, artist는 다른 스레드에서 조회하고 있습니다. 뒤에 이어지는 album, song도 마찬가지입니다. 트랜잭션을 현재 스레드에서 열고, 막상 엔티티 조회는 다른 스레드(트랜잭션을 열지 않았음)에서 조회했기 때문에, 영속성 컨텍스트 기능을 사용하지 못하고 있는 것입니다.

 TransactionTemplate(txManager).executeWithoutResult {
                val artist = threads.submit<ArtistEntity> {
                    val artistEntity = artistRepository.findByName(albumInfo.artist)
                    if (artistEntity == null) {
                        val newEntity = ArtistEntity(name = albumInfo.artist)
                        artistRepository.save(newEntity)
                        newEntity
                    } else {
                        artistEntity
                    }
                }
}

2. song 의 artist를 weeknd 에서 doja 로 바꾸어서 업데이트하려할 때, 요거는 songArtists(리스트)에서 weeknd를 제거하고, doja를 추가해주면 됩니다. 그치만 지금 코드는 트랜잭션�이 제대로 적용되지 않고 있기때문에, (1)을 먼저 수정하고 다시 시도해보시면 좋을 것 같습니다.

[DoohyunHwang97]

@PFCJeong 아이고 제가 감사하죠(__)

그래서 안 되었던 거군요ㅠㅠ

구현 중에 질문이 하나 더 생겼는데 기존의 1. (앨범 A - "Attention") 2. (앨범 B - "Attention") 에서 (앨범 E - "Attention") 로 업데이트할 때 �1번과 2번 중에 어떤 곡을 선택해야 할까요?
"Attention"은 곡이름입니다.
이름이 같은 곡 처리하는 로직을 짜고 있는데 우선순위를 모르겠어서 질문드립니다!

[DoohyunHwang97]

@PFCJeong

override fun insertAlbums(albumInfos: List<BatchAlbumInfo>) {
        albumInfos.forEach { albumInfo ->
            val isNewArtist = threads.submit<Boolean> {
                artistRepository.findByName(albumInfo.artist) == null
            }
            val isNewAlbum = threads.submit<Boolean> {
                albumRepository.findByTitle(albumInfo.title) == null
            }
            val newSongSet = threads.submit<HashSet<String>> {
                val set = HashSet<String>()
                albumInfo.songs.forEach {
                    val songEntities = songRepository.findAllByTitle(it.title)
                    if (songEntities == null) {
                        set.add(it.title)
                    }
                }
                set
            }
            val newSongArtistNameSet = threads.submit<HashSet<String>> {
                val set = HashSet<String>()
                albumInfo.songs.forEach {
                    it.artists.forEach {
                        val artistEntity = artistRepository.findByName(it)
                        if (artistEntity == null) {
                            set.add(it)
                        }
                    }
                }
                set
            }

            TransactionTemplate(txManager).executeWithoutResult {
                val artistEntity : ArtistEntity
                val albumEntity : AlbumEntity

                if (isNewArtist.get()) {
                    artistEntity = ArtistEntity(name = albumInfo.artist)
                    artistRepository.save(artistEntity)
                } else {
                    artistEntity = artistRepository.findByName(albumInfo.artist)!!
                }

                if (isNewAlbum.get()) {
                    albumEntity = AlbumEntity(
                            title = albumInfo.title,
                            image = albumInfo.image,
                            artist = artistEntity
                    )
                    albumRepository.save(albumEntity)
                } else {
                    albumEntity = albumRepository.findByTitle(albumInfo.title)!!
                    albumEntity.title = albumInfo.title
                    albumEntity.image = albumInfo.image
                    albumEntity.artist = artistEntity
                }

                albumInfo.songs.forEach {songInfo ->
//                    println(songInfo.title)
//                    println(newSongSet.get().contains(songInfo.title))
                    // 신곡일 때 새로 저장
                    if (newSongSet.get().contains(songInfo.title)) {
                        println(songInfo.title)
                        val newSongEntity = SongEntity(
                                title = songInfo.title,
                                duration = songInfo.duration,
                                album = albumEntity
                        )
                        songRepository.save(newSongEntity)
                        // 곡 아티스트 관계 추가
                        songInfo.artists.forEach { songArtistName ->
                            // 신인 가수라면 가수 저장 후 관계 추가
                            if (newSongArtistNameSet.get().contains(songArtistName)) {
                                val newSongArtistEntity = ArtistEntity(name = songArtistName)
                                artistRepository.save(newSongArtistEntity)
                                newSongEntity.artists.add(SongArtistEntity(song = newSongEntity, artist = newSongArtistEntity))
                            }
                            // 기존 가수라면 관계만 추가
                            else {
                                newSongEntity.artists.add(SongArtistEntity(
                                        song = newSongEntity,
                                        artist = artistRepository.findByName(songArtistName)!!
                                ))
                            }
                        }
                    }
                    // 있는 곡일 때 찾아서 업데이트
                    else {
                        val songEntities = songRepository.findAllByTitle(songInfo.title)!!
                        songEntities.forEach {songEntity ->
                            if (songEntity.album.title == albumInfo.title) {
                                songEntity.title = songInfo.title
                                songEntity.duration = songInfo.duration
                                songEntity.album = albumEntity

                                // 곡 아티스트 관계 추가
                                songInfo.artists.forEach { songArtistName ->
                                    // 신인 가수라면 가수 저장 후 관계 추가
                                    if (newSongArtistNameSet.get().contains(songArtistName)) {
                                        val newSongArtistEntity = ArtistEntity(name = songArtistName)
                                        artistRepository.save(newSongArtistEntity)
                                        songEntity.artists.add(SongArtistEntity(song = songEntity, artist = newSongArtistEntity))
                                    }
                                    // 기존 가수라면 관계만 추가
                                    else {
                                        songEntity.artists.add(SongArtistEntity(
                                                song = songEntity,
                                                artist = artistRepository.findByName(songArtistName)!!
                                        ))
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

위처럼 코드 작성해봤는데 이번에도 트랜잭션 문제가 있는지 앨범만 인서트가 되어있고 song들은 반영이 안되어 있네요
디버깅 해봤을 때는 신곡인 경우에 albumRepository.findByTitle(albumInfo.title) 의 결과가 null이 나와야 되는데 null이 나오지 않는 것도 의문입니다ㅠ 감사합니다

[PFCJeong]

지금 코드도 같은 문제가 있습니다.

다른 스레드에서 조회한 entity를 가지고 현재 스레드의 트랜잭션에서 활용하고 있는 것으로 보입니다.

트랜잭션-조회-생성 모두가 같은 스레드에서 이뤄져야 합니다.

제가 예제로 드린 ThreadPerPersistentContextTest를 봐보시면 좋을 것 같습니다!

[DoohyunHwang97]

@PFCJeong
아 넵ㅜㅡㅜ
다른 쓰레드에서 그냥 boolean 값을 리턴한 것을 사용하는 것은 엔티티를 조회하는 것이 아니라고 생각했습니다. 불린값을 get()해서 사용하는 것도 다른 쓰레드의 엔티티를 조회한 것으로 되나요?