尽管有@JsonIgnore，但杰克逊集合序列化程序错误

Question

您好，我的杰克逊解串器有问题。

我有两个 Spring Boot 应用程序和一个用于共享模型的单独模块。

    app1-> <dependency>
              <groupId>com.fasterxml.jackson.core</groupId>
              <artifactId>jackson-databind</artifactId>
              <version>2.5.0</version>
           </dependency>
           <dependency>
              <groupId>eu.emif.security</groupId>
              <artifactId>model</artifactId>
              <version>0.0.1-SNAPSHOT</version>
           </dependency>

    app2-> <dependency>
              <groupId>com.fasterxml.jackson.core</groupId>
              <artifactId>jackson-databind</artifactId>
              <version>2.5.0</version>
           </dependency>
           <dependency>
              <groupId>eu.emif.security</groupId>
              <artifactId>model</artifactId>
              <version>0.0.1-SNAPSHOT</version>
           </dependency>

   model-> <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
             <version>2.5.0</version>
           </dependency>

在模型中我有一个用户和角色对象

package eu.emif.security.model;

import org.codehaus.jackson.annotate.JsonAutoDetect;
import org.codehaus.jackson.annotate.JsonIgnore;
import org.codehaus.jackson.annotate.JsonMethod;
import org.codehaus.jackson.annotate.JsonProperty;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import javax.persistence.*;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

@Entity
@Table(name = "user", schema = "public")
@JsonAutoDetect(value = JsonMethod.NONE)
public class User implements Serializable, UserDetails {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @JsonProperty
    private Long id;

    @NotNull
    @JsonProperty
    private String username;
    @NotNull
    private String password;

    @ManyToMany(fetch = FetchType.EAGER,mappedBy = "users")
    @JsonIgnore
    private List<Role> roles;

    public User() { }

    @JsonIgnore
    public Collection<? extends GrantedAuthority> getAuthorities() {
        ArrayList<GrantedAuthority> grantedAuthorities = new ArrayList<GrantedAuthority>();
        for (Role role : roles) {
            grantedAuthorities.add(new SimpleGrantedAuthority(role.getRoleName()));
        }
        return grantedAuthorities;
    }

    public boolean isAccountNonExpired() {
        return true;
    }


    public boolean isAccountNonLocked() {
        return true;
    }


    public boolean isCredentialsNonExpired() {
        return true;
    }


    public boolean isEnabled() {
        return true;
    }


    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }


    public String getPassword() {
        return password;
    }

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

    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

    public Long getId() {
        return id;
    }
}




    import org.codehaus.jackson.annotate.JsonAutoDetect;
    import org.codehaus.jackson.annotate.JsonIgnore;
    import org.codehaus.jackson.annotate.JsonMethod;
    import org.codehaus.jackson.annotate.JsonProperty;

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

    @Entity
    @Table(name = "role", schema = "public")
    @JsonAutoDetect(value = JsonMethod.NONE)
    public class Role implements Serializable {

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

        @ManyToMany
        @JoinTable(name="user_roles", joinColumns=@JoinColumn(name="role_id"), inverseJoinColumns=@JoinColumn(name="user_id"))
        @JsonIgnore
        private List<User> users;

        public Role() {
        }
        @JsonProperty
        private String roleName;

        public Long getId() {
            return id;
        }

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

        public String getRoleName() {
            return roleName;
        }

        public void setRoleName(String roleName) {
            this.roleName = roleName;
        }

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

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


}
}

问题是，当我运行我的应用程序时，我得到一个堆栈溢出异常，因为当用户对象被序列化时，jackson 然后尝试序列化角色，而这些角色又拥有用户并且它无限循环。

我相信 @JsonIgnore 注释被忽略（没有双关语）

你们中有人知道为什么会发生这种情况吗？

这是他们在 Spring Boot 中告诉 jackson 需要在哪里寻找带有 jackson 注释的类的一种方式。我相信 app1 中的映射器根本不知道它们是单独模块中带注释的类。 亲切的问候

Answer 1

从您的 pom.xml 看来，您使用的是 Jackson 2.x，但注释来自旧的 Jackson (1.xx)。请尝试以下方法：

改变

import org.codehaus.jackson.annotate.JsonIgnore;

到

import org.fasterxml.jackson.annotate.JsonIgnore;