Spring JPA：多对多关联（独立关联表）查询避免无限递归

首先纠正你实体映射中的错误：UsersRoles作为关联表，@ManyToOne注解对应的应该是单个User和Role实例（而非List），因为每个关联记录仅对应一个用户和一个角色；同时User和Role中的@OneToMany需要指定mappedBy属性，明确关联关系的维护端。修正后的实体代码如下：

// User.java
@Entity
public class User {
    private String name;
    
    @OneToMany(mappedBy = "user")
    private List<UsersRoles> usersRoles;
    
    // getter、setter
}

// Role.java
@Entity
public class Role {
    private String name;
    
    @OneToMany(mappedBy = "role")
    private List<UsersRoles> usersRoles;
    
    // getter、setter
}

// UsersRoles.java
@Entity
public class UsersRoles {
    @ManyToOne
    private User user;

    @ManyToOne
    private Role role;
    
    private Long tenantId; // 多租户字段
    
    // getter、setter
}

接下来针对无限递归和DTO映射问题，提供几种落地实现方案：

方案1：手动映射DTO（最直接可控） #

在业务层查询用户后，手动提取所需字段转换为UserDTO，同时通过JOIN FETCH解决懒加载异常。

步骤1：修改Repository查询，预加载关联数据 #

public interface UserRepository extends JpaRepository<User, Long> {
    @Query("SELECT u FROM User u JOIN FETCH u.usersRoles ur JOIN FETCH ur.role WHERE u.name = :name")
    Optional<User> getUserByName(String name);
}

步骤2：Service层手动映射 #

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public Optional<UserDTO> getUserDTOByName(String name) {
        return userRepository.getUserByName(name)
                .map(user -> {
                    UserDTO dto = new UserDTO();
                    dto.setName(user.getName());
                    // 从关联表中提取角色列表
                    List<Role> roles = user.getUsersRoles().stream()
                            .map(UsersRoles::getRole)
                            .collect(Collectors.toList());
                    dto.setRoles(roles);
                    return dto;
                });
    }
}

方案2：使用ModelMapper自动映射 #

借助ModelMapper框架简化实体到DTO的映射逻辑，减少手动代码量。

步骤1：引入依赖（Maven示例） #

<dependency>
    <groupId>org.modelmapper</groupId>
    <artifactId>modelmapper</artifactId>
    <version>3.1.1</version>
</dependency>

步骤2：配置ModelMapper映射规则 #

@Configuration
public class ModelMapperConfig {
    @Bean
    public ModelMapper modelMapper() {
        ModelMapper mapper = new ModelMapper();
        // 自定义映射：从User的usersRoles列表中提取Role到UserDTO的roles字段
        mapper.typeMap(User.class, UserDTO.class)
                .addMapping(
                    src -> src.getUsersRoles().stream().map(UsersRoles::getRole).collect(Collectors.toList()),
                    UserDTO::setRoles
                );
        return mapper;
    }
}

步骤3：Service层使用映射 #

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    @Autowired
    private ModelMapper modelMapper;

    public Optional<UserDTO> getUserDTOByName(String name) {
        return userRepository.getUserByName(name)
                .map(user -> modelMapper.map(user, UserDTO.class));
    }
}

方案3：JPQL直接构造DTO #

通过JPQL语句直接实例化UserDTO，跳过实体映射环节，性能更优。

步骤1：给UserDTO添加构造方法 #

public class UserDTO {
    private String name;
    private List<Role> roles;

    // 必须与JPQL中的字段顺序匹配
    public UserDTO(String name, List<Role> roles) {
        this.name = name;
        this.roles = roles;
    }

    // getter、setter
}

步骤2：Repository中定义查询 #

public interface UserRepository extends JpaRepository<User, Long> {
    @Query("SELECT NEW com.yourpackage.dto.UserDTO(u.name, " +
            "SELECT ur.role FROM UsersRoles ur WHERE ur.user = u) " +
            "FROM User u WHERE u.name = :name")
    Optional<UserDTO> getUserDTOByName(String name);
}

角色与权限关联的处理方案 #

对于角色与权限的类似多对多关联（带额外字段），完全复用上述逻辑：

1. 创建中间实体（如RolePermissions），修正@ManyToOne/@OneToMany映射关系；
2. 定义对应的权限DTO（如PermissionDTO），通过手动映射、ModelMapper或JPQL构造的方式转换数据；
3. 查询时使用JOIN FETCH预加载关联数据，避免懒加载异常。

额外：解决实体序列化递归的临时方案 #

若需临时返回实体而非DTO，可通过Jackson注解控制序列化：

• 在User的usersRoles字段添加@JsonManagedReference
• 在UsersRoles的user字段添加@JsonBackReference

但此方式仅解决序列化问题，实体本身仍存在循环引用，推荐优先使用DTO方案，既能避免递归，又能精准控制返回数据结构。

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