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

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

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

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

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

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

如下：

界面主要分几块

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<BasicNameValuePair> 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<String, Object> 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;
    }
}