问题：

将Spring MVC中仅提及的字段序列化为JSON响应

燕航

2023-03-14

我正在使用spring MVC编写一个Rest服务，该服务产生JSON响应。它应该允许客户端仅选择给定的字段作为响应，这意味着客户端可以将他感兴趣的字段作为url参数提及，如？fields=field1，field2。

使用Jackson注释并不能提供我想要的内容，因为它不是动态的，而且Jackson中的过滤器似乎也不够有前途。到目前为止，我正在考虑实现一个自定义消息转换器，它可以处理这个问题。

有没有其他更好的方法来实现这一目标？我希望此逻辑不与我的服务或控制器耦合。

共有3个答案

柯翔

2023-03-14

我从来没有这样做过，但在看了这一页后，http://wiki.fasterxml.com/JacksonFeatureJsonFilter似乎可以这样做:

1）创建自定义 JacksonAnnotationIntrospector 实现（通过扩展默认实现），该实现将使用 ThreadLocal 变量为当前请求选择筛选器，并创建一个提供该筛选器的自定义 FilterProvider。

2)将消息转换器的对象映射器配置为使用自定义内省器和过滤器提供程序

3）为REST服务创建一个MVC拦截器，该拦截器检测字段请求参数，并通过您的自定义过滤器提供程序为当前请求配置一个新过滤器（这应该是一个线程本地过滤器）。ObjectMapper应该通过您的自定义JacksonAnnotationINSPECTOR来获取它。

我不能100%确定这个解决方案是线程安全的(这取决于ObjectMapper如何在内部使用注释自省器和过滤器提供程序)。

-编辑-

好的，我做了一个测试实现，发现步骤1)行不通，因为Jackson缓存了每个类的AnnotationInterceptor的结果。我修改了idea，只对带注释的控制器方法应用动态过滤，并且只在对象没有定义其他JsonFilter的情况下。

以下是解决方案(相当冗长):

DynamicRequest estJsonFilterSupport类管理要过滤掉的每个请求字段：

public class DynamicRequestJsonFilterSupport {

    public static final String DYNAMIC_FILTER_ID = "___DYNAMIC_FILTER";

    private ThreadLocal<Set<String>> filterFields;
    private DynamicIntrospector dynamicIntrospector;
    private DynamicFilterProvider dynamicFilterProvider;

    public DynamicRequestJsonFilterSupport() {
        filterFields = new ThreadLocal<Set<String>>();
        dynamicFilterProvider = new DynamicFilterProvider(filterFields);
        dynamicIntrospector = new DynamicIntrospector();
    }

    public FilterProvider getFilterProvider() {
        return dynamicFilterProvider;
    }

    public AnnotationIntrospector getAnnotationIntrospector() {
        return dynamicIntrospector;
    }

    public void setFilterFields(Set<String> fieldsToFilter) {
        filterFields.set(Collections.unmodifiableSet(new HashSet<String>(fieldsToFilter)));
    }

    public void setFilterFields(String... fieldsToFilter) {
        filterFields.set(Collections.unmodifiableSet(new HashSet<String>(Arrays.asList(fieldsToFilter))));
    }

    public void clear() {
        filterFields.remove();
    }

    public static class DynamicIntrospector extends JacksonAnnotationIntrospector {


        @Override
        public Object findFilterId(Annotated annotated) {
            Object result = super.findFilterId(annotated);
            if (result != null) {
                return result;
            } else {
                return DYNAMIC_FILTER_ID;
            }
        }
    }

    public static class DynamicFilterProvider extends FilterProvider {

        private ThreadLocal<Set<String>> filterFields;

        public DynamicFilterProvider(ThreadLocal<Set<String>> filterFields) {
            this.filterFields = filterFields;
        }

        @Override
        public BeanPropertyFilter findFilter(Object filterId) {
            return null;
        }

        @Override
        public PropertyFilter findPropertyFilter(Object filterId, Object valueToFilter) {
            if (filterId.equals(DYNAMIC_FILTER_ID) && filterFields.get() != null) {
                return SimpleBeanPropertyFilter.filterOutAllExcept(filterFields.get());
            }
            return super.findPropertyFilter(filterId, valueToFilter);
        }
    }
}

JsonFilterInterceptor拦截使用自定义@响应过滤器注释注释的控制器方法。

public class JsonFilterInterceptor implements HandlerInterceptor {

    @Autowired
    private DynamicRequestJsonFilterSupport filterSupport;
    private ThreadLocal<Boolean> requiresReset = new ThreadLocal<Boolean>();

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            HandlerMethod method = (HandlerMethod) handler;
            ResponseFilter filter = method.getMethodAnnotation(ResponseFilter.class);
            String[] value = filter.value();
            String param = filter.param();
            if (value != null && value.length > 0) {
                filterSupport.setFilterFields(value);
                requiresReset.set(true);
            } else if (param != null && param.length() > 0) {
                String filterParamValue = request.getParameter(param);
                if (filterParamValue != null) {
                    filterSupport.setFilterFields(filterParamValue.split(","));
                }
            }
        }
        requiresReset.remove();
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        Boolean reset = requiresReset.get();
        if (reset != null && reset) {
            filterSupport.clear();
        }
    }
}

这是自定义的@ResponseFilter注释。您可以定义静态筛选器（通过注释的值属性）或基于请求参数的筛选器（通过批注的参数属性）：

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ResponseFilter {
    String[] value() default {};
    String param() default "";
}

您需要在 config 类中设置消息转换器和拦截器：

...
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    converters.add(converter());
}

@Bean
JsonFilterInterceptor jsonFilterInterceptor() {
    return new JsonFilterInterceptor();
}

@Override
public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(jsonFilterInterceptor);
}

@Bean
DynamicRequestJsonFilterSupport filterSupport() {
    return new DynamicRequestJsonFilterSupport();
}

@Bean
MappingJackson2HttpMessageConverter converter() {
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    ObjectMapper mapper = new ObjectMapper();
    mapper.setAnnotationIntrospector(filterSupport.getAnnotationIntrospector());
    mapper.setFilters(filterSupport.getFilterProvider());
    converter.setObjectMapper(mapper);
    return converter;
}
...

最后，您可以像这样使用过滤器:

@RequestMapping("/{id}")
@ResponseFilter(param = "fields")
public Invoice getInvoice(@PathVariable("id") Long id) { ... }

何时向/invoices/1提出请求？fields=id，数字响应将被过滤，只返回id和数字属性。

请注意，我还没有彻底测试这个，但它应该让你开始。

夏弘义

2023-03-14

依我看，最简单的方法是使用自省来动态生成包含所选字段的散列，然后使用Json序列化该散列。您只需决定什么是可用字段列表(见下文)。

这里有两个示例函数能够做到这一点，第一个函数获取所有公共字段和公共getter，第二个函数获取当前类及其所有父类中的所有声明字段（包括私有字段）：

public Map<String, Object> getPublicMap(Object obj, List<String> names)
        throws IllegalAccessException, IllegalArgumentException, InvocationTargetException  {
    List<String> gettedFields = new ArrayList<String>();
    Map<String, Object> values = new HashMap<String, Object>();
    for (Method getter: obj.getClass().getMethods()) {
        if (getter.getName().startsWith("get") && (getter.getName().length > 3)) {
            String name0 = getter.getName().substring(3);
            String name = name0.substring(0, 1).toLowerCase().concat(name0.substring(1));
            gettedFields.add(name);
            if ((names == null) || names.isEmpty() || names.contains(name)) {
                values.put(name, getter.invoke(obj));
            }
        }
    }
    for (Field field: obj.getClass().getFields()) {
        String name = field.getName();
        if ((! gettedFields.contains(name)) && ((names == null) || names.isEmpty() || names.contains(name))) {
            values.put(name, field.get(obj));
        }
    }
    return values;
}

public Map<String, Object> getFieldMap(Object obj, List<String> names)
        throws IllegalArgumentException, IllegalAccessException  {
    Map<String, Object> values = new HashMap<String, Object>();
    for (Class<?> clazz = obj.getClass(); clazz != Object.class; clazz = clazz.getSuperclass()) {
        for (Field field : clazz.getDeclaredFields()) {
            String name = field.getName();
            if ((names == null) || names.isEmpty() || names.contains(name)) {
                field.setAccessible(true);
                values.put(name, field.get(obj));
            }
        }
    }
    return values;
}

然后你只需要得到这个函数中的一个（或者你可以适应你的需求的一个）的结果，并用杰克逊序列化它。

如果您对域对象进行自定义编码，则必须在两个不同的地方维护序列化规则：哈希生成和Jackson序列化。在这种情况下，您可以简单地使用Jackson生成完整的类序列化，然后过滤生成的字符串。这是这样一个过滤器函数的示例：

public String jsonSub(String json, List<String> names) throws IOException {
    if ((names == null) || names.isEmpty()) {
        return json;
    }
    ObjectMapper mapper = new ObjectMapper();
    Map<String, Object> map = mapper.readValue(json, HashMap.class);
    for (String name: map.keySet()) {
        if (! names.contains(name)) {
            map.remove(name);
        }
    }
    return mapper.writeValueAsString(map);
}

编辑：在SpringMVC中的集成

当您谈到web服务和Jackson时，我假设您使用Spring＜code＞RestController映射JacksonHttpMessageConverter。

我建议的只是添加一个新的HttpMessageConverter，它可以使用上述过滤功能之一，并将实际工作（以及辅助方法）委托给真正的MappingJackson2HttpMessageConverter。在该新转换器的写方法中，由于SpringRequest ContextHolder，可以访问最终的字段请求参数，而无需显式的ThreadLocal变量。这样：

您保持明确的角色分离，而不对现有控制器进行修改
您在Jackson2配置中没有修改
您不需要新的ThreadLocal变量，只需在已经绑定到Spring的类中使用Spring类，因为它实现了HttpMessageConverter

以下是此类消息转换器的示例：

public class JsonConverter implements HttpMessageConverter<Object> {

    private static final Logger logger = LoggerFactory.getLogger(JsonConverter.class);
    // a real message converter that will respond to ancilliary methods and do the actual work
    private HttpMessageConverter<Object> delegate =
            new MappingJackson2HttpMessageConverter();

    // allow configuration of the fields name
    private String fieldsParam = "fields";

    public void setFieldsParam(String fieldsParam) {
        this.fieldsParam = fieldsParam;
    }

    @Override
    public boolean canRead(Class<?> clazz, MediaType mediaType) {
        return delegate.canRead(clazz, mediaType);
    }

    @Override
    public boolean canWrite(Class<?> clazz, MediaType mediaType) {
        return delegate.canWrite(clazz, mediaType);
    }

    @Override
    public List<MediaType> getSupportedMediaTypes() {
        return delegate.getSupportedMediaTypes();
    }

    @Override
    public Object read(Class<? extends Object> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
        return delegate.read(clazz, inputMessage);
    }

    @Override
    public void write(Object t, MediaType contentType, HttpOutputMessage outputMessage)
            throws IOException, HttpMessageNotWritableException {
        // is there a fields parameter in request
        String[] fields = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
                .getRequest().getParameterValues(fieldsParam);
        if (fields != null && fields.length != 0) {
            // get required field names
            List<String> names = new ArrayList<String>();
            for (String field : fields) {
                String[] f_names = field.split("\\s*,\\s*");
                names.addAll(Arrays.asList(f_names));
            }
            // special management for Map ...
            if (t instanceof Map) {
                Map<?, ?> tmap = (Map<?, ?>) t;
                Map<String, Object> map = new LinkedHashMap<String, Object>();
                for (Entry entry : tmap.entrySet()) {
                    String name = entry.getKey().toString();
                    if (names.contains(name)) {
                        map.put(name, entry.getValue());
                    }
                }
                t = map;
            } else {
                try {
                    Map<String, Object> map = getMap(t, names);
                    t = map;
                } catch (Exception ex) {
                    throw new HttpMessageNotWritableException("Error in field extraction", ex);
                }
            }
        }
        delegate.write(t, contentType, outputMessage);
    }

    /**
     * Create a Map by keeping only some fields of an object
     * @param obj the Object
     * @param names names of the fields to keep in result Map
     * @return a map containing only requires fields and their value
     * @throws IllegalArgumentException
     * @throws IllegalAccessException 
     */
    public static Map<String, Object> getMap(Object obj, List<String> names)
            throws IllegalArgumentException, IllegalAccessException  {
        Map<String, Object> values = new HashMap<String, Object>();
        for (Class<?> clazz = obj.getClass(); clazz != Object.class; clazz = clazz.getSuperclass()) {
            for (Field field : clazz.getDeclaredFields()) {
                String name = field.getName();
                if (names.contains(name)) {
                    field.setAccessible(true);
                    values.put(name, field.get(obj));
                }
            }
        }
        return values;
    }    
}

如果您希望转换器更加通用，您可以定义一个接口

public interface FieldsFilter {
    Map<String, Object> getMap(Object obj, List<String> names)
            throws IllegalAccessException, IllegalArgumentException, InvocationTargetException;
}

并注入它的实现。

现在，您必须要求Spring MVC使用定制的消息控制器。

如果使用XML配置，只需在＜code＞中声明它

<mvc:annotation-driven  >
    <mvc:message-converters>
        <bean id="jsonConverter" class="org.example.JsonConverter"/>
    </mvc:message-converters>
</mvc:annotation-driven>

如果您使用Java配置，它几乎一样简单：

@EnableWebMvc
@Configuration
public class WebConfig extends WebMvcConfigurerAdapter {

  @Autowired JsonConverter jsonConv;

  @Override
  public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    converters.add(jsonConv);
    StringHttpMessageConverter stringConverter = new StringHttpMessageConverter();
    stringConverter.setWriteAcceptCharset(false);

    converters.add(new ByteArrayHttpMessageConverter());
    converters.add(stringConverter);
    converters.add(new ResourceHttpMessageConverter());
    converters.add(new SourceHttpMessageConverter<Source>());
    converters.add(new AllEncompassingFormHttpMessageConverter());
    converters.add(new MappingJackson2HttpMessageConverter());
  }
}

但在这里，您必须明确地添加所需的所有默认消息转换器。

景书

2023-03-14

从Spring 4.2开始，MappingJacksonValue支持@JsonFilter

问题：SPR-12586：支持Jackson@JsonFilter
提交：ca06582

您可以在控制器中直接将Property tyFilter注入MappingJacksonValue。

@RestController
public class BookController {
    private static final String INCLUSION_FILTER = "inclusion";

    @RequestMapping("/novels")
    public MappingJacksonValue novel(String[] include) {
        @JsonFilter(INCLUSION_FILTER)
        class Novel extends Book {}

        Novel novel = new Novel();
        novel.setId(3);
        novel.setTitle("Last summer");
        novel.setAuthor("M.K");

        MappingJacksonValue res = new MappingJacksonValue(novel);
        PropertyFilter filter = SimpleBeanPropertyFilter.filterOutAllExcept(include);
        FilterProvider provider = new SimpleFilterProvider().addFilter(INCLUSION_FILTER, filter);
        res.setFilters(provider);
        return res;
    }

或者你可以通过ResponseBodyAdvice来宣布全球政策。以下示例通过“exclude”参数实现过滤策略。

@ControllerAdvice
public class DynamicJsonResponseAdvice extends AbstractMappingJacksonResponseBodyAdvice {
    public static final String EXCLUDE_FILTER_ID = "dynamicExclude";
    private static final String WEB_PARAM_NAME = "exclude";
    private static final String DELI = ",";
    private static final String[] EMPTY = new String[]{};

    @Override
    protected void beforeBodyWriteInternal(MappingJacksonValue container, MediaType contentType,
            MethodParameter returnType, ServerHttpRequest req, ServerHttpResponse res) {
        if (container.getFilters() != null ) {
            // It will be better to merge FilterProvider
            // If 'SimpleFilterProvider.addAll(FilterProvider)' is provided in Jackson, it will be easier.
            // But it isn't supported yet. 
            return;
        }

        HttpServletRequest baseReq = ((ServletServerHttpRequest) req).getServletRequest();
        String exclusion = baseReq.getParameter(WEB_PARAM_NAME);

        String[] attrs = StringUtils.split(exclusion, DELI);
        container.setFilters(configFilters(attrs));
    }

    private FilterProvider configFilters(String[] attrs) {
        String[] ignored = (attrs == null) ? EMPTY : attrs;
        PropertyFilter filter = SimpleBeanPropertyFilter.serializeAllExcept(ignored);
        return new SimpleFilterProvider().addFilter(EXCLUDE_FILTER_ID, filter);
    }
}

类似资料：

JSON：仅序列化为对象显式设置的字段

我有一个Java对象，我想序列化为JSON。但是，在此之前，我为该对象的字段设置了一些属性。现在我想将这个对象序列化为JSON。如何仅序列化显式赋值的字段，而基本上排除所有其他字段？对我来说，在对象类上添加这些注释是不起作用的：和。原因是我有一些基本数据类型的字段。通过添加上述两个注释之一，我并没有阻止原始数据类型字段被序列化。例如，我有几个布尔字段，它们将被序列化为默认值。但是，我不希望这些字
对象序列化为json，仅限于某些字段

我有一个大的嵌套对象。我想在JSON字符串中序列化这个对象，但是我只需要包含某些字段。这里的问题是字段可能会非常频繁地更改，我希望以一种可以帮助我轻松包含或排除用于序列化的字段的方式来构建它。我知道我可以编写很多代码来提取某些字段并“手动”构建JSON。但我想知道，除了指定一个必填字段列表之外，是否还有其他优雅的方法可以实现类似的结果？例如，我希望在响应中只包含和以下对象结构： Json：
Jackson：仅序列化标记的字段

问题内容：我正在尝试做一些在gson中非常容易的事情。由于我改用Jackson作为序列化程序，所以我不知道如何实现此目的：我只想序列化已由注释标记的字段。GSON代码为：这应该导致（JSON）（语法错误可能会被忽略-来源仅用于演示）那么，杰克逊（Gson’s）和杰克逊（Json）的对应对象是什么？问题答案：似乎有一种方法可以配置为忽略所有非注释字段。资源
gson将字段反序列化为null

首先，我想说这是一个大学项目。我有三节课<代码>订单抽象类和从订单继承的和类。我使用Gson序列化/反序列化子类，但我遇到了一点问题。订单类有一个字段，gson使用该字段来确定订单类型，DineIn或Delivery。序列化工作得很好。问题是，每当我尝试反序列化时，类型字段值都不会读取，并且总是设置为null，即使它存在于JSON文件中。当有很多字段时，就会发生这种情况，因为当我尝试在较小的
将列表序列化为JSON

问题内容：我正在客户端和Django服务器之间发送信息，并且我想对此使用JSON。我正在发送简单的信息-字符串列表。我尝试使用，但是当我这样做时，看来这只能用于Django对象。如何序列化简单的Python对象？问题答案：你可以使用纯Python执行此操作：
无字段名的Jackson JSON序列化

我希望获得以下输出：（我所要做的就是删除字段名，但保留其子字段名。）以下是我的POJO，由使用：下面是MAP在搜索过程中使用的我的: null 是否有一种方法可以使它与和一起使用，因为我不能同时使用这两种方法。有人能帮忙解决这个问题吗？请指导我适当的文档或变通方法，非常感谢。

将Spring MVC中仅提及的字段序列化为JSON响应

共有3个答案

相关问答

相关文章

相关阅读

相关工具

相关文档