如何使用 springframework.data.jpa.repository.Query 查找两个日期之间忽略时间的所有结果

Question

我正在为这样一个简单的任务而苦苦挣扎，但我不知道自己做错了什么。

根据个人研究，我似乎正在编写我应该编写的代码，以便使用 Spring Data 搜索两个日期之间的所有记录。据我了解，“@Temporal(TemporalType.DATE)”具有“魔力”。

存储库

import java.math.BigDecimal;
import java.util.Date;
import java.util.List;

import javax.persistence.TemporalType;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.jpa.repository.Temporal;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;

import com.mybank.accountmanagement.model.Transaction;

    @Repository
    public interface TransactionRepository extends JpaRepository<Transaction, Long> {
    
        
@Query(value = "SELECT * FROM transactions WHERE account_id=:idAccount AND CAST(created_at AS date) BETWEEN :fromDate AND :toDate ", nativeQuery = true)
List<Transaction> findByAccountIdWithCreationDateBetween(@Param("idAccount") Long idAccount,
        @Param("fromDate") @Temporal(TemporalType.DATE) Date fromDate,
        @Param("toDate") @Temporal(TemporalType.DATE) Date toDate);
        
    }

型号：

交易

package com.mybank.accountmanagement.model;

import java.math.BigDecimal;

import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.validation.constraints.NotNull;

import org.hibernate.annotations.OnDelete;
import org.hibernate.annotations.OnDeleteAction;
import org.springframework.format.annotation.NumberFormat;

import com.fasterxml.jackson.annotation.JsonIdentityInfo;
import com.fasterxml.jackson.annotation.JsonIdentityReference;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;

@Entity
@Table(name = "transactions")
public class Transaction  extends AuditModel {

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

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = "account_id", nullable = false)
    @OnDelete(action = OnDeleteAction.CASCADE)
    @JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "id")
    @JsonIdentityReference(alwaysAsId = true)
    @JsonProperty("accoout_id")
    private Account account;

    @NotNull
    @NumberFormat(pattern = "#,###,###,###.##")
    private BigDecimal amount;

    @NotNull
    private int transactionType;

    
    
    
    public Transaction(Account account, @NotNull BigDecimal amount, @NotNull int transactionType) {
        super();
        this.account = account;
        this.amount = amount;
        this.transactionType = transactionType;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

    public BigDecimal getAmount() {
        return amount;
    }

    public void setAmount(BigDecimal amount) {
        this.amount = amount;
    }

    public int getTransactionType() {
        return transactionType;
    }

    public void setTransactionType(int transactionType) {
        this.transactionType = transactionType;
    }

    
}

审计模型

package com.mybank.accountmanagement.model;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;

@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
@JsonIgnoreProperties(value = { "createdAt", "updatedAt" }, allowGetters = true)
public abstract class AuditModel implements Serializable {
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "created_at", nullable = false, updatable = false)
    @CreatedDate
    private Date createdAt;

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "updated_at", nullable = false)
    @LastModifiedDate
    private Date updatedAt;

    public Date getCreatedAt() {
        return createdAt;
    }

    public void setCreatedAt(Date createdAt) {
        this.createdAt = createdAt;
    }

    public Date getUpdatedAt() {
        return updatedAt;
    }

    public void setUpdatedAt(Date updatedAt) {
        this.updatedAt = updatedAt;
    }
}

使用 "fromDate":"2020-08-02", "toDate":"2020-08-02" 搜索时我期望返回的结果

但它根本没有返回任何记录

***已编辑

由于某些未知的原因，我的记录与 fromDate 和 toDate 完全匹配的日期与结果无关

1. 用更长的 fromDate 和 toDate 搜索

   curl --location --request GET 'localhost:2000/transaction/1/bankstatement' --header 'Content-Type: application/json' --data-raw '{ "fromDate":"2020-08-01", “迄今为止”：“2020-08-03” }'

带来两条记录：

[
    {
        "createdAt": "2020-08-02T16:29:08.085+00:00",
        "updatedAt": "2020-08-02T16:29:08.085+00:00",
        "id": 1,
        "amount": 1.00,
        "transactionType": 2,
        "accoout_id": 1
    },
    {
        "createdAt": "2020-08-02T16:29:11.185+00:00",
        "updatedAt": "2020-08-02T16:29:11.185+00:00",
        "id": 2,
        "amount": 2.00,
        "transactionType": 1,
        "accoout_id": 1
    }
]

到目前为止一切顺利

1. 现在我在搜索确切日期时遇到问题。我希望上述查询的结果相同

   curl --location --request GET 'localhost:2000/transaction/1/bankstatement' --header 'Content-Type: application/json' --data-raw '{ "fromDate":"2020-08-02", “迄今为止”：“2020-08-02” }'

完全没有结果

*** 已编辑。感谢 Kavithakaran Kanapathippillai 提供的示例，我注意到它适用于新日期或 2020-08-02T00:00:00.000+00:00 但它在 2020-08-02 时失败。我仍然不知道为什么它会在 2020-08-02 失败，因为我不在乎时间，而且如果尝试少一天它也会起作用：2020-08-01

控制器

import java.math.BigDecimal;
import java.util.Date;
import java.util.List;

import javax.validation.Valid;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import com.mybank.accountmanagement.BankStatementFilter;

import com.mybank.accountmanagement.model.Transaction;
import com.mybank.accountmanagement.repository.TransactionRepository;
import com.mybank.accountmanagement.service.TransactionService;

@RestController
public class TransactionController {

    @Autowired
    TransactionService transactionService;

    @Autowired
    TransactionRepository transactionRepository;

    @GetMapping("/transaction/{accountId}/bankstatement")
    public List<Transaction> bankStatement(@PathVariable(value = "accountId") Long accountId,
            @Valid @RequestBody BankStatementFilter bankStatementFilter) {

        return transactionRepository.findByAccountIdWithCreationDateBetween(accountId,
                bankStatementFilter.getFromDate(), bankStatementFilter.getToDate());
    }

}

一个简单的 Pojo 仅用于从客户端发送的字符串中获取新的日期（例如 Postman 或 curl）

import java.util.Date;

public class BankStatementFilter {
    
    private Date fromDate;
    private Date toDate;
    public Date getFromDate() {
        return fromDate;
    }
    public void setFromDate(Date fromDate) {
        this.fromDate = fromDate;
    }
    public Date getToDate() {
        return toDate;
    }
    public void setToDate(Date toDate) {
        this.toDate = toDate;
    }

}

我用这个 POJO BankStatementFilter 做了一些愚蠢的事情

这是我在比较 new Date() 和 2020-08-02 时注意到的。既然我不在乎时间，那对吗？

*** 最后评论

它现在正在工作。我将我的 POJO 更改为波纹管。如果我在做一些愚蠢的事情，我会感谢你的建议。顺便说一句，我最初的问题得到了 100% 的回答。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class BankStatementFilter {

    private Date fromDate;
    private Date toDate;

    public Date getFromDate() {
        return fromDate;
    }

    public void setFromDate(String fromDate) {

        String pattern = "yyyy-MM-dd";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);

        try {
            this.fromDate = simpleDateFormat.parse(fromDate);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    public Date getToDate() {
        return toDate;
    }

    public void setToDate(String toDate) {
        String pattern = "yyyy-MM-dd";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);

        try {
            this.toDate = simpleDateFormat.parse(toDate);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

}

Answer 1

• @Temporal.Date 对您的 spring 数据存储库方法没有任何影响。只有在实体中注解时才有影响。

• 改为对cast您的参数执行以下操作：

    @Query(value = "SELECT * FROM transactions WHERE account_id=:idAccount " +
            "AND CAST(created_at AS date) " +
            "BETWEEN CAST(:fromDate AS date) AND CAST(:toDate AS date)"
            , nativeQuery = true)
    List<Transaction> findBy(@Param("idAccount") Long idAccount,
                             @Param("fromDate") Date fromDate,
                             @Param("toDate") Date toDate);

• 这是我与您的实体一起设置的示例项目，account 除外，因为如果您想比较，这不是问题。您可以将项目作为 maven 导入 IntelliJ 并运行主应用程序，它将插入数据并将其带回

  https://github.com/kavi-kanap/stackoverflow-63212441

Answer 2

您是否尝试过在 SQL 查询中使用 >= 和

另外我的建议是不要使用本机查询并尝试使用模型类来快速正确地反序列化，因为您已经定义了模型类。