Java 时间戳休眠

我尝试返回与特定用户相关的所有患者，但当我尝试返回日期时，我收到错误，即我没有合适的构造函数。 这是患者类别：

    package com.objects;

import java.io.Serializable;
import java.sql.Date;
import java.sql.Timestamp;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import org.hibernate.annotations.CollectionOfElements;
import org.hibernate.cfg.Configuration;
import org.hibernate.envers.reader.FirstLevelCache;

import javax.persistence.UniqueConstraint;
@Entity
@Table(name = "patient", uniqueConstraints = {
        @UniqueConstraint(columnNames = "paitentFirstName"),
        @UniqueConstraint(columnNames = "paitentLastName") })

public class Patient implements Serializable {

    @Id
    @Column(name="id")
    private int id;
    private String paitentFirstName;
    private String paitentLastName;
    private Timestamp dateOfbirth;
    private String sex;



    @ManyToMany(cascade = {CascadeType.ALL},fetch=FetchType.EAGER)
        @JoinTable(name="User_Patient", 
                    joinColumns={@JoinColumn(name="id")}, 
                    inverseJoinColumns={@JoinColumn(name="userName")})
        private Set<User> users = new HashSet<User>();



     @OneToMany(fetch = FetchType.LAZY, mappedBy = "pk.patient", cascade=CascadeType.ALL)
      private Set<JoinDrugPatient> JoinDrugPatient = new HashSet<JoinDrugPatient>(0);


     public Patient(int id, String paitentFirstName, String paitentLastName,
             Timestamp dateOfbirth,String sex) {
        this.id = id;
        this.paitentFirstName = paitentFirstName;
        this.paitentLastName = paitentLastName;
        this.dateOfbirth = dateOfbirth;
        this.sex = sex;
    }


     public Patient(int id, String paitentFirstName,String lastName,String sex){
         this.id = id;
         this.paitentFirstName = paitentFirstName;
         this.paitentLastName=lastName;
         this.sex=sex;
     }
     public Patient(String date){
         paitentFirstName=date;
     }

     public Patient(){}

    public int getId() {
        return id;
    }


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


    @Column(name = "paitentFirstName", nullable = false, length = 10)
    public String getPaitentFirstName() {
        return paitentFirstName;
    }


    public void setPaitentFirstName(String paitentFirstName) {
        this.paitentFirstName = paitentFirstName;
    }

    @Column(name = "paitentLastName", nullable = false, length = 10)
    public String getPaitentLastName() {
        return paitentLastName;
    }


    public void setPaitentLastName(String paitentLastName) {
        this.paitentLastName = paitentLastName;
    }


    public Timestamp getDateOfbirth() {
        return dateOfbirth;
    }


    public void setDateOfbirth(Timestamp dateOfbirth) {
        this.dateOfbirth = dateOfbirth;
    }


    public String getSex() {
        return sex;
    }


    public void setSex(String sex) {
        this.sex = sex;
    }


    public Set<User> getUsers() {
        return users;
    }


    public void setUsers(Set<User> users) {
        this.users = users;
    }

    @OneToMany(fetch = FetchType.LAZY, mappedBy = "pk.patient", cascade=CascadeType.ALL)
    public Set<JoinDrugPatient> getJoinDrugPatient() {
        return JoinDrugPatient;
    }


    public void setJoinDrugPatient(Set<JoinDrugPatient> joinDrugPatient) {
        JoinDrugPatient = joinDrugPatient;
    }










    public Set<JoinDrugPatient> getStockCategories() {
        return JoinDrugPatient;
    }


    public void setStockCategories(Set<JoinDrugPatient> stockCategories) {
        this.JoinDrugPatient = stockCategories;
    }


    @Override
    public String toString() {
        return "Patient [id=" + id + ", paitentFirstName=" + paitentFirstName
                + ", paitentLastName=" + paitentLastName + ", dateOfbirth="
                + dateOfbirth + ", sex=" + sex + "]";
    }





}

包com.objects；
导入java.io.Serializable；
导入java.sql.Date；
导入java.sql.Timestamp；
导入java.util.HashSet；
导入java.util.Set；
导入javax.persistence.CascadeType；
导入javax.persistence.Column；
导入javax.persistence.Entity；
导入javax.persistence.FetchType；
导入javax.persistence.Id；
导入javax.persistence.JoinTable；
导入javax.persistence.ManyToMany；
导入javax.persistence.JoinColumn；
导入javax.persistence.JoinTable；
导入javax.persistence.OneToMany；
导入javax.persistence.Table；
导入org.hibernate.annotations.CollectionFements；
导入org.hibernate.cfg.Configuration；
导入org.hibernate.envers.reader.FirstLevelCache；
导入javax.persistence.UniqueConstraint；
@实体
@表（name=“patient”，唯一约束={
@UniqueConstraint（columnNames=“PaitenFirstName”），
@UniqueConstraint（columnNames=“PaitenLastName”）}
公共类Patient实现可序列化{
@身份证
@列（name=“id”）
私有int-id；
私有字符串paitentFirstName；
私有字符串paitentLastName；
私有时间戳出生日期；
私密性；
@ManyToMany（cascade={CascadeType.ALL}，fetch=FetchType.EAGER）
@JoinTable（name=“User\u Patient”，
joinColumns={@JoinColumn（name=“id”）}，
inverseJoinColumns={@JoinColumn（name=“userName”）}
private Set users=new HashSet（）；
@OneToMany（fetch=FetchType.LAZY，mappedBy=“pk.patient”，cascade=CascadeType.ALL）
私有集JoinDrugPatient=新哈希集（0）；
公共患者（int-id、String-paitentFirstName、String-paitentLastName、，
时间戳dateOfbirth，字符串性别）{
this.id=id；
this.paitentFirstName=paitentFirstName；
this.paitentLastName=paitentLastName；
this.dateOfbirth=出生日期；
这个。性=性；
}
公共患者（int-id、String-paitentFirstName、String-lastName、String-sex）{
this.id=id；
this.paitentFirstName=paitentFirstName；
this.paitentLastName=lastName；
这个。性=性；
}
公共病人（字符串日期）{
paitentFirstName=日期；
}
公共病人（）{}
公共int getId（）{
返回id；
}
公共无效集合id（内部id）{
this.id=id；
}
@列（name=“paitentFirstName”，null=false，长度=10）
公共字符串getPaitentFirstName（）{
返回paitentFirstName；
}
public void setPaitentFirstName（字符串paitentFirstName）{
this.paitentFirstName=paitentFirstName；
}
@列（name=“paitentLastName”，null=false，长度=10）
公共字符串getPaitenLastName（）{
返回paitentLastName；
}
public void setPaitenLastName（字符串PaitenLastName）{
this.paitentLastName=paitentLastName；
}
公共时间戳getDateOfbirth（）{
出生返回日期；
}
public void setDateOfbirth（时间戳dateOfbirth）{
this.dateOfbirth=出生日期；
}
公共字符串getSex（）{
回归性；
}
公共无效集合（字符串性别）{
这个。性=性；
}
公共集getUsers（）{
返回用户；
}
公共void集合用户（集合用户）{
this.users=用户；
}
@OneToMany（fetch=FetchType.LAZY，mappedBy=“pk.patient”，cascade=CascadeType.ALL）
公共集getJoinDrugPatient（）{
返回患者；
}
公共无效setJoinDrugPatient（Set joinDrugPatient）{
JoinDrugPatient=JoinDrugPatient；
}
公共集合getStockCategories（）{
返回患者；
}
公共无效集合股票类别（集合股票类别）{
this.JoinDrugPatient=股票类别；
}
@凌驾
公共字符串toString（）{
return“Patient[id=“+id+”，paitentFirstName=“+paitentFirstName
+，paitentLastName=“+paitentLastName+”，出生日期=“
+出生日期+”，性别=“+sex+”]；
}
}

这是查询（hibernate）

List l=session.createQuery（“选择新患者（p.id，p.paitentFirstName，p.paitentLastName，p.dateOfbirth，p.sex）”
+“从患者p加入p.users a，其中a.UserName=？”）
.setParameter（0，用户名）
.list（）；

这不是一个Hibernate问题，而是一个Java问题 如有效Java（第二版）中所述

Java平台库中有一些类确实扩展了一个可实例化类并添加了一个值组件。例如 Timestamp扩展了java.util.Date并添加了纳秒 领域Timestamp的equals实现确实违反了对称性 如果使用时间戳和日期对象，则可能导致不稳定的行为 在同一集合中或以其他方式混合。时间戳 类有一个免责声明，警告程序员不要混淆日期和时间 时间戳。而只要你保留它们，你就不会有麻烦 分开，没有什么可以阻止你把它们混合在一起 由此产生的错误可能很难调试。时间戳的这种行为 上课是个错误，不应该模仿。（布洛赫，有效 爪哇，第二版）

你在类

用户中有什么？你不会有任何问题的
如果您在代码中的任何地方都使用
java.sql.Timestamp

为什么您要在HQL中使用新运算符，而不是简单地使用患者p的
。
？new（）运算符在构建由其他实体构造的实体时非常有用。。。（勾选）请在投递时自动设置代码格式并删除多余的空行；这使它更容易理解
List<Patient> l=session.createQuery("Select new Patient(p.id,p.paitentFirstName,p.paitentLastName,p.dateOfbirth,p.sex)"
                                        +" from Patient p join p.users a where a.UserName=?")
                                        .setParameter(0, userName)
                                        .list();