[프로젝트] N:N 관계 → 1:N & N:1 로 구현하기

✅ Git

https://github.com/ellaCoo/sns/issues/17

https://github.com/ellaCoo/sns/pull/40

 

📌 상황

[ 포스트 : 해시태그 ]가 [ N : N ] 관계로 설계된 상태에서,
관계형 데이터베이스는 정규화된 테이블 2개로 다대다 관계를 표현할 수 없다는 한계에 부딪쳤다.
(@ManyToMany 어노테이션 사용하는 방법은 연결 테이블을 개발자가 직접 관리하는 방식이 아니기에..)

⇒ 연결 테이블과 연결 테이블용 엔티티를 추가하여 일대다, 다대일 관계로 풀어내보자

왜 ManyToMany 를 지양해야 하는가?

ManyToMany를 사용하면 직접 테이블관리나 인덱스 설정을 할 수 없고,
post_hashtag가 자동적으로 만들어져서 개입하고, 직접 수정하기 어려워짐.

테이블이 자동으로 만들어짐 = 테이블이 설계에서 숨는다 
→ 관리에서 누락될 수 있음

도메인 설정 코드

// Post
@Getter
@Entity
public class Post extends AuditingFields {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Setter
    @JoinColumn(name = "userId")
    @ManyToOne(optional = false, fetch = FetchType.LAZY)
    private UserAccount userAccount;

    @Setter
    @Column(nullable = false)
    private String title;

    @Setter
    @Column(nullable = false, length = 10000)
    private String content;

    @OrderBy("createdAt DESC")
    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, fetch = FetchType.LAZY) // 연관된 엔티티도 모두 영속성 전이
    private Set<PostComment> postComments = new LinkedHashSet<>();

    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private Set<Like> likes = new LinkedHashSet<>();

    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private Set<PostHashtag> postHashtags = new LinkedHashSet<>();

// PostHashtag (중간 연결 테이블)  
@Getter
@Entity
public class PostHashtag {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Setter
    @JoinColumn(name = "postId")
    @ManyToOne(optional = false, fetch = FetchType.LAZY)
    private Post post;

    @Setter
    @JoinColumn(name = "hashtagId")
    @ManyToOne(optional = false, fetch = FetchType.LAZY)
    private Hashtag hashtag;

// Hashtag
@Getter
@Entity
public class Hashtag extends AuditingFields {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Setter
    @Column(nullable = false)
    private String hashtagName;

    @OneToMany(mappedBy = "hashtag", cascade = CascadeType.PERSIST, fetch = FetchType.LAZY)
    private Set<PostHashtag> postHashtags = new LinkedHashSet<>();

 

영속성 전이(cascade) 옵션 = CascadeType

• •  

CascadeType.ALL

- Post 의 Set<PostHashtag> postHashtags
엔티티에 수행된 모든 작업(저장, 삭제, 갱신, 병합 등)이 관련된 연관 엔티티에도 동일하게 적용
     Post 저장하면 관련된 모든 postHashtags 도 함께 저장되고, Post 삭제하면 모든 자식 postHashtags 도 삭제됨

- 아래 전이 옵션들 모두 포함
PERSIST
REMOVE
MERGE
REFRESH
DETACH

CascadeType.PERSIST

- Hashtag 의 Set<PostHashtag> postHashtags
- 저장(persist) 작업에만 전이됨
     Hashtag 저장하면 관련된 모든 postHashtags 도 함께 저장되지만, 삭제 작업은 전이되지 않음

 

📌 Post가 업데이트 되었을 때, 해당 포스트의 해시태그가 함께 업데이트 되어야 하는 상황

소스코드

👾 PostService

public void updatePost(Long postId, PostWithHashtagsDto dto) {
        try {
            Post post = postRepository.getReferenceById(postId);
            UserAccount userAccount = userAccountRepository.getReferenceById(dto.userAccountDto().userId());

            // 로그인된 사용자와 게시글 작성자가 동일한 경우(/postId/edit : get이므로 다른 사용자도 접근 가능)
            if (!post.getUserAccount().equals(userAccount)) {
                return;
            }
            if (dto.postDto().title() != null) post.setTitle(dto.postDto().title());
            if (dto.postDto().content() != null) post.setContent(dto.postDto().content());

            /**
             Hashtag LOGIC
             */
            Set<Long> originHashtagIds = post.getPostHashtags().stream().map(PostHashtag::getHashtag).map(Hashtag::getId).collect(Collectors.toSet()); // 1
            Set<String> newHashtags = dto.hashtagDtos().stream().map(HashtagDto::hashtagName).collect(Collectors.toUnmodifiableSet()); // 2

            postHashtagRepository.deleteByPostId(postId); // 3

            Set<Hashtag> hashtags = hashtagService.getExistedOrCreatedHashtagsByHashtagNames(newHashtags); // 4
            post.addHashtags(hashtags); // Post와 Hashtag 관계 설정 5
            postRepository.flush(); // 6

            hashtagService.deleteUnusedHashtags(originHashtagIds); // 7
        } catch (EntityNotFoundException e) {
            log.warn("포스트 업데이트 실패. 포스트를 수정하는데 필요한 정보를 찾을 수 없습니다.");
        }
    }

👾 PostWithHashtagsDto

public record PostWithHashtagsDto(
        PostDto postDto,
        UserAccountDto userAccountDto,
        Set<HashtagDto> hashtagDtos
) {
    public static PostWithHashtagsDto of(PostDto postDto, UserAccountDto userAccountDto, Set<HashtagDto> hashtagDtos) {
        return new PostWithHashtagsDto(postDto, userAccountDto, hashtagDtos);
    }

 

/** Hashtag LOGIC */

1 : DB SELECT → 게시글의 기존 해시태그 Id를 가져와서 Set 형태로 가공 (나중에 사용하지 않는 해시태그 검증용)

Set<Long> originHashtagIds = post.getPostHashtags().stream().map(PostHashtag::getHashtag).map(Hashtag::getId).collect(Collectors.toSet());

Hibernate: 
    select
        ph1_0.post_id,
        ph1_0.id,
        ph1_0.hashtag_id 
    from
        post_hashtag ph1_0 
    where
        ph1_0.post_id=?
2024-09-09T18:55:22.736+09:00 TRACE 22129 --- [io-8080-exec-10] org.hibernate.orm.jdbc.bind              : binding parameter (1:BIGINT) <- [49]

 

2 : 새로 업데이트 될 해시태그들을 Set 으로 가공

Set<String> newHashtags = dto.hashtagDtos().stream().map(HashtagDto::hashtagName).collect(Collectors.toUnmodifiableSet());

 

3 : DB DELETE → 연결테이블(PostHashtag)에서 포스트에 해당하는 연결 삭제

postHashtagRepository.deleteByPostId(postId);

Hibernate: 
    delete 
    from
        post_hashtag ph1_0 
    where
        ph1_0.post_id=?
2024-09-09T18:58:41.343+09:00 TRACE 24830 --- [nio-8080-exec-2] org.hibernate.orm.jdbc.bind              : binding parameter (1:BIGINT) <- [49]

 

4 : DB SELECT & INSERT → 새로 업데이트 될 해시태그가 Hashtag 테이블에 기존에 있으면 그 엔티티 가져오고, 없으면 INSERT

Set<Hashtag> hashtags = hashtagService.getExistedOrCreatedHashtagsByHashtagNames(newHashtags);

 

👾 HashtagService

    public Set<Hashtag> getExistedOrCreatedHashtagsByHashtagNames(Set<String> hashtagNames) {
        Set<Hashtag> hashtags = new HashSet<>();
        for (String hashtagName : hashtagNames) {
            Hashtag hashtag = hashtagRepository.findByHashtagName(hashtagName)
                    .orElseGet(() -> hashtagRepository.save(Hashtag.of(hashtagName)));
            hashtags.add(hashtag);
        }
        return hashtags;
    }

Hibernate: 
    select
        h1_0.id,
        h1_0.created_at,
        h1_0.created_by,
        h1_0.hashtag_name,
        h1_0.modified_at,
        h1_0.modified_by 
    from
        hashtag h1_0 
    where
        h1_0.hashtag_name=?
2024-09-09T18:59:18.471+09:00 TRACE 24830 --- [nio-8080-exec-2] org.hibernate.orm.jdbc.bind              : binding parameter (1:VARCHAR) <- [test]
Hibernate: 
    insert 
    into
        hashtag
        (created_at, created_by, hashtag_name, modified_at, modified_by) 
    values
        (?, ?, ?, ?, ?) 
    returning id

 

5 : Post 엔티티의 private Set<PostHashtag> postHashtags 에 추가

post.addHashtags(hashtags); // Post와 Hashtag 관계 설정

 

6 : flush 를 통해 쓰기 지연 SQL 저장소의 쿼리를 DB에 전송 (변경 감지 / 수정된 엔티티 쓰기 지연 SQL 저장소에 등록)

postRepository.flush();

Hibernate: 
    insert 
    into
        post_hashtag
        (hashtag_id, post_id) 
    values
        (?, ?) 
    returning id
2024-09-09T19:01:09.389+09:00 TRACE 24830 --- [nio-8080-exec-2] org.hibernate.orm.jdbc.bind              : binding parameter (1:BIGINT) <- [17]
2024-09-09T19:01:09.390+09:00 TRACE 24830 --- [nio-8080-exec-2] org.hibernate.orm.jdbc.bind              : binding parameter (2:BIGINT) <- [49]

 

7 : 수정 전의 해시태그들이 사용되지 않는다면 삭제

hashtagService.deleteUnusedHashtags(originHashtagIds);

 

👾 HashtagService

public void deleteUnusedHashtags(Set<Long> hashtagIds) {
        // JPQL 쿼리 실행 전, 자동 flush
        List<Hashtag> unusedHashtags = hashtagRepository.findUnusedHashtagsByIds(hashtagIds);
        for (Hashtag unusedHashtag : unusedHashtags) {
            hashtagRepository.delete(unusedHashtag);
        }
    }

👾 HashtagRepository

// 해시태그 중에서 PostHashtag에 속하지 않는 해시태그들 찾기
    @Query("SELECT h FROM Hashtag h WHERE h.postHashtags IS EMPTY AND h.id IN :hashtagIds")
    List<Hashtag> findUnusedHashtagsByIds(@Param("hashtagIds") Set<Long> hashtagIds);

 

7-1 : JPQL 쿼리 사용하여 사용되지 않는 해시태그 찾기

List<Hashtag> unusedHashtags = hashtagRepository.findUnusedHashtagsByIds(hashtagIds);

Hibernate: 
    select
        h1_0.id,
        h1_0.created_at,
        h1_0.created_by,
        h1_0.hashtag_name,
        h1_0.modified_at,
        h1_0.modified_by 
    from
        hashtag h1_0 
    where
        not exists(select
            1 
        from
            post_hashtag ph1_0 
        where
            h1_0.id=ph1_0.hashtag_id) 
        and h1_0.id in (?, ?, ?, ?)
2024-09-09T19:02:17.749+09:00 TRACE 24830 --- [nio-8080-exec-2] org.hibernate.orm.jdbc.bind              : binding parameter (1:BIGINT) <- [1]
2024-09-09T19:02:17.750+09:00 TRACE 24830 --- [nio-8080-exec-2] org.hibernate.orm.jdbc.bind              : binding parameter (2:BIGINT) <- [7]
2024-09-09T19:02:17.750+09:00 TRACE 24830 --- [nio-8080-exec-2] org.hibernate.orm.jdbc.bind              : binding parameter (3:BIGINT) <- [12]
2024-09-09T19:02:17.751+09:00 TRACE 24830 --- [nio-8080-exec-2] org.hibernate.orm.jdbc.bind              : binding parameter (4:BIGINT) <- [13]