Question

我有这个JPA方法，它取一个＆＃34;列表来做＆＃34;使用查询从数据库中的两个日期之间。

public List<Tarea> findTareasEntreFechas(Long idUsuario, Date fechaInicio, Date fechaFin) {
    return jpaApi.withTransaction(entityManager -> {
        TypedQuery<Tarea> query = entityManager.createQuery(
            "SELECT t " 
                + "FROM Tarea t "
                + "WHERE usuario.id = :userId "
                + "AND t.hecha is FALSE "
                + "AND t.fechaFinalizacion >= :fechaInicio "
                + "AND t.fechaFinalizacion <= :fechaFin "
        , Tarea.class);
        try {
            List<Tarea> tareas = query.setParameter("userId", idUsuario)
                .setParameter("fechaInicio", fechaInicio)
                .setParameter("fechaFin", fechaFin)
                .getResultList();
            return tareas;
        }
        catch(NoResultException ex) {
            return null;
        }
    });
}

这是我的Tarea实体。

package models;

import org.hibernate.annotations.OnDelete;
import org.hibernate.annotations.OnDeleteAction;

import java.util.Date;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.*;

@Entity
public class Tarea {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String titulo;
    // Relación muchos-a-uno entre tareas y usuario
    @ManyToOne
    // Nombre de la columna en la BD que guarda físicamente
    // el ID del usuario con el que está asociado una tarea
    @JoinColumn(name = "usuarioId")
    public Usuario usuario;

    private Boolean hecha;

    @Temporal(TemporalType.DATE)
    private Date fechaCreacion;
    @Temporal(TemporalType.DATE)
    private Date fechaFinalizacion;

    @ManyToOne
    @JoinColumn(name = "tareaPadreId")
    private Tarea tareaPadre;

    @OneToMany(mappedBy="tareaPadre", fetch = FetchType.EAGER, cascade = CascadeType.REMOVE, orphanRemoval = true)
    public Set<Tarea> subtareas = new HashSet<Tarea>();

    public Tarea() {
        this.hecha = false;
    }

    public Tarea(Usuario usuario, String titulo) {
        this.usuario = usuario;
        this.titulo = titulo;
        this.hecha = false;
        this.fechaCreacion = Calendar.getInstance().getTime();
    }

    public Tarea(Usuario usuario, String titulo, Date fechaFinalizacion) {
        this.usuario = usuario;
        this.titulo = titulo;
        this.hecha = false;
        this.fechaCreacion = Calendar.getInstance().getTime();
        this.fechaFinalizacion = fechaFinalizacion;
    }

    // Getters y setters necesarios para JPA

    public Long getId() {
        return id;
    }

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

    public String getTitulo() {
        return titulo;
    }

    public void setTitulo(String titulo) {
        this.titulo = titulo;
    }

    public Usuario getUsuario() {
        return usuario;
    }

    public void setUsuario(Usuario usuario) {
        this.usuario = usuario;
    }

    public Boolean getHecha() { return hecha; }

    public void setHecha(Boolean hecha) { this.hecha = hecha; }

    public Date getFechaCreacion() {
        return fechaCreacion;
    }

    public Date getFechaFinalizacion() {
        return fechaFinalizacion;
    }

    public String getFechaFinalizacionFormateada() {
        Date fechaFinalizacion = getFechaFinalizacion();
        if(fechaFinalizacion != null) {
            return (new SimpleDateFormat("dd-MM-yyyy")).format(fechaFinalizacion);
        }
        return "";
    }

    public void setFechaFinalizacion(Date fechaFinalizacion) {
        this.fechaFinalizacion = fechaFinalizacion;
    }

    public boolean isRetrasada() {
        if(fechaFinalizacion != null) {
            Date ahora = new Date();
            return ahora.after(fechaFinalizacion);
        }
        return false;
    }

    public String toString() {
        return String.format("Tarea id: %s titulo: %s usuario: %s hecha: %s", id, titulo, usuario.toString(), hecha ? "si" : "no");
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = prime + ((titulo == null) ? 0 : titulo.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (getClass() != obj.getClass()) return false;
        Tarea other = (Tarea) obj;
        // Si tenemos los ID, comparamos por ID
        if (id != null && other.id != null)
            return ((long) id == (long) other.id);
            // sino comparamos por campos obligatorios
        else {
            if (titulo == null) {
                if (other.titulo != null) return false;
            } else if (!titulo.equals(other.titulo)) return false;
            if (usuario == null) {
                if (other.usuario != null) return false;
                else if (!usuario.equals(other.usuario)) return false;
            }
            if (hecha == null) {
                if (other.hecha != null) return false;
                else if (!hecha.equals(other.hecha)) return false;
            }
        }
        return true;
    }

    public Tarea getTareaPadre() {
        return tareaPadre;
    }

    public void setTareaPadre(Tarea tareaPadre) {
        this.tareaPadre = tareaPadre;
    }

    public Set<Tarea> getSubtareas() {
        return subtareas;
    }

    public void setSubtareas(Set<Tarea> subtareas) {
        this.subtareas = subtareas;
    }
}

问题是，当我从控制器调用此方法并尝试将返回的List序列化为JSON时，它会抛出此异常：

com.fasterxml.jackson.databind.JsonMappingException: Infinite recursion (StackOverflowError)

此外，当我手动将结果解析为String时，它不会发生。

问题的关键在于我找到的每个解决方案都说我必须将注释@JsonIgnore放在关系的一侧。我已经尝试过，但似乎没有效果，因为这种关系本身会检索所有＆＃34;做＆＃34;用户...

Answer 1

以答案的形式提出我的意见。

您的Tarea实体同时产生对父级和Set子级的引用。

当顶级实体被序列化为JSON时，他们的孩子会被包含在JSON中。

但是，由于孩子们包含对他们父母的引用，他们的父母也会为每个孩子再次序列化。

由于父母也会产生对每个孩子等的引用等，你可以看到它将如何产生“无限”JSON并产生堆栈溢出。

解决方案是确保在序列化时至少忽略对父项的引用（@JsonIgnore），尽管您也可以忽略对子项的引用以避免冗长。

进一步推测，如果您的用户实体Usuario 也链接到任务实体Tarea，您可能也需要忽略用户中的这些字段（您似乎已经尝试过，但这可能不是问题，也可能只是其中的一部分。）

Answer 2

这有两个解决方案。一个是使用@JsonIgnore，另一个是@JsonManagedReference和@JsonBackReference。

第一个进入父类，第二个进入子类。由于这些类在这个实例中是相同的，如果在各自版本的Jackson中没有修复递归错误，则可能会出现问题。

尝试这个（没有保证，因为我只在不同的类中使用它）

@JsonBackReference
private Tarea tareaPadre;

@JsonManagedReference
public Set<Tarea> subtareas = new HashSet<Tarea>();

这也有助于反序列化，因为子对象会自动设置为指向其父对象。

杰克逊无限递归使用查询

2 个答案: