springboot 中 inputStream 神秘消失之谜(终破)

序言

最近小明接手了前同事的代码，意料之外、情理之中的遇到了坑。

为了避免掉入同一个坑两次，小明决定把这个坑记下来，并在坑前立一个大牌子，避免其他小伙伴掉进去。

httpclient 模拟调用

为了把这个问题说明，我们首先从最简单的 http 调用说起。

设置 body

服务端

服务端的代码如下：

@controller
@requestmapping("/")
public class reqcontroller {

    @postmapping(value = "/body")
    @responsebody
    public string body(httpservletrequest httpservletrequest) {
        try {
            string body = streamutil.tostring(httpservletrequest.getinputstream());
            system.out.println("请求的 body: " + body);

            // 从参数中获取
            return body;
        } catch (ioexception e) {
            e.printstacktrace();
            return e.getmessage();
        }
    }

}

java 客户端要如何请求才能让服务端读取到传递的 body 呢？

客户端

这个问题一定难不到你，实现的方式有很多种。

我们以 apache httpclient 为例：

//post请求，带集合参数
public static string post(string url, string body) {
    try {
        // 通过httppost来发送post请求
        httppost httppost = new httppost(url);
        stringentity stringentity = new stringentity(body);
        // 通过setentity 将我们的entity对象传递过去
        httppost.setentity(stringentity);
        return execute(httppost);
    } catch (unsupportedencodingexception e) {
        throw new runtimeexception(e);
    }
}

//执行请求返回响应数据
private static string execute(httprequestbase http) {
    try {
        closeablehttpclient client = httpclients.createdefault();
        // 通过client调用execute方法
        closeablehttpresponse response = client.execute(http);
        //获取响应数据
        httpentity entity = response.getentity();
        //将数据转换成字符串
        string str = entityutils.tostring(entity, "utf-8");
        //关闭
        response.close();
        return str;
    } catch (ioexception e) {
        throw new runtimeexception(e);
    }
}

可以发现 httpclient 封装之后还是非常方便的。

我们设置 setentity 为对应入参的 stringentity 即可。

测试

为了验证正确性，小明本地实现了一个验证方法。

@test
public void bodytest() {
    string url = "http://localhost:8080/body";
    string body = buildbody();
    string result = httpclientutils.post(url, body);

    assert.assertequals("body", result);
}

private string buildbody() {
    return "body";
}

很轻松，小明漏出了龙王的微笑。

设置 parameter

服务端

小明又看到有一个服务端的代码实现如下：

@postmapping(value = "/param")
@responsebody
public string param(httpservletrequest httpservletrequest) {
    // 从参数中获取
    string param = httpservletrequest.getparameter("id");
    system.out.println("param: " + param);
    return param;
}

private map<string,string> buildparammap() {
    map<string,string> map = new hashmap<>();
    map.put("id", "123456");

    return map;
}

所有的参数是通过 getparameter 方法获取，应该如何实现呢？

客户端

这个倒也不难，小明心想。

因为以前很多代码都是这样实现的，于是 ctrl+cv 搞定了下面的代码：

//post请求，带集合参数
public static string post(string url, map<string, string> parammap) {
    list<namevaluepair> namevaluepairs = new arraylist<>();
    for (map.entry<string, string> entry : parammap.entryset()) {
        namevaluepair pair = new basicnamevaluepair(entry.getkey(), entry.getvalue());
        namevaluepairs.add(pair);
    }
    return post(url, namevaluepairs);
}

//post请求，带集合参数
private static string post(string url, list<namevaluepair> list) {
    try {
        // 通过httppost来发送post请求
        httppost httppost = new httppost(url);
        // 我们发现entity是一个接口，所以只能找实现类，发现实现类又需要一个集合，集合的泛型是namevaluepair类型
        urlencodedformentity formentity = new urlencodedformentity(list);
        // 通过setentity 将我们的entity对象传递过去
        httppost.setentity(formentity);
        return execute(httppost);
    } catch (exception exception) {
        throw new runtimeexception(exception);
    }
}

如此是最常用的 parammap，便于构建；和具体的实现方式脱离，也便于后期拓展。

servlet 标准

urlencodedformentity 看似平平无奇，表示这是一个 post 表单请求。

里面还涉及到 servlet 3.1 的一个标准，必须满足下面的标准，post 表单的 parameter 集合才可用。

1. 请求是 http 或 https

2. 请求的方法是 post

3. content type 为： application/x-www-form-urlencoded

4. servlet 已经在 request 对象上调用了相关的 getparameter 方法。

当以上条件不满足时，post 表单的数据并不会设置到 parameter 集合中，但依然可以通过 request 对象的 inputstream 来获取。

当以上条件满足时，post 表单的数据在 request 对象的 inputstream 将不再可用了。

这是很重要的一个约定，导致很多小伙伴比较蒙圈。

测试

于是，小明也写好了对应的测试用例：

@test
public void paramtest() {
    string url = "http://localhost:8080/param";

    map<string,string> map = buildparammap();
    string result = httpclientutils.post(url, map);

    assert.assertequals("123456", result);
}

如果谈恋爱能像编程一样，那该多好。

小明想着，却不由得眉头一皱，发现事情并不简单。

设置 parameter 和 body

服务端

有一个请求的入参是比较大，所以放在 body 中，其他参数依然放在 paramter 中。

@postmapping(value = "/paramandbody")
@responsebody
public string paramandbody(httpservletrequest httpservletrequest) {
    try {
        // 从参数中获取
        string param = httpservletrequest.getparameter("id");
        system.out.println("param: " + param);
        string body = streamutil.tostring(httpservletrequest.getinputstream());
        system.out.println("请求的 body: " + body);
        // 从参数中获取
        return param+"-"+body;
    } catch (ioexception e) {
        e.printstacktrace();
        return e.getmessage();
    }
}

其中 streamutil#tostring 是一个对流简单处理的工具类。

/**
 * 转换为字符串
 * @param inputstream 流
 * @return 结果
 * @since 1.0.0
 */
public static string tostring(final inputstream inputstream)  {
    if (inputstream == null) {
        return null;
    }
    try {
        int length = inputstream.available();
        final reader reader = new inputstreamreader(inputstream, standardcharsets.utf_8);
        final chararraybuffer buffer = new chararraybuffer(length);
        final char[] tmp = new char[1024];
        int l;
        while((l = reader.read(tmp)) != -1) {
            buffer.append(tmp, 0, l);
        }
        return buffer.tostring();
    } catch (exception exception) {
        throw new runtimeexception(exception);
    }
}

客户端

那么问题来了，如何同时在 httpclient 中设置 parameter 和 body 呢？

机智的小伙伴们可以自己先尝试一下。

小明尝试了多种方法，发现一个残酷的现实—— httppost 只能设置一个 entity，也尝试看了各种子类，然并luan。

就在小明想要放弃的时候，小明忽然想到，paramter 完全可以通过拼接 url 的方式实现。

也就是我们把 parameter 和 url 并且为一个新的 url，body 和以前设置方式一样。

实现代码如下：

//post请求，带集合参数
public static string post(string url, map<string, string> parammap,
                          string body) {
    try {
        list<namevaluepair> namevaluepairs = new arraylist<>();
        for (map.entry<string, string> entry : parammap.entryset()) {
            namevaluepair pair = new basicnamevaluepair(entry.getkey(), entry.getvalue());
            namevaluepairs.add(pair);
        }

        // 构建 url
        //构造请求路径，并添加参数
        uri uri = new uribuilder(url).addparameters(namevaluepairs).build();

        //构造httpclient
        closeablehttpclient httpclient = httpclients.createdefault();
        // 通过httppost来发送post请求
        httppost httppost = new httppost(uri);
        httppost.setentity(new stringentity(body));

        // 获取响应
        // 通过client调用execute方法
        closeablehttpresponse response = httpclient.execute(httppost);
        //获取响应数据
        httpentity entity = response.getentity();
        //将数据转换成字符串
        string str = entityutils.tostring(entity, "utf-8");
        //关闭
        response.close();
        return str;
    } catch (urisyntaxexception | ioexception | parseexception e) {
        throw new runtimeexception(e);
    }
}

这里通过 new uribuilder(url).addparameters(namevaluepairs).build() 构建新的 url，当然你可以使用 &key=value 的方式自己拼接。

测试代码

@test
public void paramandbodytest() {
    string url = "http://localhost:8080/paramandbody";
    map<string,string> map = buildparammap();
    string body = buildbody();
    string result = httpclientutils.post(url, map, body);

    assert.assertequals("123456-body", result);
}

测试通过，非常完美。

新的征程

当然，一般的文章到这里就该结束了。

不过上面并不是本文的重点，我们的故事才刚刚开始。

日志需求

大雁飞过，天空一定会留下他的痕迹。

程序更应如此。

为了方便的跟踪问题，我们一般都是对调用的入参进行日志留痕。

为了便于代码拓展和可维护性，小明当然采用拦截器的方式。

日志拦截器

import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.stereotype.component;
import org.springframework.util.streamutils;
import org.springframework.web.servlet.handlerinterceptor;
import org.springframework.web.servlet.modelandview;

import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
import java.nio.charset.standardcharsets;
import java.util.enumeration;

/**
 * 日志拦截器

 * @author 老马啸西风
 * @since 1.0.0
 */
@component
public class loghandlerinterceptor implements handlerinterceptor {

    private logger logger = loggerfactory.getlogger(loghandlerinterceptor.class);

    @override
    public boolean prehandle(httpservletrequest httpservletrequest,
                             httpservletresponse httpservletresponse, object o) throws exception {
        // 获取参数信息
        enumeration<string> enumeration = httpservletrequest.getparameternames();
        while (enumeration.hasmoreelements()) {
            string paraname = enumeration.nextelement();
            logger.info("param name: {}, value: {}", paraname, httpservletrequest.getparameter(paraname));
        }

        // 获取 body 信息
        string body = streamutils.copytostring(httpservletrequest.getinputstream(), standardcharsets.utf_8);
        logger.info("body: {}", body);

        return true;
    }

    @override
    public void posthandle(httpservletrequest httpservletrequest,
                           httpservletresponse httpservletresponse, object o, modelandview modelandview) throws exception {

    }

    @override
    public void aftercompletion(httpservletrequest httpservletrequest,
                                httpservletresponse httpservletresponse, object o, exception e) throws exception {

    }

}

非常的简单易懂，输出入参中的 parameter 参数和 body 信息。

然后指定一下生效的范围：

@configuration
public class springmvcconfig extends webmvcconfigureradapter {

    @autowired
    private loghandlerinterceptor loghandlerinterceptor;

    @override
    public void addinterceptors(interceptorregistry registry) {
        registry.addinterceptor(loghandlerinterceptor)
                .addpathpatterns("/**");

        super.addinterceptors(registry);
    }

}

所有的请求都会生效。

我的 inputstream 呢？

小伙伴们觉得刚才的日志拦截器有没有问题？

如果有，又应该怎么解决呢？

小明写完心想一切顺利，一运行测试用例，整个人都裂开了。

所有 controller 方法中的 httpservletrequest.getinputstream() 的内容都变成空了。

是谁？偷走了我的 inputstream？

转念一想，小明发现了问题所在。

肯定是自己刚才新增的日志拦截器有问题，因为 stream 作为流只能被读取一遍，日志中读取一遍之后，后面就读不到了。

可是日志中必须要输出，那应该怎么办呢？

遇事不决

遇事不决，技术问 google，八卦去围脖。

于是小明去查了一下，解决方案也比较直接，重写。

重写 httpservletrequestwrapper

首先重写 httpservletrequestwrapper，把每次读取的流信息保存起来，便于重复读取。

/**
 * @author binbin.hou
 * @since 1.0.0
 */
public class myhttpservletrequestwrapper extends httpservletrequestwrapper {

    private byte[] requestbody = null;//用于将流保存下来

    public myhttpservletrequestwrapper(httpservletrequest request) throws ioexception {
        super(request);
        requestbody = streamutils.copytobytearray(request.getinputstream());
    }


    @override
    public servletinputstream getinputstream() {
        final bytearrayinputstream bais = new bytearrayinputstream(requestbody);
        return new servletinputstream() {
            @override
            public int read() {
                return bais.read();  // 读取 requestbody 中的数据
            }

            @override
            public boolean isfinished() {
                return false;
            }

            @override
            public boolean isready() {
                return false;
            }

            @override
            public void setreadlistener(readlistener readlistener) {
            }
        };
    }

    @override
    public bufferedreader getreader() throws ioexception {
        return new bufferedreader(new inputstreamreader(getinputstream()));
    }

}

实现 filter

我们上面重写的 myhttpservletrequestwrapper 什么时候生效呢？

我们可以自己实现一个 filter，对原有的请求进行替换：

import org.springframework.stereotype.component;

import javax.servlet.*;
import javax.servlet.http.httpservletrequest;
import java.io.ioexception;

/**
 * @author binbin.hou
 * @since 1.0.0
 */
@component
public class httpservletrequestreplacedfilter implements filter {

    @override
    public void destroy() {}

    @override
    public void dofilter(servletrequest request, servletresponse response,
                         filterchain chain) throws ioexception, servletexception {
        servletrequest requestwrapper = null;

        // 进行替换
        if(request instanceof httpservletrequest) {
            requestwrapper = new myhttpservletrequestwrapper((httpservletrequest) request);
        }

        if(requestwrapper == null) {
            chain.dofilter(request, response);
        } else {
            chain.dofilter(requestwrapper, response);
        }
    }
    @override
    public void init(filterconfig arg0) throws servletexception {}

}

然后就可以发现一切都好起来了，小明嘴角又漏出了龙王的微笑。

小结

文中对原始问题进行了简化，实际遇到这个问题的时候，直接就是一个拦截器+参数和body的请求。

所以整个问题排查起来有些浪费时间。

不过浪费的时间如果没有任何反思，那就是真的浪费了。

最核心的两点在于：

（1）对于 servlet 标准的理解。

（2）对于流读取的理解，以及一些 spring 的相关知识。

到此这篇关于springboot 中 inputstream 神秘消失之谜的文章就介绍到这了,更多相关springboot 中 inputstream 内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！