利用httpclient制作网关层接口的快速测试界面,仿postman测试工具

由于公司项目工程的庞大，为了精简以及管理业务流程，诞生了网关项目，我正好有机会参与处理这个项目，整个设计思路如下。

网关的主要功能是，在整个项目的访问环节提供了一个统一的入口层。该层通过dubbo的高级特性泛化去调用注册中心的服务接口。
wormhole网关项目开原地址

可以在网关层控制流量、鉴权、认证等操作。

网关层需要维护接口、接口组、权限、应用等数据。

由于网关这层有个简单的数据维护界面，所以要做一个简易界面来做接口的测试，方便数据录入后的验证。

如下：

界面主要分几块

1、基本请求

数据都是从库中读取，自动填充在对应位置。这样就减少了测试时人工录入的时间成本。

请求类型：一般是get、post

请求环境：local、dev、test、自定义地址

请求地址：服务接口的具体路径以及基本参数的拼接

其他：如红框内的内容，说明接口需要鉴权、登录。 其他必要信息可以显示出来

2、header参数设置 可以固定几个常用的以及可自行添加

可以存放一些sign、uid、key等信息

3、body参数设置

一些保存表单的信息可以放在这里

4、response响应显示

主要展示响应结果

具体布局，可以根据页面的实际使用情况处理

请求流程

get请求

比较简单，参数主要拼接在url中，传递到后台对应解析即可

post请求

处理逻辑稍多，首先要分别解析url、header、body中的参数。

一、验签参数

要注意参数的顺序、大小写、具体参数键值对是否匹配。

二、验签逻辑

注意编码格式以及处理方式，要和服务端保持一致

三、特殊处理

如body中并不是标准的json格式对象，而是一段流或者一段长文本。对应dubbo服务调用时如何匹配类型等。

四、异常处理

服务层：异常信息要能够正确的返回到网关层

网关层：能够返回正确的信息到界面上

这里主要是对异常信息的友好包装，能够正确的反馈给用户，从而做出改进。否则要一层一层、一个一个去查看服务的日志是比较费时费力了。

HttpClient处理

当然需要对应controller层的处理和服务层的一些接口支持。

 

package com.test;

import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;

import java.nio.charset.Charset;

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


public class HTTPClientUtils {
    private static final Logger logger = LoggerFactory.getLogger(HTTPClientUtils.class);

    // private static final JsonNodeFactory factory = new JsonNodeFactory(false);
    @SuppressWarnings("deprecation")
    public static ObjectNode get(String url) {
        ObjectNode resObjectNode = null;
        CloseableHttpClient httpCilent = HttpClients.createDefault();
        HttpGet httpGet = new HttpGet(url);

        try {
            HttpResponse httpResponse = httpCilent.execute(httpGet);
            HttpEntity entity = httpResponse.getEntity();

            if (null != entity) {
                String responseContent = EntityUtils.toString(entity, "UTF-8");
                EntityUtils.consume(entity);

                ObjectMapper mapper = new ObjectMapper();
                JsonFactory factory = mapper.getJsonFactory();
                JsonParser jp = factory.createJsonParser(responseContent);
                resObjectNode = mapper.readTree(jp);
                resObjectNode.put("statusCode",
                    httpResponse.getStatusLine().getStatusCode());
            }
        } catch (IOException e) {
            logger.info("调用get请求发生异常{}", e.getMessage());
            e.printStackTrace();
        } finally {
            try {
                httpCilent.close(); // 释放资源
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resObjectNode;
    }

    @SuppressWarnings("deprecation")
    public static ObjectNode post(String url,
        List nameValuePair) {
        ObjectNode resObjectNode = null;
        CloseableHttpClient httpCilent = HttpClients.createDefault();
        HttpPost post = new HttpPost(url);

        try {
            if (nameValuePair != null) {
                UrlEncodedFormEntity params = new UrlEncodedFormEntity(nameValuePair,
                        "UTF-8");
                post.setEntity(params);
            }

            //设置post求情参数
            HttpResponse httpResponse = httpCilent.execute(post);
            HttpEntity entity = httpResponse.getEntity();

            if (null != entity) {
                String responseContent = EntityUtils.toString(entity, "UTF-8");
                EntityUtils.consume(entity);

                ObjectMapper mapper = new ObjectMapper();
                JsonFactory factory = mapper.getJsonFactory();
                JsonParser jp = factory.createJsonParser(responseContent);
                resObjectNode = mapper.readTree(jp);
                resObjectNode.put("statusCode",
                    httpResponse.getStatusLine().getStatusCode());
            }
        } catch (IOException e) {
            logger.info("调用post请求发生异常{}", e.getMessage());
            e.printStackTrace();
        } finally {
            try {
                httpCilent.close(); // 释放资源
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resObjectNode;
    }

    @SuppressWarnings({"deprecation",
        "rawtypes"
    })
    public static ObjectNode post(String url, Map map) {
        ObjectNode resObjectNode = null;
        CloseableHttpClient httpCilent = HttpClients.createDefault();
        HttpPost post = new HttpPost(url);

        //处理头部参数
        String kfix = "header_key";

        //处理头部参数
        String vfix = "header_value";
        ArrayList al = (ArrayList) map.get("enables");

        for (int i = 0; i < al.size(); i++) {
            Object key = map.get(kfix + al.get(i));

            if (key == null) {
                continue;
            }

            post.addHeader(key.toString(),
                (map.get(kfix + al.get(i)) == null) ? ""
                                                    : map.get(vfix + al.get(i))
                                                         .toString());
        }

        post.addHeader("user-agent", map.get("user-agent").toString());
        post.addHeader("host", map.get("host").toString());
        post.addHeader("connection", map.get("connection").toString());
        post.addHeader("accept-encoding", map.get("accept-encoding").toString());
        post.addHeader("content-encoding",
            (map.get("content-encoding") == null) ? ""
                                                  : map.get("content-encoding")
                                                       .toString());

        Object body = map.get("body");

        if (body != null) {
            // 构建消息实体
            StringEntity entity = new StringEntity(body.toString(),
                    Charset.forName("UTF-8"));
            entity.setContentEncoding("UTF-8");
            entity.setContentType("application/json"); // 发送Json格式的数据请求
            post.setEntity(entity);
        }

        try {
            //设置post求情参数
            HttpResponse httpResponse = httpCilent.execute(post);
            HttpEntity entity = httpResponse.getEntity();

            if (null != entity) {
                String responseContent = EntityUtils.toString(entity, "UTF-8");
                EntityUtils.consume(entity);

                ObjectMapper mapper = new ObjectMapper();
                JsonFactory factory = mapper.getJsonFactory();
                JsonParser jp = factory.createJsonParser(responseContent);
                resObjectNode = mapper.readTree(jp);
                resObjectNode.put("statusCode",
                    httpResponse.getStatusLine().getStatusCode());
            }
        } catch (IOException e) {
            logger.info("调用post请求发生异常{}", e.getMessage());
            e.printStackTrace();
        } finally {
            try {
                httpCilent.close(); // 释放资源
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resObjectNode;
    }
}