杰克逊无限递归处理查询

Question

我有这个 JPA 方法，它使用查询从数据库中获取两个日期之间的“待办事项”列表。

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)

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

问题的关键在于，我找到的每个解决方案都说我必须将注释 @JsonIgnore 放在关系的一侧。我已经尝试过了，但似乎不起作用，因为关系本身会检索用户的所有“待办事项”......

Answer 1

把我的 cmets 放在一个答案的形式中。

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

当顶级实体被序列化为 JSON 时，会发生什么情况是它们的子实体被包含在 JSON 中。

但是由于子项包含对其父项的引用，因此对于每个子项，它们的父项也会再次序列化。

并且由于父级还产生对每个子级的引用，等等等等，您可以看到这将如何生成“无限”JSON 并产生堆栈溢出。

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

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

Answer 2

对此有两种解决方案。一种是使用@JsonIgnore，另一种是结合@JsonManagedReference和@JsonBackReference。

第一个进入父类，第二个进入子类。由于在这种情况下这些类是相同的，因此如果在相应版本的 Jackson 中没有修复递归错误，则可能会出现问题。

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

@JsonBackReference
private Tarea tareaPadre;

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

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