JPA 和按多个日期搜索

Question

这是我的实体类

@Data
@NoArgsConstructor
@Builder
@AllArgsConstructor
@Entity(name = "words")
public class Word {

    @Id
    private Long id;

    @ManyToOne
    private Group group;

    @ManyToOne
    private User user;

    @NotBlank
    private String englishWord;

    @NotBlank
    private String russianWord;

    private LocalDate created = LocalDate.now();

    private final LocalDate plusOneDay = created.plusDays(1);

    private final LocalDate plusTwoDays = created.plusDays(2);

    private final LocalDate plusFiveDays = created.plusDays(5);

    private final LocalDate plusTenDays = created.plusDays(10);

    private final LocalDate plusTwoWeeks = created.plusWeeks(2);

    private final LocalDate plusSixWeeks = created.plusWeeks(6);

    private final LocalDate plusThreeMonths = created.plusMonths(3);

    private final LocalDate plusSixMonths = created.plusMonths(6);

    private final LocalDate plusOneYear = created.plusYears(1);
}

如您所见，我有几个 LocalDate 字段。

我需要检查，created, OR plusOneDay, OR plusTwoWeek, etc 是否与今天匹配。如果匹配 - 它必须从数据库中获取。我可以这样写：

Set<Word> findAllByCreatedOrByPlusOneDayOrByPlusTwoDays(LocalDate date);

但是请求会太长，并且不起作用。 还有其他方法可以在一个日期之前检查多个字段吗？

Answer 1

我认为您可以使用规范。文档：https://docs.spring.io/spring-data/jpa/docs/1.7.0.RELEASE/reference/html/#specifications

我编写了一些代码，可能会有所帮助。

import org.springframework.data.jpa.domain.Specification;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.time.LocalDate;

public class WordSpecs {

        public static Specification<Word> isOneDateEqual(final LocalDate date){
            return new Specification<Word>() {
                @Override
                public Predicate toPredicate(Root<Word> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                    final Predicate created = criteriaBuilder.equal(root.get("created"), date);
                    final Predicate plusOneDay = criteriaBuilder.equal(root.get("plusOneDay"), date);
                    return criteriaBuilder.or(created, plusOneDay);
                }
            };

        }
    }

存储库类：

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

@org.springframework.stereotype.Repository
public interface WordRepository extends JpaRepository<Word, Long>, JpaSpecificationExecutor {


}

服务类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.util.List;

@Service
public class WordService {

    @Autowired
    private WordRepository repository;

    public List<Word> findMatched(final LocalDate date){
        return repository.findAll(WordSpecs.isOneDateEqual(date));

    }

}

编辑：

更简单，您可能会喜欢：

@Query("SELECT word FROM Word word WHERE 1 = 1 AND word.user.userId = :userId AND ( word.created = :date OR word.plus1 = :date ) " )
List<Word> findMatched(@Param("date") final LocalDate date, @Param("userId") final Long userId); 

Answer 2

是的，您可以传递可能的日期列表：

Set<Word> findAllByCreatedIn(List<LocalDate> dates);

然后调用它：

repo.findAllByCreatedIn(List.of(date, date.minusDays(1), date.minusDays(2)));