如何通过字段笛卡尔积生成Java对象？Spring Boot测试数据生成方案

问题背景 #

现有如下Java实体类：

class User{
   String name;
   String email;
   int age;
   Role[] role;
   // 其他字段

   // 构造方法、getter、setter等
}

其中Role为已定义的类或枚举。

需要实现一个工厂方法，基于传入的字段值列表（如姓名列表、年龄列表）的笛卡尔积，生成所有可能的User实例。目标方法大致结构如下：

List<User> factory(Map<String, List> arguments){
   List<User> result = new ArrayList<>();
   // 利用arguments生成所有User组合
   return result;
}

核心要求：传入的参数数量不固定，未提供的字段需设为默认值（如引用类型设null，基本类型设对应默认值）。

补充场景：Spring Boot Web应用的分层测试（JUnit+Mockito）中，需要大量测试数据，避免硬编码重复代码，希望实现通用的实例生成逻辑。

一、手动实现通用方案 #

通过反射+笛卡尔积生成实现，无需依赖第三方库，灵活可控：

实现步骤 #

1. 遍历目标类的所有字段，为未传入值的字段设置默认值（引用类型null，基本类型如int设0）；
2. 生成所有字段值列表的笛卡尔积，得到所有可能的字段值组合；
3. 通过反射创建实例并为每个字段赋值。

完整代码 #

import java.lang.reflect.Field;
import java.util.*;

public class GenericInstanceFactory {

    @SuppressWarnings("unchecked")
    public static <T> List<T> createInstances(Class<T> clazz, Map<String, List<?>> arguments) throws Exception {
        // 1. 整理所有字段的可选值列表（补全默认值）
        Map<String, List<?>> fieldValueMap = new HashMap<>();
        Field[] fields = clazz.getDeclaredFields();

        for (Field field : fields) {
            String fieldName = field.getName();
            if (arguments.containsKey(fieldName)) {
                fieldValueMap.put(fieldName, arguments.get(fieldName));
            } else {
                // 未提供字段值时，生成仅含默认值的列表
                Object defaultValue = getDefaultValue(field.getType());
                fieldValueMap.put(fieldName, Collections.singletonList(defaultValue));
            }
        }

        // 2. 生成字段值的笛卡尔积
        List<Map<String, Object>> combinations = generateCartesianProduct(fieldValueMap);

        // 3. 反射创建实例并赋值
        List<T> instances = new ArrayList<>();
        for (Map<String, Object> combo : combinations) {
            T instance = clazz.getDeclaredConstructor().newInstance();
            for (Field field : fields) {
                field.setAccessible(true);
                field.set(instance, combo.get(field.getName()));
            }
            instances.add(instance);
        }

        return instances;
    }

    // 获取字段类型的默认值
    private static Object getDefaultValue(Class<?> type) {
        if (type.isPrimitive()) {
            if (type == int.class) return 0;
            if (type == boolean.class) return false;
            if (type == long.class) return 0L;
            if (type == double.class) return 0.0D;
            // 其他基本类型可按需补充
            return null;
        }
        return null; // 引用类型默认null
    }

    // 生成笛卡尔积
    private static List<Map<String, Object>> generateCartesianProduct(Map<String, List<?>> fieldValues) {
        List<Map<String, Object>> result = new ArrayList<>();
        result.add(new HashMap<>());

        for (Map.Entry<String, List<?>> entry : fieldValues.entrySet()) {
            String fieldName = entry.getKey();
            List<?> values = entry.getValue();
            List<Map<String, Object>> tempList = new ArrayList<>();

            for (Map<String, Object> existingMap : result) {
                for (Object value : values) {
                    Map<String, Object> newMap = new HashMap<>(existingMap);
                    newMap.put(fieldName, value);
                    tempList.add(newMap);
                }
            }

            result = tempList;
        }

        return result;
    }
}

使用示例 #

// 准备测试参数
Map<String, List<?>> args = new HashMap<>();
args.put("name", Arrays.asList("Alice", "Bob"));
args.put("age", Arrays.asList(25, 30));
args.put("role", Arrays.asList(new Role[]{Role.ADMIN}, new Role[]{Role.USER}));

// 生成所有User实例
List<User> users = GenericInstanceFactory.createInstances(User.class, args);

二、工具库推荐（测试场景优先） #

如果是测试数据生成场景，推荐使用现成的工具库，减少重复代码：

1. Fixture Factory #

专门用于测试数据生成的库，支持笛卡尔积、自定义规则，配置简单：

依赖引入

<dependency>
    <groupId>br.com.six2six</groupId>
    <artifactId>fixture-factory</artifactId>
    <version>3.1.0</version>
    <scope>test</scope>
</dependency>

使用示例

import br.com.six2six.fixturefactory.Fixture;
import br.com.six2six.fixturefactory.Rule;

// 定义User的生成规则
Fixture.of(User.class).addTemplate("testTemplate", new Rule(){{
    add("name", random("Alice", "Bob"));
    add("age", random(25, 30));
    add("role", random(new Role[]{Role.ADMIN}, new Role[]{Role.USER}));
    add("email", null); // 未指定的字段可直接设默认值
}});

// 生成所有组合的实例（4种组合）
List<User> users = Fixture.from(User.class).gimme(4);

2. JUnitParams #

适合JUnit参数化测试，可直接生成笛卡尔积参数，配合BeanUtils快速创建实例：

依赖引入

<dependency>
    <groupId>pl.pragmatists</groupId>
    <artifactId>JUnitParams</artifactId>
    <version>1.1.1</version>
    <scope>test</scope>
</dependency>

使用示例

import junitparams.Parameters;
import junitparams.JUnitParamsRunner;
import org.junit.runner.RunWith;
import org.junit.Test;
import org.apache.commons.beanutils.BeanUtils;

@RunWith(JUnitParamsRunner.class)
public class UserTest {

    @Test
    @Parameters(method = "userParameterCombinations")
    public void testUser(String name, Integer age, Role[] role, String email) throws Exception {
        User user = new User();
        // 用BeanUtils批量赋值
        BeanUtils.setProperty(user, "name", name);
        BeanUtils.setProperty(user, "age", age);
        BeanUtils.setProperty(user, "role", role);
        BeanUtils.setProperty(user, "email", email);
        
        // 执行测试逻辑
    }

    // 生成所有参数组合（笛卡尔积）
    private Object[] userParameterCombinations() {
        return $(
            $("Alice", 25, new Role[]{Role.ADMIN}, null),
            $("Alice", 25, new Role[]{Role.USER}, null),
            $("Bob", 30, new Role[]{Role.ADMIN}, null),
            $("Bob", 30, new Role[]{Role.USER}, null)
        );
    }
}

总结 #

• 若需要通用、无依赖的实现，反射+笛卡尔积的手动方案最灵活，适合非测试场景或需高度定制的场景；
• 若仅用于测试数据生成，优先选择Fixture Factory，配置简单且功能丰富，能大幅减少硬编码。

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