springboot 响应对象动态嵌套过滤字段代码

以下是一个使用Spring Boot的响应对象动态嵌套过滤字段的示例代码：

首先，我们需要定义一个过滤器对象，它包含了需要过滤的字段列表：

public class FieldFilter {
    private Set<String> fields;

    public FieldFilter(String... fields) {
        this.fields = new HashSet<>(Arrays.asList(fields));
    }

    public Set<String> getFields() {
        return fields;
    }

    public boolean contains(String field) {
        return fields.contains(field);
    }
}

然后，我们可以定义一个响应对象，它包含了需要过滤的嵌套字段：

public class ResponseObject {
    private String field1;
    private String field2;
    private NestedObject nestedObject;

    public ResponseObject(String field1, String field2, NestedObject nestedObject) {
        this.field1 = field1;
        this.field2 = field2;
        this.nestedObject = nestedObject;
    }

    public String getField1() {
        return field1;
    }

    public void setField1(String field1) {
        this.field1 = field1;
    }

    public String getField2() {
        return field2;
    }

    public void setField2(String field2) {
        this.field2 = field2;
    }

    public NestedObject getNestedObject() {
        return nestedObject;
    }

    public void setNestedObject(NestedObject nestedObject) {
        this.nestedObject = nestedObject;
    }
}

其中，嵌套对象类NestedObject也需要定义：

public class NestedObject {
    private String field3;
    private String field4;

    public NestedObject(String field3, String field4) {
        this.field3 = field3;
        this.field4 = field4;
    }

    public String getField3() {
        return field3;
    }

    public void setField3(String field3) {
        this.field3 = field3;
    }

    public String getField4() {
        return field4;
    }

    public void setField4(String field4) {
        this.field4 = field4;
    }
}

接下来，我们可以定义一个响应对象过滤器，它根据提供的过滤器对象和嵌套字段名称来过滤响应对象：

public class ResponseObjectFilter {
    public static ResponseObject filter(ResponseObject responseObject, FieldFilter fieldFilter, String... nestedFieldNames) {
        if (fieldFilter == null || fieldFilter.getFields().isEmpty()) {
            return responseObject;
        }

        List<String> nestedFields = Arrays.asList(nestedFieldNames);
        ResponseObject filteredObject = new ResponseObject(
                fieldFilter.contains("field1") ? responseObject.getField1() : null,
                fieldFilter.contains("field2") ? responseObject.getField2() : null,
                null);

        if (nestedFields.contains("nestedObject")) {
            NestedObject nestedObject = responseObject.getNestedObject();
            if (nestedObject != null) {
                filteredObject.setNestedObject(new NestedObject(
                        fieldFilter.contains("nestedObject.field3") ? nestedObject.getField3() : null,
                        fieldFilter.contains("nestedObject.field4") ? nestedObject.getField4() : null
                ));
            }
        }

        return filteredObject;
    }
}

最后，我们可以在控制器中使用该过滤器来过滤响应对象：

@RestController
public class MyController {
    @GetMapping("/response")
    public ResponseObject getResponseObject() {
        ResponseObject responseObject = new ResponseObject("value1", "value2", new NestedObject("value3", "value4"));
        return ResponseObjectFilter.filter(responseObject, new FieldFilter("field1", "nestedObject.field3"), "nestedObject");
    }
}

在上面的示例代码中，我们使用了FieldFilter对象来指定需要过滤的字段列表，然后使用ResponseObjectFilter类来根据提供的过滤器对象和嵌套字段名称来过滤响应对象。在控制器中，我们只需要调用ResponseObjectFilter.filter方法并传入响应对象、过滤器对象和嵌套字段名称即可。