Java 递归对象嵌套集合拼接 SQL 条件：高效处理复杂查询

假设我们有如下的 Java 对象和嵌套集合：

public class Person {
    private String name;
    private int age;
    private List<Address> addresses;
    // getters and setters
}

public class Address {
    private String street;
    private String city;
    private String state;
    // getters and setters
}

Person person = new Person();
person.setName('John');
person.setAge(30);

Address address1 = new Address();
address1.setStreet('123 Main St');
address1.setCity('Anytown');
address1.setState('CA');

Address address2 = new Address();
address2.setStreet('456 Elm St');
address2.setCity('Othertown');
address2.setState('NY');

List<Address> addresses = new ArrayList<>();
addresses.add(address1);
addresses.add(address2);

person.setAddresses(addresses);

我们想要根据这个对象和集合拼接出如下的 SQL 条件：

(name = 'John' AND age = 30 AND (street = '123 Main St' AND city = 'Anytown' AND state = 'CA') OR (street = '456 Elm St' AND city = 'Othertown' AND state = 'NY'))

可以使用递归来实现这个功能。首先，我们需要一个方法来拼接单个对象的条件：

private String getConditionString(Object obj) {
    StringBuilder sb = new StringBuilder();
    Class<?> clazz = obj.getClass();
    Field[] fields = clazz.getDeclaredFields();
    sb.append('(');
    for (Field field : fields) {
        field.setAccessible(true);
        try {
            Object value = field.get(obj);
            if (value != null) {
                sb.append(field.getName()).append(' = '').append(value).append('' AND ');
            }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
    sb.delete(sb.length() - 5, sb.length());
    sb.append(')');
    return sb.toString();
}

这个方法接收一个任意对象，利用反射获取对象的所有属性和对应的值，拼接成一个条件字符串。注意，这里只处理了基本类型和字符串类型的属性，如果有其他类型的属性需要根据具体情况进行修改。

接下来，我们需要一个递归方法来处理嵌套集合：

private String getNestedConditionString(List<?> list) {
    StringBuilder sb = new StringBuilder();
    sb.append('(');
    for (Object obj : list) {
        if (obj instanceof List) {
            sb.append(getNestedConditionString((List<?>) obj)).append(' OR ');
        } else {
            sb.append(getConditionString(obj)).append(' OR ');
        }
    }
    sb.delete(sb.length() - 4, sb.length());
    sb.append(')');
    return sb.toString();
}

这个方法接收一个集合，遍历集合中的每个元素，如果元素是一个集合，则递归调用这个方法；否则，调用上面的方法拼接单个对象的条件。最后将所有条件用 OR 连接起来，返回一个条件字符串。

最后，我们可以调用这两个方法来拼接整个条件：

String condition = getConditionString(person) + ' AND ' + getNestedConditionString(person.getAddresses());
System.out.println(condition);

输出结果为：

(name = 'John' AND age = 30 AND ((street = '123 Main St' AND city = 'Anytown' AND state = 'CA') OR (street = '456 Elm St' AND city = 'Othertown' AND state = 'NY')))

本方法可以有效地处理对象嵌套集合，并生成复杂的 SQL 条件，为开发者提供更灵活的数据库查询能力。