Spring JPA：双向关联下如何仅查询指定字段避免递归？

当然可以实现，直接上几个可行的方案：

方案1：用Jackson的@JsonView注解控字段 #

通过定义不同的视图分组，控制不同场景下要序列化的字段，完美匹配你的需求：

首先定义两个视图接口：

public class Views {
    // 基础视图：只包含User的核心字段，不含articles
    public static class BasicUser {}
    // 完整视图：继承基础视图，额外包含articles字段
    public static class FullUser extends BasicUser {}
}

修改User实体类，给字段指定对应的视图：

@Entity
@Table(name = "user")
@Data
public class User {
    @JsonView(Views.BasicUser.class)
    private int userId;
    @JsonView(Views.BasicUser.class)
    private String firstName;
    @JsonView(Views.BasicUser.class)
    private String lastName;

    @JsonView(Views.FullUser.class)
    @OneToMany
    @JoinColumn(name="user")
    private List<Article> articles;
}

修改Article实体类，指定关联的User用基础视图：

@Entity
@Table(name = "article")
@Data
public class Article {
    private int articleId;
    private String articleText;

    @JsonView(Views.BasicUser.class)
    @ManyToOne
    @JoinColumn(name="user_id")
    private User user;
}

最后在Controller接口上指定用完整视图：

@GetMapping("/users/{id}")
@JsonView(Views.FullUser.class)
public User getUserById(@PathVariable int id) {
    return userRepository.findById(id).orElse(null);
}

这样顶层User会用FullUser视图，带出所有字段包括articles；而Article里的User会自动用BasicUser视图，跳过articles字段，彻底避免递归。

方案2：自定义Jackson序列化器 #

如果不想加一堆视图注解，也可以写个自定义序列化器，根据序列化上下文判断要不要输出articles字段：

先写序列化器逻辑：

public class UserSerializer extends StdSerializer<User> {
    public UserSerializer() {
        this(null);
    }

    public UserSerializer(Class<User> t) {
        super(t);
    }

    @Override
    public void serialize(User user, JsonGenerator gen, SerializerProvider provider) throws IOException {
        gen.writeStartObject();
        gen.writeNumberField("userId", user.getUserId());
        gen.writeStringField("firstName", user.getFirstName());
        gen.writeStringField("lastName", user.getLastName());
        
        // 判断当前是不是在序列化Article里的user字段
        boolean isInsideArticle = gen.getOutputContext().getParent().getCurrentName().equals("user");
        
        // 只有顶层User才输出articles
        if (!isInsideArticle) {
            gen.writeFieldName("articles");
            provider.defaultSerializeValue(user.getArticles(), gen);
        }
        gen.writeEndObject();
    }
}

然后在User实体类上指定用这个序列化器：

@Entity
@Table(name = "user")
@Data
@JsonSerialize(using = UserSerializer.class)
public class User {
    // 字段定义不变
}

这种方式不用额外定义视图，靠上下文判断就能实现需求。

方案3：用DTO层解耦（生产环境推荐） #

如果不想在实体类上沾序列化相关的注解，最干净的方式是用DTO（数据传输对象）把持久化实体和返回前端的数据结构彻底分开：

创建三个DTO类：

// 顶层User的完整DTO，包含articles
@Data
public class UserFullDTO {
    private int userId;
    private String firstName;
    private String lastName;
    private List<ArticleDTO> articles;

    public static UserFullDTO fromEntity(User user) {
        UserFullDTO dto = new UserFullDTO();
        dto.setUserId(user.getUserId());
        dto.setFirstName(user.getFirstName());
        dto.setLastName(user.getLastName());
        dto.setArticles(user.getArticles().stream()
            .map(ArticleDTO::fromEntity)
            .collect(Collectors.toList()));
        return dto;
    }
}

// Article的DTO，关联基础User信息
@Data
public class ArticleDTO {
    private int articleId;
    private String articleText;
    private UserBasicDTO user;

    public static ArticleDTO fromEntity(Article article) {
        ArticleDTO dto = new ArticleDTO();
        dto.setArticleId(article.getArticleId());
        dto.setArticleText(article.getArticleText());
        dto.setUser(UserBasicDTO.fromEntity(article.getUser()));
        return dto;
    }
}

// 基础User的DTO，不含articles
@Data
public class UserBasicDTO {
    private int userId;
    private String firstName;
    private String lastName;

    public static UserBasicDTO fromEntity(User user) {
        UserBasicDTO dto = new UserBasicDTO();
        dto.setUserId(user.getUserId());
        dto.setFirstName(user.getFirstName());
        dto.setLastName(user.getLastName());
        return dto;
    }
}

然后在Controller里返回DTO：

@GetMapping("/users/{id}")
public UserFullDTO getUserById(@PathVariable int id) {
    User user = userRepository.findById(id).orElse(null);
    return UserFullDTO.fromEntity(user);
}

这种方式完全解耦，实体类只负责持久化逻辑，DTO负责返回结构，后期需求变更也更容易维护。

内容的提问来源于stack exchange，提问作者AC1