Jpa 对回调事件执行自动Bean验证时违反了Bean验证约束：'；预科生'；

我想存储

生日

，所以我在MySQL上选择了

日期

，当我在数据库中创建实体时，结果是这样的：

import java.util.Date;

    // ..code
    @NotNull(message="fill you birthdate")
    @Temporal(TemporalType.DATE)
    private Date birthdate;

但当我试图坚持时，它会给我以下错误：

对回调事件“prePersist”执行自动Bean验证时违反了Bean验证约束。有关详细信息，请参阅嵌入式约束冲突

我做错了什么？ 我在谷歌上读到一些关于定义时区的东西，我来自巴西，我该怎么做

编辑

package entity;

import java.io.Serializable;
import javax.persistence.*;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

import org.hibernate.validator.constraints.Email;

import java.util.Date;
import java.util.List;


/**
 * The persistent class for the user database table.
 * 
 */
@Entity
public class User implements Serializable {
    private static final long serialVersionUID = 1L;

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

    @Temporal(TemporalType.DATE)
    private Date birthdate;

    @NotNull(message="informe seu e-mail")
    @Email(message="e-mail inválido")
    private String email;

    @NotNull(message="informe seu gênero")
    private String gender;

    private String image;

    @NotNull(message="informe seu nome completo")
    private String name;

    @Size(min=6,max=16, message="senha com no mínimo: 6 dígitos e no máximo 16 dígitos")
    @NotNull(message="informe sua senha")
    private String password;

    //bi-directional many-to-one association to Document
    @OneToMany(mappedBy="user")
    private List<Document> documents;

    //bi-directional many-to-one association to QuestionQuery
    @OneToMany(mappedBy="user")
    private List<QuestionQuery> questionQueries;

    //bi-directional many-to-one association to Team
    @OneToMany(mappedBy="user")
    private List<Team> teams;

    public User() {
    }

    public Integer getId() {
        return this.id;
    }

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

    public Date getBirthdate() {
        return this.birthdate;
    }

    public void setBirthdate(Date birthdate) {
        this.birthdate = birthdate;
    }

    public String getEmail() {
        return this.email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getGender() {
        return this.gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getImage() {
        return this.image;
    }

    public void setImage(String image) {
        this.image = image;
    }

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return this.password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public List<Document> getDocuments() {
        return this.documents;
    }

    public void setDocuments(List<Document> documents) {
        this.documents = documents;
    }

    public List<QuestionQuery> getQuestionQueries() {
        return this.questionQueries;
    }

    public void setQuestionQueries(List<QuestionQuery> questionQueries) {
        this.questionQueries = questionQueries;
    }

    public List<Team> getTeams() {
        return this.teams;
    }

    public void setTeams(List<Team> teams) {
        this.teams = teams;
    }

    public void print() {
        System.out.println("User [id=" + id + ", birthdate=" + birthdate + ", email="
                + email + ", gender=" + gender + ", image=" + image + ", name="
                + name + ", password=" + password + "]");
    }



}

包实体；
导入java.io.Serializable；
导入javax.persistence.*；
导入javax.validation.constraints.NotNull；
导入javax.validation.constraints.Size；
导入org.hibernate.validator.constraints.Email；
导入java.util.Date；
导入java.util.List；
/**
*用户数据库表的持久类。
* 
*/
@实体
公共类用户实现可序列化{
私有静态最终长serialVersionUID=1L；
@身份证
@GeneratedValue（策略=GenerationType.IDENTITY）
私有整数id；
@时态（TemporalType.DATE）
私人生日；
@NotNull（message=“informe seu电子邮件”）
@电子邮件（message=“e-mail inválido”）
私人字符串电子邮件；
@NotNull（message=“informe seu gênero”）
私人字符串性别；
私有字符串图像；
@NotNull（message=“informe seu nome completo”）
私有字符串名称；
@大小（最小值=6，最大值=16，message=“senha com no mínimo:6dígitos e no máximo 16dígitos”）
@NotNull（message=“informe sua senha”）
私有字符串密码；
//文档的双向多对一关联
@OneToMany（mappedBy=“用户”）
私人清单文件；
//双向多对一关联查询
@OneToMany（mappedBy=“用户”）
私人列表查询；
//双向多对一关联到团队
@OneToMany（mappedBy=“用户”）
私人名单小组；
公共用户（）{
}
公共整数getId（）{
返回此.id；
}
公共无效集合id（整数id）{
this.id=id；
}
公共日期getBirthdate（）{
返回此项。生日；
}
公共无效设置出生日期（日期出生日期）{
this.birthdate=生日；
}
公共字符串getEmail（）{
返回此电子邮件；
}
公用电子邮件（字符串电子邮件）{
this.email=电子邮件；
}
公共字符串getGender（）{
返回这个。性别；
}
公共无效设置性别（字符串性别）{
这个。性别=性别；
}
公共字符串getImage（）{
返回此.image；
}
公共void setImage（字符串图像）{
这个图像=图像；
}
公共字符串getName（）{
返回此.name；
}
公共void集合名（字符串名）{
this.name=名称；
}
公共字符串getPassword（）{
返回此密码；
}
public void setPassword（字符串密码）{
this.password=密码；
}
公共列表文件（）{
归还此文件；
}
公共文件（列出文件）{
本文件=文件；
}
公共列表getQuestionQueries（）{
返回此项。查询；
}
公共void setQuestionQueries（列表questionQueries）{
this.questionQueries=questionQueries；
}
公共列表getTeams（）{
把这个还给我。团队；
}
公共医疗队（名单小组）{
这个。团队=团队；
}
公开作废印刷品（）{
System.out.println（“用户[id=“+id+”，birthdate=“+birthdate+”，电子邮件=”
+email+”，gender=“+gender+”，image=“+image+”，name=”
+name+”，password=“+password+”]”；
}
}

错误显示您试图持久化的实体失败 数据库约束，因此在实际插入之前，请尝试确定要插入到数据库中的确切值

---

也可以通过注释/ommitting

@NotNull

注释进行尝试

我解决问题的方法是颠倒顺序

@Size

和

@NotNull

之前：

@Size(min=6,max=16, message="senha com no mínimo: 6 dígitos e no máximo 16 dígitos")
@NotNull(message="informe sua senha")
private String password;

之后：

@NotNull(message="informe sua senha")
@Size(min=6,max=16, message="senha com no mínimo: 6 dígitos e no máximo 16 dígitos")
private String password;

我不知道为什么这个顺序如此重要，但它确实如此

---

谢谢大家

我也遇到了同样的问题，但经过几个小时的寻找，我终于找到了答案。。。。您应该编辑AbstractFacade.java类并添加以下代码

public void create(T entity) {

    ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
    Validator validator = factory.getValidator();
    Set<ConstraintViolation<T>> constraintViolations = validator.validate(entity);
    if(constraintViolations.size() > 0){
        Iterator<ConstraintViolation<T>> iterator = constraintViolations.iterator();
        while(iterator.hasNext()){
            ConstraintViolation<T> cv = iterator.next();
            System.err.println(cv.getRootBeanClass().getName()+"."+cv.getPropertyPath() + " " +cv.getMessage());

            JsfUtil.addErrorMessage(cv.getRootBeanClass().getSimpleName()+"."+cv.getPropertyPath() + " " +cv.getMessage());
        }
    }else{
        getEntityManager().persist(entity);
    }
}

public void创建（T实体）{
ValidatorFactory=Validation.buildDefaultValidatorFactory（）；
Validator Validator=factory.getValidator（）；
Set constraintViolations=validator.validate（实体）；
if（constraintViolations.size（）>0）{
迭代器迭代器=constraintViolations.Iterator（）；
while（iterator.hasNext（））{
ConstraintViolation cv=iterator.next（）；
System.err.println（cv.getRootBeanClass（）.getName（）+“+cv.getPropertyPath（）+”+cv.getMessage（））；
JsfUtil.addErrorMessage（cv.getRootBeanClass（）.getSimpleName（）+“+cv.getPropertyPath（）+”+cv.getMessage（））；
}
}否则{
getEntityManager（）.persist（实体）；
}
}

现在，此方法将提醒您哪个属性以及验证失败的原因。

---

我希望这对你有用，就像对我一样

当然，Iomanip的答案是完全正确的！我只是把它扩展了一点。也许这也有帮助：

  private boolean constraintValidationsDetected(T entity) {
    ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
    Validator validator = factory.getValidator();
    Set<ConstraintViolation<T>> constraintViolations = validator.validate(entity);
    if (constraintViolations.size() > 0) {
      Iterator<ConstraintViolation<T>> iterator = constraintViolations.iterator();
      while (iterator.hasNext()) {
        ConstraintViolation<T> cv = iterator.next();
        System.err.println(cv.getRootBeanClass().getName() + "." + cv.getPropertyPath() + " " + cv.getMessage());

        JsfUtil.addErrorMessage(cv.getRootBeanClass().getSimpleName() + "." + cv.getPropertyPath() + " " + cv.getMessage());
      }
      return true;
    }
    else {
      return false;
    }
  }

  public void create(T entity) {
    if (!constraintValidationsDetected(entity)) {
      getEntityManager().persist(entity);
    }
  }

  public T edit(T entity) {
    if (!constraintValidationsDetected(entity)) {
      return getEntityManager().merge(entity);
    }
    else {
      return entity;
    }
  }

  public void remove(T entity) {
    if (!constraintValidationsDetected(entity)) {
      getEntityManager().remove(getEntityManager().merge(entity));
    }
  }

检测到私有布尔约束验证（T实体）{ ValidatorFactory=Validation.buildDefaultValidatorFactory（）； Validator Validator=factory.getValidator（）； Set constraintViolations=validator.validate（实体）； if（constraintViolations.size（）>0）{ 迭代器迭代器=constraintViolations.Iterator（）； while（iterator.hasNext（））{ ConstraintViolation cv=iterator.next（）； System.err.println（cv.getRootBeanClass（）.getName（）+“）+

Bean Validation constraint(s) violated while executing Automatic Bean Validation on callback event:'preUpdate'. Please refer to embedded ConstraintViolations for details.

@Size(min = 1, max = 10)
@Column(name = Utilizator.JPA_DISCRIMINATOR)
private String jpaDiscriminator;

some_pk   INTEGER NOT NULL,
fk_b      VARCHAR2(5 CHAR)
...

id VARCHAR2(4 CHAR)
...

catch (ConstraintViolationException e) {
       log.log(Level.SEVERE,"Exception: ");
       e.getConstraintViolations().forEach(err->log.log(Level.SEVERE,err.toString()));
    }