Junit模拟http请求

最新推荐文章于 2024-04-11 00:56:49 发布
最新推荐文章于 2024-04-11 00:56:49 发布
阅读量2.5k 收藏 2
点赞数 1
文章标签： java 测试
原文链接：https://yq.aliyun.com/articles/211921
版权 
package cn.xxx;

import javax.net.ssl.*;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Created by yinx on 2017/9/19 0019.
 */
public class HttpUtils {
    public static final String UTF8 = "utf-8";
    public static final String GBK = "gbk";
    public static final String GB2312 = "gb2312";
    public static final String ISO88591 = "ISO-8859-1";
    public static int READ_TIMEOUT = 30000;
    public static int CONNECT_TIMEOUT = 30000;

    /**
     * post请求数据
     *
     * @param connectURL
     * @param param
     * @param charset
     * @return
     */
    public static String doPost(String connectURL, String param, String charset) {
        byte[] bytes = null;
        ByteArrayOutputStream byteArrayOut = null;
        URL url = null;
        HttpURLConnection httpPost = null;
        OutputStream out = null;
        InputStream in = null;
        try {
            url = new URL(connectURL);
            httpPost = (HttpURLConnection) url.openConnection();
            httpPost.setRequestMethod("POST");
            httpPost.setDoInput(true);
            httpPost.setDoOutput(true);
            httpPost.setUseCaches(false);
            httpPost.setConnectTimeout(CONNECT_TIMEOUT);
            httpPost.setReadTimeout(READ_TIMEOUT);
            httpPost.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            httpPost.connect();
            out = httpPost.getOutputStream();
            out.write(param.getBytes(charset));
            out.flush();
            in = httpPost.getInputStream();
            byteArrayOut = new ByteArrayOutputStream();
            byte[] buf = new byte[512];
            int l = 0;
            while ((l = in.read(buf)) != -1) {
                byteArrayOut.write(buf, 0, l);
            }
            bytes = byteArrayOut.toByteArray();
            return new String(bytes, charset);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close(byteArrayOut);
            close(out);
            close(in);
            close(httpPost);
        }
        return null;
    }

    public static String doPostSSL(String connectURL, Map<String, String> params, String charset) throws MalformedURLException, IOException, UnsupportedEncodingException {
        _ignoreSSL();
        return doPost(connectURL, params, charset);
    }

    /**
     * post请求数据
     *
     * @param connectURL
     * @param params
     * @param charset
     * @return
     */
    public static String doPost(String connectURL, Map<String, String> params, String charset) {
        String param = "";
        if (params != null && !params.isEmpty()) {
            StringBuffer paramBuf = new StringBuffer();
            for (Iterator<String> it = params.keySet().iterator(); it.hasNext();) {
                String key = it.next();
                String value = params.get(key);
                paramBuf.append("&").append(key).append("=").append(value);
            }
            param = paramBuf.substring(1);
        }
        System.out.println("post url:" + connectURL);
        System.out.println("post data:" + param);
        byte[] bytes = null;
        ByteArrayOutputStream byteArrayOut = null;
        URL url = null;
        HttpURLConnection httpPost = null;
        OutputStream out = null;
        BufferedInputStream in = null;
        try {
            url = new URL(connectURL);
            httpPost = (HttpURLConnection) url.openConnection();
            httpPost.setRequestMethod("POST");
            httpPost.setDoInput(true);
            httpPost.setDoOutput(true);
            httpPost.setUseCaches(false);
            httpPost.setConnectTimeout(CONNECT_TIMEOUT);
            httpPost.setReadTimeout(READ_TIMEOUT);
            httpPost.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            httpPost.connect();
            out = httpPost.getOutputStream();
            out.write(param.getBytes(charset));
            out.flush();

            try {
                in = new BufferedInputStream(httpPost.getInputStream());
            } catch (IOException e) {
                in = new BufferedInputStream(httpPost.getErrorStream());
            }

            byteArrayOut = new ByteArrayOutputStream();
            byte[] buf = new byte[512];
            int l = 0;
            while ((l = in.read(buf)) != -1) {
                byteArrayOut.write(buf, 0, l);
            }
            bytes = byteArrayOut.toByteArray();
            return new String(bytes, charset);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close(byteArrayOut);
            close(in);
            close(out);
            close(httpPost);
        }
        return null;
    }

    /**
     * Get请求数据
     *
     * @param connectURL
     * @param charset
     * @return
     */
    public static String doGet(String connectURL, String charset) {
        byte[] bytes = null;
        ByteArrayOutputStream byteArrayOut = null;
        URL url = null;
        HttpURLConnection httpGet = null;
        InputStream in = null;
        try {
            url = new URL(connectURL);
            httpGet = (HttpURLConnection) url.openConnection();
            httpGet.setConnectTimeout(CONNECT_TIMEOUT);
            httpGet.setReadTimeout(READ_TIMEOUT);
            httpGet.connect();
            in = httpGet.getInputStream();
            byteArrayOut = new ByteArrayOutputStream();
            byte[] buf = new byte[512];
            int l = 0;
            while ((l = in.read(buf)) != -1) {
                byteArrayOut.write(buf, 0, l);
            }
            bytes = byteArrayOut.toByteArray();
            return bytes != null ? new String(bytes, charset) : null;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close(byteArrayOut);
            close(in);
            close(httpGet);
        }
        return null;
    }

    private static void close(Closeable stream) {
        if (stream != null) {
            try {
                stream.close();
                stream = null;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static void close(HttpURLConnection httpConn){
        if(httpConn != null){
            httpConn.disconnect();
        }
    }

    private static HostnameVerifier ignoreHostnameVerifier = new HostnameVerifier() {
        @Override
        public boolean verify(String s, SSLSession sslsession) {
            return true;
        }
    };

    /**
     * 忽略SSL
     */
    private static void _ignoreSSL() {
        try {
            // Create a trust manager that does not validate certificate chains
            TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }

                @Override
                public void checkClientTrusted(X509Certificate[] certs, String authType) {
                }

                @Override
                public void checkServerTrusted(X509Certificate[] certs, String authType) {
                }
            } };

            // Install the all-trusting trust manager

            SSLContext sc = SSLContext.getInstance("TLS");
            sc.init(null, trustAllCerts, new SecureRandom());
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
            HttpsURLConnection.setDefaultHostnameVerifier(ignoreHostnameVerifier);
        } catch (KeyManagementException ex) {
            Logger.getLogger(HttpUtils.class.getName()).log(Level.SEVERE, null, ex);
        } catch (NoSuchAlgorithmException ex) {
            Logger.getLogger(HttpUtils.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public String doPost(String actionURL, HashMap<String, String> parameters){
        String response = "";
        try{
            URL url = new URL(actionURL);
            HttpURLConnection connection = (HttpURLConnection)url.openConnection();
            //发送post请求需要下面两行
            connection.setDoInput(true);
            connection.setDoOutput(true);
            connection.setUseCaches(false);
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Connection", "Keep-Alive");
            connection.setRequestProperty("Charset", "UTF-8");;
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            //设置请求数据内容
            String requestContent = "";
            Set<String> keys = parameters.keySet();
            for(String key : keys){
                requestContent = requestContent + key + "=" + parameters.get(key) + "&";
            }
            requestContent = requestContent.substring(0, requestContent.lastIndexOf("&"));
            DataOutputStream ds = new DataOutputStream(connection.getOutputStream());
            //使用write(requestContent.getBytes())是为了防止中文出现乱码
            ds.write(requestContent.getBytes());
            ds.flush();
            try{
                //获取URL的响应
                BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), "utf-8"));
                String s = "";
                String temp = "";
                while((temp = reader.readLine()) != null){
                    s += temp;
                }
                response = s;
                reader.close();
            }catch(IOException e){
                e.printStackTrace();
                System.out.println("No response get!!!");
            }
            ds.close();
        }catch(IOException e){
            e.printStackTrace();
            System.out.println("Request failed!");
        }
        return response;
    }

    /**
     * @author Johnson
     * @method singleFileUploadWithParameters
     * @description 集上传单个文件与传递参数于一体的方法
     * @param actionURL 上传文件的URL地址包括URL
     * @param fileType 文件类型(枚举类型)
     * @param uploadFile 上传文件的路径字符串
     * @param parameters 跟文件一起传输的参数(HashMap)
     * @return String("" if no response get)
     * @attention 上传文件name为file(服务器解析)
     * */
    /*public String singleFileUploadWithParameters(String actionURL, String uploadFile, MIME_FileType fileType, HashMap<String, String> parameters){
        String end = "\r\n";
        String twoHyphens = "--";
        String boundary = "---------------------------7e0dd540448";
        String response = "";
        try{
            URL url = new URL(actionURL);
            HttpURLConnection connection = (HttpURLConnection)url.openConnection();
            //发送post请求需要下面两行
            connection.setDoInput(true);
            connection.setDoOutput(true);
            //设置请求参数
            connection.setUseCaches(false);
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Connection", "Keep-Alive");
            connection.setRequestProperty("Charset", "UTF-8");
            connection.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
            //获取请求内容输出流
            DataOutputStream ds = new DataOutputStream(connection.getOutputStream());
            String fileName = uploadFile.substring(uploadFile.lastIndexOf(this.PathSeparator) + 1);
            //开始写表单格式内容
            //写参数
            Set<String> keys = parameters.keySet();
            for(String key : keys){
                ds.writeBytes(twoHyphens + boundary + end);
                ds.writeBytes("Content-Disposition: form-data; name=\"");
                ds.write(key.getBytes());
                ds.writeBytes("\"" + end);
                ds.writeBytes(end);
                ds.write(parameters.get(key).getBytes());
                ds.writeBytes(end);
            }
            //写文件
            ds.writeBytes(twoHyphens + boundary + end);
            ds.writeBytes("Content-Disposition: form-data; " + "name=\"file\"; " + "filename=\"");
            //防止中文乱码
            ds.write(fileName.getBytes());
            ds.writeBytes("\"" + end);
            ds.writeBytes("Content-Type: " + fileType.getValue() + end);
            ds.writeBytes(end);
            //根据路径读取文件
            FileInputStream fis = new FileInputStream(uploadFile);
            byte[] buffer = new byte[1024];
            int length = -1;
            while((length = fis.read(buffer)) != -1){
                ds.write(buffer, 0, length);
            }
            ds.writeBytes(end);
            fis.close();
            ds.writeBytes(twoHyphens + boundary + twoHyphens + end);
            ds.writeBytes(end);
            ds.flush();
            try{
                //获取URL的响应
                BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), "utf-8"));
                String s = "";
                String temp = "";
                while((temp = reader.readLine()) != null){
                    s += temp;
                }
                response = s;
                reader.close();
            }catch(IOException e){
                e.printStackTrace();
                System.out.println("No response get!!!");
            }
            ds.close();
        }catch(IOException e){
            e.printStackTrace();
            System.out.println("Request failed!");
        }
        return response;
    }*/
}
weixin_33895016
关注
基于Junit的HttpUnit测试
08-10
NULL 博文链接：https://jisonami.iteye.com/blog/2202505
九、junit接口自动化框架-构造http请求
喵酱
05-15 855
一、http请求分类 get请求 post请求： json格式 form表单格式 二、具体代码
必备技能~Java编程使用Junit实现接口单元测试，快速实现接口全覆盖(1)
最新发布
2401_83739951的博客
04-11 997
涵盖了95%以上软件测试开发知识点，真正体系化！**
Springboot+Junit测试Http请求实例包括Get,Post,Put和Delete已及断言Assert的使用
热门推荐
九零后的技术员
08-03 1万+
今天测试Http接口的时候，发现一些问题，遇见Put和Delete请求时，使用TestRestTemplate无法获取返回值。先简单来说说两个测试的方法，第一个，使用Mock，但是个人认为它使用起来十分繁琐，不适合着急测试的人群，不亲民。第二个就是spring的TestRestTemplate，它实现的是RestOperations接口，里面有好多方法，即get,post,put,delete。但
JAVA HTTP请求
willem的博客
07-13 270
GET请求方式 /** * Description: 发送GET请求，请求参数为MAP * @author: willem * @date: 2020/7/13 11:45 * @param url * @param param * @return:java.lang.String */ public static String sendGet(String url, Map<String, String> pa
mock-httpserver:一个模拟 Http 服务器
06-19
一个 Mock Http Server，您可以在其中根据请求必须满足的谓词来定义请求中收到的答案。 它的主要目的是在 JUnit-Tests 中使用。 启动和停止模拟 httpserver 假设我们在setUp方法中启动模拟 httpserver 并在...
java后端请求HTTP需要用到的jar包及其测试方法(get和post)
01-11
测试过程中，可以使用JUnit或其他测试框架来编写单元测试，模拟不同的请求场景，确保HTTP请求能正确发送和接收。测试内容应包括但不限于：正常请求、错误处理、超时设置、连接管理、异步请求等。 总结来说，利用...
Junit 测试
10-14
这时，我们可以使用JUnit结合Spring Test来创建一个测试环境，模拟HTTP请求并注入mock对象来隔离被测试的Controller。 例如，我们可以创建一个名为`TestSpring`的测试类，该类使用`@RunWith(SpringRunner.class)`...
单元测试案例junit +spring mvc +springboot
06-18
在进行单元测试时，可以利用Spring MVC的MockMvc类来模拟HTTP请求，测试控制器方法的行为，而无需实际启动服务器。 3. Spring Boot Spring Boot旨在简化Spring应用的初始搭建以及开发过程。它通过预设合理的默认...
junit测试demo
10-25
2. **Struts**：Struts是MVC架构的一部分，用于处理HTTP请求和控制应用程序流程。在JUnit测试中，我们可能需要模拟Struts的Action和Result，或者使用Mockito等工具来模拟依赖，以便隔离测试。 3. **Hibernate**：...
http的方式调用接口
qq_36323075的博客
10-16 704
调用接口的方式很多，可以使用cxf框架等，单最简单的是用http，废话不多说，代码如下： public static String sendPost(String url, String param) { OutputStreamWriter out = null; BufferedReader in = null; String...
post方法
u014622411的专栏
06-16 555
public static String doPost(String urlString, String param) { URL url = null; HttpURLConnection URLConn = null; OutputStreamWriter out = null; BufferedReader reader = null; StringBuffer resultBuf
在Servlet 中的获取所有请求参数
allway2的博客
10-20 841
在本教程中，我们将向您展示如何在 Java Servlet 中获取所有请求参数。这是开发 Servelt 应用程序时必须考虑的最基本步骤，因为 HTTP 主要基于参数交换。这是一个关于如何在 Servlet 中获取所有请求参数的示例。
Junit 模拟http请求快速上手
寻梦
05-30 3416
junit相信做java的都不陌生，用过的人也很多。本人一直没写过junit的http测试，最近有用到，网上的资料不少，但是比较杂。所以整理一个让你快速开始写代码的文章。本文属于快速入门使用，不属于深入研究类型。 本文是基于springboot，junit4 @RunWith(SpringRunner.class) @SpringBootTest(classes = RouterApplication.class) // 这个是你的springboot启动类 @ActiveProfiles("junit")
SpringBoot测试（Junit单元测试、MockMvc测试Http请求 ）
yu的博客
03-23 1880
使用测试 可以对项目中的方法进行测试，看它的执行是否能达到我们的预期效果，对相应的类创建对应的测试类，在方法上添加注解 @Test，就能使测试方法如同 main方法一样可以直接运行，这样就能观察到该方法最终执行的效果。MockMvc是由spring-test包提供，MockMvc实现了对Http请求的模拟，能够直接使用网络的形式，转换到Controller的调用，使请求的验证变得更加方便。需要去掉@Test注解。选择需要测试的方法，并生成测试的类（⽣成了单元测试的框架类，具体的业务代码要⾃⼰填充）
java 后台 携带参数 远程操作 调用接口
syrup66的博客
06-19 1536
package cn.it.ssm.util;import java.io.BufferedReader;import java.io.File;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStreamWriter;import java.net.HttpURLConnection...
HttpClient 模拟登陆，保持会话并进行后续操作
追逐梦想
08-20 679
Apache HttpClient 是很方便的 Java 开源的访问 HTTP 资源的组件。网站上的资源不总是能匿名访问的，很多都需要登陆后才能操作，且不说论坛里登陆后才能发言，就是某些稍显敏感的 XML 等信息也是登陆后才能获取到的。 没问题，HttpClient 能让你做到，它提供了 Basic 和 Form-Based 两种验证方式。登陆后获得服务器端发来的 Cookie 作为下一
junit 模拟压力测试
zaqwpl的博客
03-11 1861
                  junit 模拟多线程压力测试             在生产中经常会遇到关于压力测试的问题，如何在实际生产中测试程序所承受的压力，对于开发来说并不是一件容易的事，下面介绍junit 多线程测试。 直接上代码 package com.bypay.bingfa;   import java.io.BufferedReader; import jav...
利用 Junit + MockMvc + Mockito 对 Http 请求进行单元测试
HD243608836的博客
03-02 5405
关于Mockito以及模拟(mock)测试的介绍请直接看下面的文章：https://www.oschina.net/translate/mockito-a-great-mock-framework-for-java-developmenthttps://www.tianmaying.com/tutorial/JunitForSpringBoot。 在此文主要列举了一些可能在实际中遇到的需...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值