soft delete 구현 및 문제점

[berryberrybin]

soft delete 구현

• soft delete 구현 방법
  • boolean 타입의 필드로 삭제 유무를 구분하고, 메소드를 통해 객체의 상태를 변경하여 삭제함
  • @SQLDelete(sql = "UPDATE comments SET deleted = true WHERE id = ?") 이용
  • delete쿼리 대신 update 쿼리를 통해 deleted 필드 값만 true로 변경시켜줌
  • @SQLDelete는 엔티티 삭제가 발생했을때 delete 쿼리 대신 실행시켜줄 커스텀 sql 구문을 뜻하는 어노테이션
• @Where(clause = "deleted = false")
  • 엔티티 조회 쿼리의 where절에 반드시 포함되는 조건을 설정할 수 있음
  • Lazy Loading으로 발생하는 조회 쿼리의 where절에 조건을 포함시키기 위해서는 반드시 사용해야함
  • 하지만 JPQL 또는 HQL이 아닌 native SQL을 사용할 때는 적용되지 않기 때문에 주의해야함
  • @Where(clause = "deleted = false") = deleted가 false인것만 조회 = 삭제된것은 제외하고 조회

@Entity
@Where(clause = "deleted = false")
@SQLDelete(sql = "UPDATE posts SET deleted = true WHERE id = ?")
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Posts {

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

    @Column(nullable = false)
    private String title;

    @Column(nullable = false)
    private String content;

    @Column(nullable = false)
    private boolean deleted;

    @OneToMany(fetch = FetchType.LAZY, mappedBy = "post", cascade = CascadeType.REMOVE)
    private List<Comments> comments = new ArrayList<>();

    public Posts(String title, String content) {
        this.title = title;
        this.content = content;
    }

    public void delete() {
        this.deleted = true;
    }

    public void addComment(Comments comment) {
        this.comments.add(comment);
    }

}

@Entity
@Where(clause = "deleted = false")
@SQLDelete(sql = "UPDATE comments SET deleted = true WHERE id = ?")
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Comments {

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

    @Column(nullable = false)
    private String content;

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    private Posts post;

    @Column(nullable = false)
    private boolean deleted;

    public Comments(String content, Posts post) {
        this.content = content;
        this.post = post;
        this.post.addComment(this);
    }

    public void delete() {
        this.deleted = true;
    }

}

[berryberrybin]

soft delete 문제점

• SQLDelete는 영속성 컨텍스트에서 관리되다가 트랜잭션이 끝나고 -> 실제 DB에 쿼리를 보낼때 처리를 해줌
• 즉, test코드 작성시 아래와 같이 작성하게 되면 'deletedComment'는 찾을 수 없다고 함

@Test
   void 댓글_삭제_성공() {
    //given
    Board board = new Board("testBoard");
    User user = userRepository.save(new User("testUserNickname", "email", User.Role.USER));
    Post post = postRepository.save(new Post(board, user, "testPostTitle", "testPostContent"));
    Comment commentA = commentRepository.save(new Comment(user, post, "testCommentContentA", null));
    Comment commentB = commentRepository.save(new Comment(user, post, "testCommentContentB", null));

    CommentCommand.DeleteCommentCommand command = CommentCommand.DeleteCommentCommand.builder()
            .userId(user.getId())
            .postId(post.getId())
            .commentId(commentA.getId()).build();

    //when
    commentCommandService.deleteComment(command);
    Optional<Comment> deletedComment = commentRepository.findById(commentA.getId());
    Optional<Comment> notDeletedComment = commentRepository.findById(commentB.getId());

    //then
    assertThat(deletedComment.isPresent()).isEqualTo(false);
    assertThat(notDeletedComment.isPresent()).isEqualTo(true);
}

@Test
    @DisplayName("Shop soft delete")
    public void delete() {
        Shop shop = new Shop("가게이름", "대구광역시");
        Shop savedShop = shopRepository.save(shop);

        assertThat(savedShop.getId()).isNotNull();
        assertThat(savedShop.isDeleted()).isFalse();

        shopRepository.delete(savedShop);
        entityManager.flush();

        Optional<Shop> afterDelete = shopRepository.findById(savedShop.getId());
        assertThat(afterDelete).isNotEmpty();
        assertThat(afterDelete.get().isDeleted()).isTrue();
  }

[berryberrybin]

상속 관계에서 soft delete처리

• 부모클래스에만 @SQLDelete(sql = "UPDATE shop SET deleted = true WHERE id = ?") 처리를 해주면, 자식 테이블에서는 실제 삭제가 일어남
• 해결방안 : 각 자식 클래스에 @OnDelete(action = OnDeleteAction.CASCADE)처리를 해줘서 막아줄 수 있음

@Entity
@Inheritance(strategy = InheritanceType.JOINED)
@DiscriminatorColumn
@SQLDelete(sql = "UPDATE shop SET deleted = true WHERE id = ?")
public abstract class Shop {

}

@Entity
@DiscriminatorValue("C")
@OnDelete(action = OnDeleteAction.CASCADE)
public class Restaurant extends Shop {

}

[berryberrybin]

• https://velog.io/@max9106/JPA-soft-delete
• https://velog.io/@nmrhtn7898/JPA-JPA-Hibernate-%EA%B8%B0%EB%B0%98%EC%9D%98-%EA%B0%9C%EB%B0%9C-%ED%99%98%EA%B2%BD%EC%97%90%EC%84%9C-Soft-Delete-%EA%B5%AC%ED%98%84%ED%95%98%EA%B8%B0

[berryberrybin]

EntityManager를 통한 soft delete 관련 test 해결

• EntityManager (Persistence Context)

  • 엔티티 정보를 저장하고 있는 환경
  • 요청 결과가 DB에 반영되기 이전에 위치하는 논리적인 영역 (가상의 데이터베이스 영역이라 봐도 무방함)
  • 사용자 요청을 받아 Connection을 통해 DB와 로컬 트랜잭션을 맺으며, 데이터를 관리하고 영속적으로 반영하는 or 삭제하는 책임을 가지는 객체

• persist, flush, clear

  • persist() : 영속성 컨텍스트에 쿼리를 저장
  • flush() : DB에 실제 쿼리를 날림. DB에 반영 안됨
  • clear() : 영속성 컨텍스트에 데이터를 제거함.

@SpringBootTest
@Transactional
class CommentCommandServiceIntegrationTest {

    @Autowired
    private CommentCommandService commentCommandService;

    @Autowired
    private CommentRepository commentRepository;

    @Autowired
    private PostRepository postRepository;

    @Autowired
    private UserRepository userRepository;

    @PersistenceContext
    EntityManager entityManager;

    @Test
    void 댓글_삭제_성공() {
        //given
        Board board = new Board("testBoard");
        User user = userRepository.save(new User("testUserNickname", "email", User.Role.USER));
        Post post = postRepository.save(new Post(board, user, "testPostTitle", "testPostContent"));
        Comment commentA = commentRepository.save(new Comment(user, post, "testCommentContentA", null));
        Comment commentB = commentRepository.save(new Comment(user, post, "testCommentContentB", null));

        entityManager.persist(board); // 영속성 컨텍스트에 저장
        entityManager.persist(user);
        entityManager.persist(post);
        entityManager.persist(commentA);
        entityManager.persist(commentB);

        CommentCommand.DeleteCommentCommand command = CommentCommand.DeleteCommentCommand.builder()
            .userId(user.getId())
            .postId(post.getId())
            .commentId(commentA.getId()).build();

        //when
        commentCommandService.deleteComment(command);

        entityManager.flush(); // 영속성 컨텍스트에 있는 데이터를 DB로 쿼리 전송
        entityManager.clear(); // 영속성 컨텍스트에 있는 데이터를 제거 
        Optional<Comment> deletedComment = commentRepository.findById(commentA.getId());
        Optional<Comment> notDeletedComment = commentRepository.findById(commentB.getId());

        //then
        assertThat(deletedComment.get().getIsDeleted()).isEqualTo(true);
        assertThat(notDeletedComment.isPresent()).isEqualTo(true);
    }
}

persist, flush, clear 정의 및 이해

• @PerisstenceContext는 @Autowired랑 비슷
• insert, update, delete와 같은 쿼리를 날릴때, 트랜잭션이 시작되고, 끝나기 직전까지 내가 날린 데이터는 영속성 컨텍스트에 저장됨
• Persist
  • 쿼리를 날려 영속성 컨텍스트에 저장하는 명령어가 entityManager.persist(comment)
  • comment라는 객체가 persist를 통해 영속성 컨텍스트에 보관 중
  • 트랜잭션을 끝내고 싶다면, commit을 통해 실제 DB에 저장,수정,삭제를 하던가, rollback을 통해 DB에 저장하지 않고, 영속성 컨텍스트 데이터를 날리면 됨
• Flush
  • 영속성 컨텍스트의 변경 내용들을 DB까지 접근 시킴 (commit 되는 것은 아님 / 영속성 컨텍스트에 저장된 정보를 비우는 것은 아님)
  • 즉, 쿼리를 날리지만 commit하는 저장 작업은 없어서 DB에 반영되지 않고, DB에 날릴 준비만 완료한 상태
  • jpa로 구성한 데이터가 DB에 저장되지는 않지만 어떤식으로 실제 쿼리를 날리는지 확인 할 수 있음
  • Flush 발생시 Flow
    • 엔티티에 대한 변경을 감지하고
    • 추가, 수정, 삭제된 엔티티 정보에 대한 Query를 내부 SQL 저장소에 등록한 뒤
    • 해당 정보를 DB에 전송함
  • Flush를 발생시키는 방법
    • entityManager.flush()를 통한 직접 호출
    • 트랜잭션 commit()을 통한 자동 호출
    • JPQL로 만들어진 Query 실행시, 자동 호출 영속성 컨텍스트에만 관리되고 있는 영속 상태의 엔티티들은 사실상 DB에 존재하지 않으므로 JPQL을 통한 Query요청시 결과에서 이것들을 확인할 수 없게 됨. 이를 방지하기 위해 미리 Flush()를 호출하여 DB에 반영한 뒤 정삭적인 결과를 제공하게 됨
• clear
  • 영속성 컨텍스트에 저장한 데이터를 지워버림
  • persist로 영속성 컨텍스트에 데이터가 저장되었을때, clear를 하면 데이터가 지워짐
  • 실제 DB에 저장된 데이터를 지우는 것이 아님