2. 程式人生 > 其它 >API介面使用Jackson序列化JSON資料動態過濾欄位

API介面使用Jackson序列化JSON資料動態過濾欄位

阿新 • • 發佈：2021-01-06

技術標籤：經驗分享Java後端SpringBootjavaspringbootjacksonjsonapi欄位過濾

背景

編寫API介面過程中，不可避免的會遇到一個問題，對於不同的介面，需要的欄位不一樣，但大多數情況下，使用的Service層方法是相同的，也就是說，獲取到的資料欄位是一樣的，但是往往不需要返回所有的欄位。

解決方案

常用的解決思路有兩種，一種是針對每個介面定義VO類，在資料返回時，將Service層查到的資料複製到VO類後再返回，這樣的話就可以返回需要的欄位，但這樣也有缺點，不同的介面，需要定義專屬的VO類，這樣會使類的數量增多，後期如果需要新增一個通用欄位，那麼需要在每個VO

類都新增欄位，否則無法返回，後期維護工作量大，不好維護，其次是效能問題，資料返回到瀏覽器之前，都需要將資料複製到VO類，這樣會產生許多的中間例項，影響效能；

第二種方案，在資料序列化為JSON字串的時候，只序列化需要返回的欄位，這種方法相對第一種方法，可以很好的避免第一種方法出現的缺點，對於Jackson原生的註解，無法實現動態過濾需求，如果把註解加在實體欄位上，無法實現動態過濾，於是有了改進方案，自定義註解，通過自定義註解獲取需要返回或需要過濾的欄位，在序列化時處理。

程式碼實現

自定義註解

為了實現多註解，我們定義兩個註解來實現，多註解可實現巢狀物件的欄位過濾。

package com.
 
jeeplus.common.annotation;

import java.lang.annotation.*;

/**
 * JSON 返回欄位過濾
 *
 * @author zhufeihong
 * @since 2020/12/28 14:32
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(JsonFieldFilters.class)
public @interface JsonFieldFilter {

    /**
     * 物件類
     */
    Class<
 
?> type();

    /**
     * 只包含的欄位
     */
    String[] include() default {};

    /**
     * 不包含的欄位，如果重新賦值那麼預設值失效
     */
    String[] exclude() default {"createBy", "updateBy"};

    /**
     * 不包含的欄位，在exclude()預設值的條件下繼續新增排除欄位
     */
    String[] addExclude() default {};
}

package com.jeeplus.common.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * JSON 返回欄位過濾
 *
 * @author zhufeihong
 * @since 2020/12/28 14:32
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface JsonFieldFilters {

    JsonFieldFilter[] value();
}

自定義JSON過濾器

由於Jackson自帶的過濾器com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter不能滿足需求，需要自定義過濾器，用於序列化時動態過濾。

package com.jeeplus.config.handler;

import com.fasterxml.jackson.annotation.JsonFilter;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.BeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.FilterProvider;
import com.fasterxml.jackson.databind.ser.PropertyFilter;
import com.fasterxml.jackson.databind.ser.PropertyWriter;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;

import java.util.*;

/**
 * 自定義JSON序列化過濾器
 *
 * @author zhufeihong
 * @since 2021/1/4 16:30
 */
@JsonFilter("JacksonJsonFilter")
public class SuberJacksonFilterProvider extends FilterProvider {

    /**
     * 包含欄位 Map
     */
    Map<Class<?>, Set<String>> includeMap = new HashMap<>();

    /**
     * 排除欄位 Map
     */
    Map<Class<?>, Set<String>> excludeMap = new HashMap<>();

    /**
     * 新增包含欄位
     *
     * @param type   欄位所屬類
     * @param fields 欄位名陣列
     * @since 2021/1/4 17:03
     */
    public void include(Class<?> type, String... fields) {
        addToMap(includeMap, type, fields);
    }

    /**
     * 新增排除欄位
     *
     * @param type   欄位所屬類
     * @param fields 欄位名陣列
     * @since 2021/1/4 17:03
     */
    public void exclude(Class<?> type, String... fields) {
        addToMap(excludeMap, type, fields);
    }

    /**
     * 實際執行新增包含/排除欄位進對應Map的方法
     *
     * @param map    包含欄位Map OR 排除欄位Map
     * @param type   欄位所屬類
     * @param fields 欄位名稱陣列
     * @since 2021/1/4 17:04
     */
    private void addToMap(Map<Class<?>, Set<String>> map, Class<?> type, String... fields) {
        Set<String> fieldSet = map.getOrDefault(type, new HashSet<>());
        fieldSet.addAll(Arrays.asList(fields));
        map.put(type, fieldSet);
    }

    @Deprecated
    @Override
    public BeanPropertyFilter findFilter(Object filterId) {
        throw new UnsupportedOperationException("Access to deprecated filters not supported");
    }

    @Override
    public PropertyFilter findPropertyFilter(Object filterId, Object valueToFilter) {
        return new SimpleBeanPropertyFilter() {
            @Override
            public void serializeAsField(Object pojo, JsonGenerator jgen, SerializerProvider prov, PropertyWriter writer)
                    throws Exception {
                if (apply(pojo.getClass(), writer.getName())) {
                    writer.serializeAsField(pojo, jgen, prov);
                } else if (!jgen.canOmitFields()) {
                    writer.serializeAsOmittedField(pojo, jgen, prov);
                }
            }
        };
    }

    /**
     * 判斷是否序列化當前欄位，在includeMap或不在excludeMap中的欄位進行序列化
     *
     * @param type 欄位所屬類
     * @param name 欄位名稱
     * @return boolean 是否序列化
     * @since 2021/1/4 17:09
     */
    public boolean apply(Class<?> type, String name) {
        Set<String> includeFields = includeMap.get(type);
        Set<String> excludeFields = excludeMap.get(type);
        if (includeFields != null && includeFields.contains(name)) {
            return true;
        } else if (excludeFields != null && !excludeFields.contains(name)) {
            return true;
        } else {
            return includeFields == null && excludeFields == null;
        }
    }
}

自定義JSON序列化方法

我們自定義了過濾器，要想實現欄位過濾，需要自定義序列化方法。

package com.jeeplus.core.mapper;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.google.common.collect.ObjectArrays;
import com.jeeplus.common.annotation.JsonFieldFilter;
import com.jeeplus.common.annotation.JsonFieldFilters;
import com.jeeplus.config.handler.SuberJacksonFilterProvider;

/**
 * JSON 序列化，用於API返回欄位過濾
 *
 * @author zhufeihong
 * @since 2020/12/28 15:11
 */
public class ResponseJsonFilterSerializer {

    // JsonMapper 繼承自com.fasterxml.jackson.databind.ObjectMapper
    JsonMapper mapper = JsonMapper.getInstance();
    SuberJacksonFilterProvider filterProvider = new SuberJacksonFilterProvider();

    /**
     * json資料返回時過濾欄位
     *
     * @param clazz   需要設定規則的Class
     * @param include 轉換時包含哪些欄位
     * @param exclude 轉換時過濾哪些欄位
     */
    public void filter(Class<?> clazz, String[] include, String[] exclude) {
        if (clazz == null) {
            return;
        }
        if (include != null && include.length > 0) {
            filterProvider.include(clazz, include);
        } else if (exclude != null && exclude.length > 0) {
            filterProvider.exclude(clazz, exclude);
        }
        mapper.addMixIn(clazz, filterProvider.getClass());
    }

    /**
     * json資料返回時過濾欄位
     *
     * @param fieldFilters 註解陣列進行過濾
     * @since 2021/1/4 17:26
     */
    public void filter(JsonFieldFilters fieldFilters) {
        for (JsonFieldFilter json : fieldFilters.value()) {
            this.filter(json.type(), json.include(),
                    ObjectArrays.concat(json.exclude(), json.addExclude(), String.class));
        }
    }

    public String toJson(Object object) throws JsonProcessingException {
        mapper.setFilterProvider(filterProvider);
        return mapper.toJson(object);
    }
}

ResponseJson處理器定義

以上準備就緒，我們需要定義一個處理器，用來呼叫我們的自定義序列化方法實現動態過濾欄位。

package com.jeeplus.config.handler;

import com.google.common.collect.ObjectArrays;
import com.jeeplus.common.annotation.JsonFieldFilter;
import com.jeeplus.common.annotation.JsonFieldFilters;
import com.jeeplus.core.mapper.ResponseJsonFilterSerializer;
import org.springframework.core.MethodParameter;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.http.MediaType;
import org.springframework.lang.Nullable;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodReturnValueHandler;
import org.springframework.web.method.support.ModelAndViewContainer;

import javax.servlet.http.HttpServletResponse;
import java.lang.annotation.Annotation;
import java.util.Arrays;
import java.util.Objects;

/**
 * JSON返回欄位過濾處理器
 *
 * @author zhufeihong
 * @since 2020/12/28 14:52
 */
public class JsonReturnFilterHandler implements HandlerMethodReturnValueHandler {

    @Override
    public boolean supportsReturnType(MethodParameter returnType) {
        // 如果有自定義的 @JsonFieldFilter 註解 就用我們這個Handler 來處理
        return AnnotatedElementUtils.hasAnnotation(returnType.getContainingClass(), JsonFieldFilters.class)
                || returnType.hasMethodAnnotation(JsonFieldFilters.class)
                || AnnotatedElementUtils.hasAnnotation(returnType.getContainingClass(), JsonFieldFilter.class)
                || returnType.hasMethodAnnotation(JsonFieldFilter.class);
    }

    @Override
    public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
                                  ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
        // 設定這個就是最終的處理類了，處理完不再去找下一個類進行處理
        mavContainer.setRequestHandled(true);

        // 獲得註解並執行filter方法 最後返回
        HttpServletResponse response = webRequest.getNativeResponse(HttpServletResponse.class);
        Annotation[] annotations = returnType.getMethodAnnotations();
        ResponseJsonFilterSerializer jsonFilterSerializer = new ResponseJsonFilterSerializer();
        Arrays.asList(annotations).forEach(a -> {
            if (a instanceof JsonFieldFilter) {
                JsonFieldFilter json = (JsonFieldFilter) a;
                jsonFilterSerializer.filter(json.type(), json.include(),
                        ObjectArrays.concat(json.exclude(), json.addExclude(), String.class));
            } else if (a instanceof JsonFieldFilters) {
                jsonFilterSerializer.filter((JsonFieldFilters) a);
            }
        });

        Objects.requireNonNull(response).setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);
        String json = jsonFilterSerializer.toJson(returnValue);
        response.getWriter().write(json);
    }
}

註冊處理器物件

處理器定義好了，我們需要註冊它，才能使用，在Spring Boot專案中，對於API介面返回的JSON資料，交由org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor處理後返回，我們需要在這個處理器前新增我們的自定義處理器，才能實現欄位過濾，否則進行到這個過濾器後，就不會往下處理，直接返回資料了。

package com.jeeplus.config.handler;

import com.jeeplus.common.annotation.JsonFieldFilter;
import com.jeeplus.common.utils.collection.CollectionUtil;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.method.support.HandlerMethodReturnValueHandler;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
import org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor;

import java.util.ArrayList;
import java.util.List;

/**
 * 配置 HandlerMethodReturnValueHandler
 * 在此配置 API 介面返回的 JSON 欄位過濾處理器
 * 在處理器 {@link RequestResponseBodyMethodProcessor} 前新增 {@link JsonReturnFilterHandler}
 * 預設的返回值處理配置 {@link RequestMappingHandlerAdapter#getDefaultReturnValueHandlers()}
 *
 * @author zhufeihong
 * @see JsonFieldFilter
 * @since 2020/12/30 10:10
 */
@Configuration
public class InitializingRequestMappingHandler implements InitializingBean {

    @Autowired
    private RequestMappingHandlerAdapter adapter;

    @Override
    public void afterPropertiesSet() throws Exception {
        List<HandlerMethodReturnValueHandler> returnValueHandlers = adapter.getReturnValueHandlers();
        if (CollectionUtil.isEmpty(returnValueHandlers)) {
            return;
        }
        // 不能直接使用 returnValueHandlers集合，因為此集合被方法unmodifiableList設定為不可修改
        List<HandlerMethodReturnValueHandler> handlers = new ArrayList<>(returnValueHandlers);
        this.decorateHandlers(handlers);
        adapter.setReturnValueHandlers(handlers);
    }

    private void decorateHandlers(List<HandlerMethodReturnValueHandler> handlers) {
        for (int i = 0; i < handlers.size(); i++) {
            // 在RequestResponseBodyMethodProcessor前新增自定義json資料返回處理器，用於返回欄位過濾
            if (handlers.get(i) instanceof RequestResponseBodyMethodProcessor) {
                handlers.add(i, new JsonReturnFilterHandler());
                break;
            }
        }
    }
}

使用示例

在方法上使用註解，填寫只包含的欄位或需要排除的欄位，返回的JSON資料就可以實現動態過濾了，對於實體無侵入，不影響之前的方法。

/**
 * 分頁查詢建築物資訊
 *
 * @param queryParam 查詢引數
 * @param page       分頁引數
 * @return java.util.Map<java.lang.String, java.lang.Object>
 * @author zhufeihong
 * @date 2020/11/4 16:48
 */
@Api
@RequestMapping("/findPage")
@JsonFieldFilter(type = BuildLocation.class, include = {"createDate", "updateDate", "id"})
@JsonFieldFilter(type = Page.class, include = {"pageSize", "pageNo", "count", "list"})
public Map<String, Object> findPage(@RequestAttribute BuildLocation queryParam,
                                    @RequestAttribute Page<BuildLocation> page) {
    Page<BuildLocation> pageList;
    if (Strings.isBlank(queryParam.getAddressId())) {
        pageList = new Page<>();
    } else {
        pageList = buildLocationService.findPage(page, queryParam);
    }
    return super.success(pageList);
}

相關推薦

API介面使用Jackson序列化JSON資料動態過濾欄位

技術標籤：經驗分享Java後端SpringBootjavaspringbootjacksonjsonapi欄位過濾 背景 編寫API介面過程中，不可避免的會遇到一個問題，對於不同的介面，需要的欄位不一樣，但大多數情況下，使用的Service層方法是相

python 呼叫API介面 獲取和解析 Json資料

任務背景： 呼叫API介面資料，抽取我們所需型別的資料，並寫入指定mysql資料庫。

Java利用Jackson序列化實現資料脫敏

幾天前使用了Jackson對資料的自定義序列化。突發靈感，利用此方法來簡單實現介面返回資料脫敏，故寫此文記錄。

java web專案服務端返回json結果時過濾欄位為null的屬性

import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.databind.ObjectMapper;

com.fasterxml.jackson包序列化json物件和反序列化

需要序列化的類需實現介面： public class ResponseModel implements Serializable { 　　 序列化和反序列化程式碼例子：

C#序列化和反序列化 之 dynamic 動態Json的反序列化

序列化和反序列化的常識不再贅述，如果不清楚這個，可以 參考一下其他人寫的文章https://www.cnblogs.com/maitian-lf/p/3670570.html

含有動態未知欄位的 JSON 反序列化

一般來說，正常的 json 長這個模樣： { \'Name\': \'Bad Boys\', \'ReleaseDate\': \'1995-4-7T00:00:00\',

python序列化與資料持久化例項詳解

本文例項講述了python序列化與資料持久化。分享給大家供大家參考，具體如下：

在VUE中--匯出json檔案，前端請求介面返回一堆json資料，如何匯出成json檔案並且下載？？？

areaButton(){ //點選下載 outArea().then(res=>{ var data = JSON.stringify(res) //encodeURIComponent解決中文亂碼

SpringBoot---快取技術2（基於Redis註解和基於RedisTemplate的手動快取，包括將快取資料序列化成json資料，有原始碼）

基於註解的Redis快取實現 1、加入redis依賴 <dependency> <groupId>org.springframework.boot</groupId>

jackson序列化與反序列化的應用實踐

jackson序列化與反序列化的應用實踐 原始碼地址: https://github.com/zhouweixin/serializable

jackson序列化和反序列化的應用實踐指南

原始碼地址:https://github.com/zhouweixin/serializable 1 相關概念 序列化: 把物件轉換為位元組序列的過程稱為物件的序列化

Jackson序列化和反序列化忽略欄位操作

一、設定Jackson序列化時只包含不為空的欄位 new ObjectMapper().setSerializationInclusion(Include.NON_NULL);

springboot專案中jackson-序列化-處理 NULL教程

在專案中有事需要對值為NULL的物件中Field不做序列化輸入配置方式如下： [配置型別]：

C# 遠端RPC呼叫 CS架構設計 遠端API介面 RPC視覺化 MqttRpc實現 HslCommunication遠端呼叫，同步網路訪問，進度報告

今天來說說C#的遠端RPC呼叫，當然其實不止是限於C#，這個RPC對JAVA，Python都是支援的，好了，進入主題

springboot中的resttemplate使用了jackson序列化遇到的坑

spring.jackson.time-zone=GMT+8 spring.jackson.date-format=yyyy-MM-dd HH:mm:ss springboot之restTemplate學習

spring-mvc介面返回json格式資料Long型別欄位精度失真

問題 介面響應vo： @Data public class QueryProductListVo implements Serializable { private Long id;

JackSon序列化失敗問題

*** java.lang.instrument ASSERTION FAILED ***: \"!errorOutstanding\" with message transform method call failed at JPLISAgent.c line: 844

vue2.x搭建saas專案系列之七：API介面及常量、基礎資料統一維護

技術標籤：vue2.xvuesaas專案架構 此篇幅主要介紹、我們是如何做API介面及常量統一維護，如有不足和建議請留言，在此感謝，專案目前階段還處在少年，一直在迭代

react-diagram 序列化Json解讀案例分析

本文目標 本文件的目標在於解釋react-diagram框架模型序列化的json，由於缺乏文件，我這邊只能通過不斷嘗試和除錯來進行測試。