MapStruct递归映射遇StackOverflowError问题求助，拟替换Spring BeanUtils

嗨，这个循环引用导致的栈溢出问题在MapStruct里确实是个常见的坑——毕竟JPA的双向关联设计和MapStruct默认的递归映射逻辑天生就容易撞在一起。我给你几个实用的解决方案，你可以根据自己的业务场景选：

1. 直接忽略引发循环的关联字段（最简单） #

如果你的DTO不需要保留双向关联，直接用@Mapping注解把循环链切断就行。比如在映射A到ADto时，忽略B对象里的A集合；或者映射B到BDto时忽略A对象里的B引用：

@Mapper
public interface CustomMapper {
    CustomMapper INSTANCE = Mappers.getMapper(CustomMapper.class);
    
    // 映射A到ADto时，忽略B中的aData字段
    @Mapping(target = "bData.aData", ignore = true)
    ADto atoADto(A a);
    
    // 如果需要映射B到BDto，同样忽略A中的bData字段
    @Mapping(target = "aData.bData", ignore = true)
    BDto btoBDto(B b);
}

这种方式最直接，适合你只需要单向关联数据的场景，完全避免递归循环。

2. 使用MapStruct内置的循环避免上下文（MapStruct 1.4+推荐） #

从MapStruct 1.4版本开始，官方提供了CycleAvoidingMappingContext这个内置工具类，专门用来处理循环引用问题。你只需要在映射方法里添加这个上下文参数即可：

@Mapper
public interface CustomMapper {
    CustomMapper INSTANCE = Mappers.getMapper(CustomMapper.class);
    
    ADto atoADto(A a, @Context CycleAvoidingMappingContext context);
    
    // 提供一个无参默认方法，方便调用
    default ADto atoADto(A a) {
        return atoADto(a, new CycleAvoidingMappingContext());
    }
    
    // 同样给B的映射方法加上上下文
    BDto btoBDto(B b, @Context CycleAvoidingMappingContext context);
}

这个类会自动追踪已经映射过的对象，遇到重复对象时不会重复映射，自然就不会出现栈溢出了，是官方推荐的标准解法。

3. 自定义上下文追踪映射过的对象（兼容旧版本） #

如果你的MapStruct版本低于1.4，也可以自己写一个简单的上下文类来追踪已映射的对象，原理和内置类类似：

首先创建上下文类：

public class MappingTracker {
    private final Set<Object> mappedObjects = new HashSet<>();
    
    public boolean hasMapped(Object obj) {
        return mappedObjects.contains(obj);
    }
    
    public void markMapped(Object obj) {
        mappedObjects.add(obj);
    }
}

然后修改Mapper接口：

@Mapper
public interface CustomMapper {
    CustomMapper INSTANCE = Mappers.getMapper(CustomMapper.class);
    
    ADto atoADto(A a, @Context MappingTracker tracker);
    
    default ADto atoADto(A a) {
        return atoADto(a, new MappingTracker());
    }
    
    // 自定义B的映射逻辑，先检查是否已经映射过
    default BDto btoBDto(B b, @Context MappingTracker tracker) {
        if (b == null || tracker.hasMapped(b)) {
            return null;
        }
        tracker.markMapped(b);
        BDto dto = new BDto();
        dto.setId(b.getId());
        dto.setName(b.getName());
        // 映射A集合时也要传入追踪器
        dto.setaData(mapAData(b.getaData(), tracker));
        return dto;
    }
    
    // 批量映射A集合的方法，同样检查是否已映射
    default Set<ADto> mapAData(Set<A> aSet, @Context MappingTracker tracker) {
        Set<ADto> dtoSet = new HashSet<>();
        for (A a : aSet) {
            if (!tracker.hasMapped(a)) {
                tracker.markMapped(a);
                dtoSet.add(atoADto(a, tracker));
            }
        }
        return dtoSet;
    }
}

这种方式灵活性很高，你可以完全控制哪些对象需要被追踪，适合需要自定义映射逻辑的场景。

4. 手动编写部分映射逻辑截断循环 #

如果业务逻辑比较特殊，你也可以直接手动编写映射方法，只映射需要的字段，主动切断循环链：

@Mapper
public interface CustomMapper {
    CustomMapper INSTANCE = Mappers.getMapper(CustomMapper.class);
    
    // 让MapStruct自动映射A的基本字段，我们自定义bData的映射
    @Mapping(target = "bData", qualifiedByName = "mapBWithoutAData")
    ADto atoADto(A a);
    
    @Named("mapBWithoutAData")
    default BDto mapBWithoutAData(B b) {
        if (b == null) {
            return null;
        }
        BDto dto = new BDto();
        dto.setId(b.getId());
        dto.setName(b.getName());
        // 这里不设置aData，直接切断循环
        return dto;
    }
}

这种方式适合你只需要B的基础数据，不需要关联的A集合的场景，完全由你掌控映射行为。

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