spring api接口返回数据优化 —— 只返回需要的字段数据

简介:

概述

spring/spring boot 返回的json数据,通常包含了对象所有的字段,有时候浪费流量。例如一个接口有10个字段,而前端只需要2个字段,都返回会浪费流量。
解决方案:前端在header中传递需要包含或需要排除的字段;后端在返回数据前进行统一拦截,只返回需要的字段。
具有有多种实现方式(这里只提供spring boot)。

首先约定返回的BaseResult对象格式如下,里面result属性就是实际各种数据对象。

{
    "ret":0,
    "msg":null,
    "result":{
        "id":1,
        "name":"后摄像头53"
    },
    "time":1540972430498
}

实现方式一:通过AOP controller来实现

aop实现步骤说明:

  • 判断返回的是不是BaseResult对象
  • 判断request header或params是否有x-include-fields、x-exclude-fields属性(有则取出来放入set中)
  • 满足以上条件则对BaseResult.result 对象进行处理,用Map替换result对象,Map只返回需要的字段。如果是Array或Collection则每个Item替换成一个Map。

import com.cehome.cloudbox.common.object.BaseResult;
import com.cehome.cloudbox.common.object.ItemsResult;
import com.cehome.cloudbox.common.object.PageResult;
import com.cehome.cloudbox.common.page.Page;
import com.cehomex.spring.feign.FeignRequestHolder;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.beans.PropertyDescriptor;
import java.util.*;

@Aspect
public class ControllerAOP {
    private static String INCLUDE_FIELDS = "x-include-fields";
    private static String EXCLUDE_FIELDS = "x-exclude-fields";
    private static String P_INCLUDE_FIELDS = "x-include-fields";
    private static String P_EXCLUDE_FIELDS = "x-exclude-fields";

    private static final Logger logger = LoggerFactory.getLogger(ControllerAOP.class);

    @Pointcut("within(@org.springframework.stereotype.Controller *)")
    public void controller() {
    }

    @Pointcut("within(@org.springframework.web.bind.annotation.RestController *)")
    public void restController() {
    }

    @Around("(controller() || restController()) && execution(public * *(..))")
    public Object proceed(ProceedingJoinPoint joinPoint) throws Throwable {

        try {

            Object object=joinPoint.proceed();
            ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder
                    .getRequestAttributes();
            if (requestAttributes != null) {
                HttpServletRequest request = requestAttributes.getRequest();
                handleReturnValue(object,request);
            }
            return object;
        } finally {

            FeignRequestHolder.removeAll();
        }


    }

    /**
     * 返回前端需要的字段
     * @param o
     * @param request
     * @throws Exception
     */
    public void handleReturnValue(Object o,HttpServletRequest request) throws Exception {
        if(!isSuccess(o)) return;

        //HttpServletRequest request = nativeWebRequest.getNativeRequest(HttpServletRequest.class);
        //HttpServletResponse response = nativeWebRequest.getNativeResponse(HttpServletResponse.class);
        String fields1 = StringUtils.trimToEmpty(request.getHeader(INCLUDE_FIELDS));
        if(fields1.length()==0) fields1 = StringUtils.trimToEmpty(request.getParameter(P_INCLUDE_FIELDS));
        String fields2 = StringUtils.trimToEmpty(request.getHeader(EXCLUDE_FIELDS));
        if(fields2.length()==0) fields2 = StringUtils.trimToEmpty(request.getParameter(P_EXCLUDE_FIELDS));
        if (fields1.length() > 0 || fields2.length() > 0) {
            Set<String> includes = fields1.length() == 0 ? new HashSet<>() : new HashSet<>(Arrays.asList(fields1.split(",")));
            Set<String> excludes = fields2.length() == 0 ? new HashSet<>() : new HashSet<>(Arrays.asList(fields2.split(",")));

            if (o instanceof BaseResult) {
                BaseResult result = (BaseResult) o;
                Object object = result.getResult();
                result.setResult(convertResult(object, includes, excludes));

            } else if (o instanceof ItemsResult) {
                ItemsResult result = (ItemsResult) o;
                Object object = result.getItems();
                result.setItems(convertResult(object, includes, excludes));

            } else if (o instanceof PageResult) {
                PageResult result = (PageResult) o;
                Object object = result.getPage();
                if (object instanceof Page) {
                    Page page=(Page) object;
                    List datas = page.getDatas();
                    page.setDatas((List)convertResult(datas, includes, excludes));

                }

            }

        }


    }

    private boolean isSuccess(Object object){
        if(object==null) return false;
        if (object instanceof BaseResult) return ( (BaseResult) object).isSuccess();
        if (object instanceof ItemsResult) return ( (ItemsResult) object).isSuccess();
        if (object instanceof PageResult) return ( (PageResult) object).isSuccess();
        return false;
    }
    /*private void handleObject(Object object, Set<String> includes, Set<String> excludes) throws Exception {

        PropertyDescriptor[] pds = PropertyUtils.getPropertyDescriptors(object);
        for (PropertyDescriptor pd : pds) {
            String name = pd.getName();
            if (name.equals("class")) {
                continue;
            }
            if (excludes.contains(name) || !includes.contains(name)) {
                PropertyUtils.setProperty(object, name, null);
            }
        }
    }*/

    /**
     * convert objects to maps
     * @param object
     * @param includes
     * @param excludes
     * @return
     * @throws Exception
     */
    private Object convertResult(Object object, Set<String> includes, Set<String> excludes) throws Exception{
        if (object instanceof Object[]) {
            Object[] objects = (Object[]) object;
            return convertArray(objects,includes,excludes);
        } else if (object instanceof Collection) {
            Collection collection = (Collection) object;
            return convertCollection(collection,includes,excludes);
        }else{
            return convertObject(object,includes,excludes);
        }
    }

    private Collection<Map> convertCollection(Collection collection, Set<String> includes, Set<String> excludes) throws Exception{
        Collection<Map> result=new ArrayList<>();
        for (Object item : collection) {
            result.add(convertObject(item,includes,excludes));
        }
        return result;
    }
    private Map[] convertArray(Object[] objects, Set<String> includes, Set<String> excludes)  throws Exception{
        Map[] result=new HashMap[objects.length];
        for(int i=0;i<objects.length;i++){
            result[i]=convertObject(objects[i],includes,excludes);
        }

        return result;
    }

    /**
     * convert object to map
     * @param object  input
     * @param includes  include props
     * @param excludes  exclude props
     * @return
     * @throws Exception
     */
    private Map convertObject(Object object, Set<String> includes, Set<String> excludes) throws Exception {

        Map<Object,Object> result=new HashMap<>();
        if(!(object instanceof Map)) {
            PropertyDescriptor[] pds = PropertyUtils.getPropertyDescriptors(object);
            for (PropertyDescriptor pd : pds) {
                String name = pd.getName();
                if (name.equals("class")) {
                    continue;
                }
                if(!excludes.isEmpty() && excludes.contains(name)){
                    continue;
                }
                if(!includes.isEmpty() && !includes.contains(name)){
                    continue;
                }
                result.put(name,PropertyUtils.getProperty(object, name));
            }
        }else {
            Map<Object,Object>  map=(Map<Object,Object>) object;

            for(Map.Entry<Object,Object>  entry :map.entrySet()){
                String name= entry.getKey()==null?"":entry.getKey().toString();
                if(!excludes.isEmpty() && excludes.contains(name)){
                    continue;
                }
                if(!includes.isEmpty() && !includes.contains(name)){
                    continue;
                }
                result.put(entry.getKey(),entry.getValue());

            }
        }

        return result;


    }



}

用Map替换的方式改变了原来的对象,还有一种效率更好的不改变对象的方式,
就是把不需要返回的字段设为null,然后配置一个JSON处理bean,统一过滤null的字段。这种方式null的字段就不再返回前端,需要前端做些兼容。

    @Bean
    @Primary
    @ConditionalOnMissingBean(ObjectMapper.class)
    public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
        ObjectMapper objectMapper = builder.createXmlMapper(false).build();
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        return objectMapper;
    }

实现方式二:自定义HttpMessageConverter来实现

spring boot缺省包含了好几个消息转换器,根据返回媒体类型进行匹配,第一个匹配上就忽略掉其它的了。
MappingJackson2HttpMessageConverter 是其处理JSON的消息转换器。

  • 所以,需要先删除缺省的MappingJackson2HttpMessageConverter
  • 继承MappingJackson2HttpMessageConverter,实现自定义的消息转换。


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;

import java.io.IOException;
import java.lang.reflect.Type;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.http.converter.json.MappingJacksonValue;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
@Configuration
public class WebConfig extends WebMvcConfigurerAdapter {


    @Override
    public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {

        //-- 移除缺省的JSON处理器
        for (int i = converters.size() - 1; i >= 0; i--) {
            HttpMessageConverter<?> messageConverter = converters.get(i);
            if (messageConverter instanceof org.springframework.http.converter.json.MappingJackson2HttpMessageConverter)
                converters.remove(i);
        }

        // --  添加自己得JSON处理器

        MappingJackson2HttpMessageConverter c = new MappingJackson2HttpMessageConverter() {
            @Override
            protected void writeInternal(Object object, Type type, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
                
                //-- 例子一: 转成fastjson对象,然后替换name字段
                JSONObject json = (JSONObject) JSON.toJSON(object);
                json.getJSONObject("result").put("name", "coolma");
                super.writeInternal(json, type, outputMessage);
               
                //-- 例子二: 用过滤器只保留name字段,其它字段不要。
                //注意,例子二需要给BaseResult对象的result属性加上com.fasterxml.jackson.annotation.JsonFilter注解:
                // @JsonFilter("result") 
                // private  T result;
                MappingJacksonValue value = new MappingJacksonValue(object);
                value.setFilters(new SimpleFilterProvider().addFilter("result",
                        SimpleBeanPropertyFilter.filterOutAllExcept("name")));
                super.writeInternal(value, type, outputMessage);
            }

        };
        c.setDefaultCharset(Charset.forName("UTF-8"));
        List<MediaType> mediaTypes = new ArrayList<>();
        mediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
        c.setSupportedMediaTypes(mediaTypes);
        converters.add(c);

    }
}
目录
相关文章
|
7天前
|
API PHP 开发者
速卖通商品详情接口(速卖通API系列)
速卖通(AliExpress)是阿里巴巴旗下的跨境电商平台,提供丰富的商品数据。通过速卖通开放平台(AliExpress Open API),开发者可获取商品详情、订单管理等数据。主要功能包括商品搜索、商品详情、订单管理和数据报告。商品详情接口aliexpress.affiliate.productdetail.get用于获取商品标题、价格、图片等详细信息。开发者需注册账号并创建应用以获取App Key和App Secret,使用PHP等语言调用API。该接口支持多种请求参数和返回字段,方便集成到各类电商应用中。
|
13天前
|
JSON API 数据格式
微店商品列表接口(微店 API 系列)
微店商品列表接口是微店API系列的一部分,帮助开发者获取店铺中的商品信息。首先需注册微店开发者账号并完成实名认证,选择合适的开发工具如PyCharm或VS Code,并确保熟悉HTTP协议和JSON格式。该接口支持GET/POST请求,主要参数包括店铺ID、页码、每页数量和商品状态等。响应数据为JSON格式,包含商品详细信息及状态码。Python示例代码展示了如何调用此接口。应用场景包括商品管理系统集成、数据分析、多平台数据同步及商品展示推广。
|
5天前
|
JSON 前端开发 API
以项目登录接口为例-大前端之开发postman请求接口带token的请求测试-前端开发必学之一-如果要学会联调接口而不是纯写静态前端页面-这个是必学-本文以优雅草蜻蜓Q系统API为实践来演示我们如何带token请求接口-优雅草卓伊凡
以项目登录接口为例-大前端之开发postman请求接口带token的请求测试-前端开发必学之一-如果要学会联调接口而不是纯写静态前端页面-这个是必学-本文以优雅草蜻蜓Q系统API为实践来演示我们如何带token请求接口-优雅草卓伊凡
29 5
以项目登录接口为例-大前端之开发postman请求接口带token的请求测试-前端开发必学之一-如果要学会联调接口而不是纯写静态前端页面-这个是必学-本文以优雅草蜻蜓Q系统API为实践来演示我们如何带token请求接口-优雅草卓伊凡
|
4天前
|
监控 供应链 搜索推荐
亚马逊商品详情接口(亚马逊 API 系列)
亚马逊作为全球最大的电商平台之一,提供了丰富的商品资源。开发者和电商从业者可通过亚马逊商品详情接口获取商品的描述、价格、评论、排名等数据,对市场分析、竞品研究、价格监控及业务优化具有重要价值。接口基于MWS服务,支持HTTP/HTTPS协议,需注册并获得API权限。Python示例展示了如何使用mws库调用接口获取商品详情。应用场景包括价格监控、市场调研、智能选品、用户推荐和库存管理等,助力电商运营和决策。
51 23
|
5天前
|
JSON 数据挖掘 API
lazada商品详情接口 (lazada API系列)
Lazada 是东南亚知名电商平台,提供海量商品资源。通过其商品详情接口,开发者和商家可获取商品标题、价格、库存、描述、图片、用户评价等详细信息,助力市场竞争分析、商品优化及库存管理。接口采用 HTTP GET 请求,返回 JSON 格式的响应数据,支持 Python 等语言调用。应用场景包括竞品分析、价格趋势研究、用户评价分析及电商应用开发,为企业决策和用户体验提升提供有力支持。
52 21
|
2天前
|
JSON API 数据格式
eBay商品详情接口(ebay API系列)
eBay 商品详情接口是电商从业者、开发者和数据分析师获取商品详细信息的重要工具,涵盖标题、价格、库存、卖家信息等。使用前需在 eBay 开发者平台注册并获取 API 凭证,通过 HTTP GET 请求调用接口,返回 JSON 格式数据。Python 示例代码展示了如何发送请求并解析响应,确保合法合规使用数据。
32 12
|
1天前
|
JSON API 数据格式
阿里巴巴商品详情接口(阿里巴巴 API 系列)
在电商开发中,获取阿里巴巴商品详情信息对数据分析、竞品研究等至关重要。通过调用其商品详情接口,开发者可获取标题、价格、图片、描述等数据,满足多种业务需求。接口采用HTTPS协议,支持GET/POST请求,返回JSON格式数据。示例代码展示了如何使用Python的requests库进行接口请求,需传递商品ID和访问令牌。实际应用时,请依据官方文档调整参数并确保安全性。
27 10
|
6天前
|
数据采集 JSON 监控
速卖通商品列表接口(以 AliExpress Affiliate 商品查询 API 为例)
以下是使用 Python 调用速卖通商品列表接口(以 AliExpress Affiliate 商品查询 API 为例)的代码示例。该示例包含准备基础参数、生成签名、发送请求和处理响应等关键步骤,并附有详细注释说明。代码展示了如何通过公共参数和业务参数构建请求,使用 HMAC-SHA256 加密生成签名,确保请求的安全性。最后,解析 JSON 响应并输出商品信息。此接口适用于商品监控、数据采集与分析及商品推荐等场景。注意需通过 OAuth2.0 获取 `access_token`,并根据官方文档调整参数和频率限制。
|
7天前
|
存储 搜索推荐 API
淘宝拍立淘按图搜索API接口系列概述
淘宝拍立淘按图搜索API接口允许用户通过上传图片或拍摄实物来搜索相似或相同的商品。这一功能主要依赖于图像识别技术,系统会对上传的图片进行分析和处理,提取出商品的特征信息,并在淘宝的商品数据库中进行匹配搜索,最终返回与上传图片相似或相同的商品列表。
|
18天前
|
存储 NoSQL Java
使用Java和Spring Data构建数据访问层
本文介绍了如何使用 Java 和 Spring Data 构建数据访问层的完整过程。通过创建实体类、存储库接口、服务类和控制器类,实现了对数据库的基本操作。这种方法不仅简化了数据访问层的开发,还提高了代码的可维护性和可读性。通过合理使用 Spring Data 提供的功能,可以大幅提升开发效率。
61 21