package com.mengyunzhi.springbootsamplecode.softdelete.entity;

import javax.persistence.MappedSuperclass;

@MappedSuperclass
public abstract class BaseEntity {
  private Boolean deleted = false;
  // setter and getter
}

package com.mengyunzhi.springbootsamplecode.softdelete.entity;

import org.hibernate.annotations.SQLDelete;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

/**
 * 班級(jí)
 */
@Entity
@SQLDelete(sql = "update `klass` set deleted = 1 where id = ?")
public class Klass extends BaseEntity {
  @Id
  @GeneratedValue
  private Long id;
  private String name;
  // setter and getter
}

@Entity
@SQLDelete(sql = "update `klass_test` set deleted = 1 where id = ?")
@Where(clause = "deleted = false")
public class KlassTest extends BaseEntity {
  @Id @GeneratedValue
  private Long id;
  private String name;
}

package com.mengyunzhi.springbootsamplecode.softdelete.core;


import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.NoRepositoryBean;

import javax.transaction.Transactional;
import java.util.Optional;

/**
 * 應(yīng)用軟刪除
 * 默認(rèn)的@Where(clause = "deleted = 0")會(huì)導(dǎo)致hibernate內(nèi)部進(jìn)行關(guān)聯(lián)查詢時(shí)，發(fā)生ObjectNotFound的異常
 * 在此重新定義接口
 * 參考：https://stackoverflow.com/questions/19323557/handling-soft-deletes-with-spring-jpa/22202469
 * @author 河北工業(yè)大學(xué) 夢(mèng)云智軟件開發(fā)團(tuán)隊(duì)
 */
@NoRepositoryBean
public interface SoftDeleteCrudRepository<T, ID> extends CrudRepository<T, ID> {
  @Override
  @Transactional
  @Query("select e from #{#entityName} e where e.id = ?1 and e.deleted = false")
  Optional<T> findById(ID id);

  @Override
  @Transactional
  default boolean existsById(ID id) {
    return findById(id).isPresent();
  }

  @Override
  @Transactional
  @Query("select e from #{#entityName} e where e.deleted = false")
  Iterable<T> findAll();

  @Override
  @Transactional
  @Query("select e from #{#entityName} e where e.id in ?1 and e.deleted = false")
  Iterable<T> findAllById(Iterable<ID> ids);

  @Override
  @Transactional
  @Query("select count(e) from #{#entityName} e where e.deleted = false")
  long count();
}

/**
 * 班級(jí)
 * @author panjie
 */
public interface KlassRepository extends SoftDeleteCrudRepository<Klass, Long>{
}

public interface KlassTestRepository extends SoftDeleteCrudRepository<KlassTest, Long> {
}

public interface TeacherRepository extends CrudRepository<Teacher, Long> {
}

package com.mengyunzhi.springbootsamplecode.softdelete.repository;

import com.mengyunzhi.springbootsamplecode.softdelete.entity.Klass;
import com.mengyunzhi.springbootsamplecode.softdelete.entity.KlassTest;
import com.mengyunzhi.springbootsamplecode.softdelete.entity.Teacher;
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.orm.jpa.JpaObjectRetrievalFailureException;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;
import java.util.Optional;


/**
 * @author panjie
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class TeacherRepositoryTest {
  private final static Logger logger = LoggerFactory.getLogger(TeacherRepositoryTest.class);
  @Autowired KlassRepository klassRepository;
  @Autowired KlassTestRepository klassTestRepository;
  @Autowired TeacherRepository teacherRepository;

  @Test
  public void findById() {
    logger.info("新建一個(gè)有Klass和KlassTest的教師");
    Klass klass = new Klass();
    klassRepository.save(klass);
    KlassTest klassTest = new KlassTest();
    klassTestRepository.save(klassTest);
    Teacher teacher = new Teacher();
    teacher.setKlass(klass);
    teacher.setKlassTest(klassTest);
    teacherRepository.save(teacher);

    logger.info("查找教師，斷言查找了實(shí)體，并且不發(fā)生異常");
    Optional<Teacher> teacherOptional = teacherRepository.findById(teacher.getId());
    Assertions.assertThat(teacherOptional.get()).isNotNull();


    logger.info("刪除關(guān)聯(lián)的Klass, 再查找教師實(shí)體，斷言查找到了實(shí)體，不發(fā)生異常。斷言教師實(shí)體中，仍然存在已經(jīng)刪除的Klass實(shí)體");
    klassRepository.deleteById(klass.getId());
    teacherOptional = teacherRepository.findById(teacher.getId());
    Assertions.assertThat(teacherOptional.get()).isNotNull();
    Assertions.assertThat(teacherOptional.get().getKlass().getId()).isEqualTo(klass.getId());

    logger.info("查找教師列表，不發(fā)生異常。斷言教師實(shí)體中，存在已刪除的Klass實(shí)體記錄");
    List<Teacher> teacherList = (List<Teacher>) teacherRepository.findAll();
    for (Teacher teacher1 : teacherList) {
      Assertions.assertThat(teacher1.getKlass().getId()).isEqualTo(klass.getId());
    }

    logger.info("刪除關(guān)聯(lián)的KlassTest，再查找教師實(shí)體, 斷言找到了刪除的klassTest");
    klassTestRepository.deleteById(klassTest.getId());
    teacherOptional = teacherRepository.findById(teacher.getId());
    Assertions.assertThat(teacherOptional.get()).isNotNull();
    Assertions.assertThat(teacherOptional.get().getKlassTest().getId()).isEqualTo(klassTest.getId());

    logger.info("再查找教師列表，斷言將發(fā)生JpaObjectRetrievalFailureException(EntityNotFound 異常被捕獲后，封裝拋出)異常");
    Boolean catchException = false;
    try {
      teacherRepository.findAll();
    } catch (JpaObjectRetrievalFailureException e) {
      catchException = true;
    }
    Assertions.assertThat(catchException).isTrue();
  }

}