更改数据库设计以改进 Spring Data JPA 软删除和查询身份验证

Question

我希望这个问题不是基于意见的，但我们开始吧。 我正在开发一个使用 spring boot、spring data jpa 和 JWT Token 作为身份验证系统的小型 API。 API 非常简单，是一个考试生成器，您可以在其中注册教授、课程、问题、选择等。

例如： [13/11/2017 - 编辑以包含 AbstractEntity]

@MappedSuperclass
public class AbstractEntity implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    protected Long id;
    protected boolean enabled = true;
    //equals, hashcode...
}

public class Professor extends AbstractEntity{ 
    private String email;
}

public class Course extends AbstractEntity {
    @ManyToOne(optional = false)
    private Professor professor;  
}

public class Question extends AbstractEntity {
    @ManyToOne(optional = false)
    private Course course;
}

因为身份验证系统是所有查询的 JWT 令牌，所以我必须包含教授的信息。

例如

public interface CourseRepository extends PagingAndSortingRepository<Course, Long> {
    @Query("select c from Course c where c.id = ?1 and c.professor = ?#{principal.professor} and c.enabled = true")
    Course findOne(Long id);
}

问题在于，由于教授的信息以及启用的字段，对于每个 crud 查询，我都必须编写自己的自定义查询。

我知道有一种方法可以扩展 PagingAndSortingRepository 并编写您自己的自定义查询，如下所示：

public interface CustomPagingAndSortRepository<T, ID extends Serializable> extends PagingAndSortingRepository<T, ID> {
    @Override
    @Query("select e from #{#entityName} e where e.id = ?1 and e.professor = ?#{principal.professor} and e.enabled = true")
    T findOne(ID id);
    //More fields overrided here
}

如果我只启用担心，这个 CustomPagingAndSortRepository 将完美地适用于所有类。这门课非常适合 Course，因为 e.professor = ?#{principal.professor} 会在那里找到教授。但它不适用于问题，例如，因为我需要加入课程班级才能获得教授，例如e.course.professor = ?#{principal.professor}

关键是如果我在所有课程中都与教授建立关联，我可以使通用代码工作，节省大量代码但牺牲数据库设计的规范化。 问题是：还有其他方法吗？或者这样做是否有效？

PS：问题，课程等永远不会改变所有者，这意味着只有创建的教授才能使用它。

Answer 1

你为什么不创建一个注解@Service 的类，它会自动连接你的CourseRepository，然后将id, principal.professor, enabled 传递给它，那么你的存储库将拥有Course findByIdAndProfessorAndEnabled(Long id, String professor, Boolean enabled) 方法。 代码片段：

public interface CourseRepository extends PagingAndSortingRepository<Course, Long> {
    Course findByIdAndProfessorAndEnabled(Long id, Professor professor, Boolean enabled);
}

@Service
public class CourseService{
    @Autowired
    CourseRepository courseRepository;

    //pass in principal.professor from your controller or from wherever this is called
    public Course findByIdAndProfessorAndEnabled(Long id, Professor  professor, Boolean enabled){
        return courseRepository.findByIdAndProfessor(id, professor, enabled);
    }
}

编辑：对于 Hibernate 模型

如果您总是希望在查询中将 enabled 设置为 true，您可以在模型上使用 @Where 注释

@MappedSuperclass
@Where(clause="is_enabled=true")
public class AbstractEntity implements Serializable {
.
.
.
@Column(name="is_enabled")
protected boolean enabled = true;
...

我不知道这种方法是否也适用于您的委托人，但您可以尝试一下

Answer 2

好的，我会回答我自己的问题。所以，问题是：

关键是如果我在所有课程中都与教授建立关联，我可以使通用代码工作，节省大量代码但牺牲数据库设计的规范化。问题是：还有其他方法吗？或者这样做是否有效？

我确实做到了，基于this answer，它减少了很多代码。

现在我有这样的模型类（在所有其他类中也包括Professor）：

@MappedSuperclass
public class AbstractEntity implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    protected Long id;
    @Column(columnDefinition = "boolean default true", nullable = false)
    private boolean enabled = true;
// ...
}

@Entity
public class Course extends AbstractEntity {
    private String name;
    @ManyToOne(optional = false)
    private Professor professor;
    //...
}

@Entity
public class Question extends AbstractEntity {
    private String title;
    @ManyToOne(optional = false)
    private Course course;
    @ManyToOne(optional = false)
    private Professor professor;
    // ...
}

还有这样的 CustomPagingAndSortRepository

@NoRepositoryBean
public interface CustomPagingAndSortRepository<T extends AbstractEntity, ID extends Long>
        extends PagingAndSortingRepository<T,ID> {
    @Override
    @Query("select e from #{#entityName} e where e.professor = ?#{principal.professor} and e.enabled = true")
    Iterable<T> findAll(Sort sort);

    @Override
    @Query("select e from #{#entityName} e where e.professor = ?#{principal.professor} and e.enabled = true")
    Page<T> findAll(Pageable pageable);

    @Override
    @Query("select e from #{#entityName} e where e.id =?1 and e.professor = ?#{principal.professor} and e.enabled = true")
    T findOne(Long id);

    @Override
    default boolean exists(Long id){
        return findOne(id) != null;
    }

    @Override
    @Query("select e from #{#entityName} e where e.professor = ?#{principal.professor} and e.enabled = true")
    Iterable<T> findAll();

    @Override
    @Query("select e from #{#entityName} e where e.professor = ?#{principal.professor} and e.enabled = true")
    Iterable<T> findAll(Iterable<ID> iterable);

    @Override
    @Query("select count(e) from #{#entityName} e where e.professor = ?#{principal.professor} and e.enabled = true")
    long count();

    @Override
    @Transactional
    @Modifying
    @Query("update #{#entityName} e set e.enabled=false where e.id=?1 and e.professor = ?#{principal.professor}")
    void delete(Long id);

    @Override
    @Transactional
    @Modifying
    default void delete(T t){
        delete(t.getId());
    }

    @Override
    @Transactional
    @Modifying
    default void delete(Iterable<? extends T> iterable){
        iterable.forEach(entity -> delete(entity.getId()));
    }

    @Override
    @Transactional
    @Modifying
    @Query("update #{#entityName} e set e.enabled=false where e.professor = ?#{principal.professor}")
    void deleteAll();
}

这样做，我的所有基本查询将自动包括实体名称、教授以及是否启用。比如我的 QuestionRepository 是这样的：

public interface QuestionRepository extends CustomPagingAndSortRepository<Question, Long> {
    @Query("select q from Question q where q.course.id = ?1 and q.title like %?2% and q.professor = ?#{principal.professor} and q.enabled = true")
    List<Question> listQuestionsByCourseAndTitle(long courseId, String title);
}

现在我不必担心创建自定义删除、自定义 findALL 或 deleteAll 等，以便为我创建的每个类包含 Professor 和 enabled。

所以，我自己的问题的答案：在我看来，在所有课程中添加与教授的关联是有效的（在像我这样的情况下，使用 JWT 身份验证）。我能够减少很多代码，这是一个 100% 的 Spring 解决方案。

PS：还没有用Sort 和Pageable 测试findAll。