Java接口自动化测试实战001----get、post方法实现与封装

一、接口测试

1、接口测试流程

  • 根据接口文档编写测试用例
  • 准备测试数据
  • 准备工具（测试工具or接口测试代码）
  • 填写接口信息（接口地址、请求方式等）
  • 准备请求头数据（如果有必要，比如：cookies，Content-Type等）
  • 发起请求，获取接口的相应信息（状态码、响应报文、或者某些特殊的响应头数据）
  • 根据报文判断实际与预期结果是否一致

2、HTTP请求

   HTTP请求表示的是从客户端发送到服务器端的请求，HttpGet和HttpPost都是HttpRequest的实现类，属于子类对象，其关系如下图所示：

 

3、HTTP响应

   HTTP响应表示的是从服务器到客户端的响应，其使用方法有以下几种：

  • 从响应对象中获取返回的数据：getEntity()
  • 从响应对象中获取响应状态码：getStatusLine().getStatusCode()
  • 从响应对象中获取响应头信息：getAllHeaders()

二、接口自动化测试之Get请求

1、get请求的特点

  • 以get方式提交请求到服务器
  • Get参数不是封装在请求体当中的（由没有setEntity方法可以看出来）
  • 数据长度是有限制的
  • 支持get提交的接口一般都是从服务器上拿下来数据

2、HttpGet请求

     HttpGet是模拟实现Http协议下get请求的java类，它关键的api函数有以下几个：

  • 构造函数：HttpGet httpGet=new HttpGet(url);创建一个get对象，以get方式提交接口请求
  • 组合拼接参数：URLEncodedUtils.format(params,”utf-8”);----UrlEncodeFormEntity以表单的形式提交数据.

     注意：如果以get提交的接口请求有需要传参数，参数通常直接拼接在url后面的。

3、HttpGet请求代码实现

（1）实现思想

  •   准备测试地址和测试数据，并拼接
  •   创建HttpGet对象，指定接口请求方式： HttpGet httpGet=new HttpGet(url);
  •   设置请求头信息：httpGet.setHeader(String,String);
  •   创建一个可关闭的HttpClient对象：HttpClient httpclient=HttpClients.createDefault();
  •   执行请求获取响应信息：HttpResponse httpresponse=httpclient.execute(get);
  •   获取响应的状态码：int code=httpresponse.getStatusLine().getStatusCode();
  •   获取响应的报文：String result=EntityUtils.toString((httpresponse.getEntity()));

（2）实现代码

   根据实现思想，编写测试代码，如下：

 1 package testInterface.test_V1;
 2 
 3 import java.io.IOException;
 4 
 5 import org.apache.http.HttpResponse;
 6 import org.apache.http.client.HttpClient;
 7 import org.apache.http.client.methods.HttpGet;
 8 import org.apache.http.impl.client.HttpClients;
 9 import org.apache.http.util.EntityUtils;
10 
11 public class doGet {
12 
13     public static void main(String[] args) {
14     //http://127.0.0.1:8080/api/pay/getAllBaseWatercategory?pageNum=1&pageSize=10&name=
15     //1、准备URL和测试数据，并拼接成请求的测试地址
16      String  url="http://127.0.0.1:8080/api/pay/getAllBaseWatercategory";
17      String para="pageNum=1&pageSize=10&name=";     //测试数据
18      url=url+"?"+para;    //拼接请求地址
19      
20      //2、创建HttpGet对象，指定接口提交的方式
21      HttpGet get =new HttpGet(url);
22      
23      //3、设置请求头
24      get.setHeader("Authorization", "Bearer eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOjMsImxvZ2luVG9rZW4iOiI3YTc3MDYwYy1jMDkzLTRhYzMtYTFlMC04MGJiNGZmYjIyZmMiLCJleHAiOjE1OTM3MDUyNTB9.k2WvdxXOE-XVNdl3zk-Ee8oxDR4Licj5lSC8rhFN2xSPC1lxPDqYkoLnBGfPEB56Aic7_2b100QTmmoByUyfmA");
25      
26      //4、创建一个可关闭的HttpClient对象
27      HttpClient httpclient=HttpClients.createDefault();
28      try {
29      //5、执行post请求，获取响应信息（状态码、响应报文、响应头等）。相当于jmeter上点击运行按钮，然后赋值给HttpResponse对象接收
30         HttpResponse httpresponse=httpclient.execute(get);
31         
32      //6、获取响应状态码和响应报文，并输出
33         int code=httpresponse.getStatusLine().getStatusCode();
34         System.out.print(code);
35         String result=EntityUtils.toString((httpresponse.getEntity()));
36         System.out.print(result);
37     } catch (Exception e) {
38         e.printStackTrace();
39     } 
40  }
41 
42 }

三、接口自动化测试之Post请求

1、Post提交的特点

  • 以post方式提交请求到服务器
  • 参数一般是封装到请求体中提交的
  • 参数长度没有长度限制
  • 支持post方式提交的接口往往是把数据提交到服务器上去

2、HttpPost请求

  • HttpGet是模拟实现Http协议下post请求的java类，它关键的api函数有以下几个：
  • 构造函数：HttpPost httpPost=new HttpPost(url);创建一个post对象，以post方式提交接口请求
  • 设置参数到请求体：post.setEntity(entity,charset);通过此方法将接口参数设置到请求体中。 

3、HttpPost请求具体实现

（1）实现思想

  •   准备测试地址和测试数据
  •   使用BasicNameValuePair封装post请求中的参数名称和值： 
  • List<BasicNameValuePair> parameters=new ArrayList<BasicNameValuePair>();
  • parameters.add(new BasicNameValuePair("mobile",mobile));
  •   把请求参数放到请求体中--------定义请求的实体，并把参数传进来，定义编码格式为utf-8：post.setEntity(new UrlEncodedFormEntity(parameters,"utf-8"));     
  •   创建HttpPost对象，指定接口请求方式： HttpPost httpPost=new HttpPost(url);
  •   设置请求头信息：httpGet.setHeader(String,String);
  •   创建一个可关闭的HttpClient对象：HttpClient httpclient=HttpClients.createDefault();
  •   执行请求获取响应信息：HttpResponse httpresponse=httpclient.execute(post);
  •   获取响应的状态码：int code=httpresponse.getStatusLine().getStatusCode();
  •   获取响应的报文：String result=EntityUtils.toString((httpresponse.getEntity()));

（2）实现代码

根据实现思想，编写测试代码，如下：

 1 package testInterface.test_V1;
 2 
 3 
 4 import java.io.IOException;
 5 import java.util.ArrayList;
 6 import java.util.List;
 7 
 8 import org.apache.http.HttpResponse;
 9 import org.apache.http.client.ClientProtocolException;
10 import org.apache.http.client.HttpClient;
11 import org.apache.http.client.entity.UrlEncodedFormEntity;
12 import org.apache.http.client.methods.HttpPost;
13 import org.apache.http.impl.client.HttpClients;
14 import org.apache.http.message.BasicNameValuePair;
15 import org.apache.http.util.EntityUtils;
16 
17 public class doPost {
18     public static void  main(String[] args) throws ClientProtocolException, IOException {
19         //1、准备测试请求的地址和参数（测试数据）
20         String url="http://127.0.0.1:8080/api/user/smsCodeLogin";
21         String mobile="13265537610";
22         String smsCode="9999";
23         
24         //2、使用BasicNameValuePair封装post请求中的参数名称和值
25         List<BasicNameValuePair> parameters=new ArrayList<BasicNameValuePair>();
26         parameters.add(new BasicNameValuePair("mobile",mobile));
27         parameters.add(new BasicNameValuePair("smsCode",smsCode));
28         
29         //3、创建HttpPost对象，指定接口提交的方式
30         HttpPost post=new HttpPost(url);
31         
32         //4、把请求参数放到请求体中--------定义请求的实体，并把参数传进来，定义编码格式为utf-8
33         post.setEntity(new UrlEncodedFormEntity(parameters,"utf-8"));
34         
35          //5、创建一个可关闭的HttpClient对象
36         HttpClient httpclient=HttpClients.createDefault();
37         
38          //6、执行post请求，获取响应信息（状态码、响应报文、响应头等）。相当于jmeter上点击运行按钮，然后赋值给HttpResponse对象接收
39         HttpResponse httpresponse=httpclient.execute(post);
40         
41         //7、获取响应状态码和响应报文，并输出
42         int code=httpresponse.getStatusLine().getStatusCode();
43         System.out.print(code);
44         String result=EntityUtils.toString((httpresponse.getEntity()));
45         System.out.print(result);
48     }
49 }

四、封装之拆分get、 post请求

1、拆分getDemo类

(1)实现步骤

  • 主函数中处理url和参数，将参数封装到map集合中，调用doGet方法传入url和参数；
  • 新建doGet方法，处理map中的参数拼接到地址中，之后执行请求，步骤与之前一样。

（2）实现代码如下：

拆分getDemo类为主函数调用doGet方法的形式，如下所示：

 1 public class getDemo {
 2 
 3     public static void main(String[] args) {
 4           //http://114.135.61.188:58088/api/pay/getAllBaseWatercategory?pageNum=1&pageSize=10&name=
 5         //1、准备URL和测试数据，并拼接成请求的测试地址
 6          String  url="http://114.135.61.188:58088/api/pay/getAllBaseWatercategory";
 7          String para="pageNum=1&pageSize=10&name=";     //测试数据
 8          String pageNum="1";
 9          String pageSize="10";
10          String name="";
11          Map<String,String> parameter=new HashMap<String,String>();
12          parameter.put("pageNum",pageNum);
13          parameter.put("pageSize",pageSize);
14          parameter.put("name",name);
15 
16          doGet(url,parameter);
17     }
18         
19     public static void doGet(String url,Map<String,String> parameter) {
20         //拼接URL
21         Set<String>  keys=parameter.keySet();
22         int mark=1;  //定义一个标志位
23         for (String para : keys) {
24             if(mark==1) {
25                 url=url+"?"+para+"="+parameter.get(para);
26             }else {
27                 url=url+"&"+para+"="+parameter.get(para);
28             }
29             mark++;
30         }
31         System.out.print(url);
32      //2、创建HttpGet对象，指定接口提交的方式
33      HttpGet get =new HttpGet(url);
34      
35      //3、设置请求头
36      get.setHeader("Authorization", "Bearer eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOjMsImxvZ2luVG9rZW4iOiI3YTc3MDYwYy1jMDkzLTRhYzMtYTFlMC04MGJiNGZmYjIyZmMiLCJleHAiOjE1OTM3MDUyNTB9.k2WvdxXOE-XVNdl3zk-Ee8oxDR4Licj5lSC8rhFN2xSPC1lxPDqYkoLnBGfPEB56Aic7_2b100QTmmoByUyfmA");
37      
38      //4、创建一个可关闭的HttpClient对象
39      HttpClient httpclient=HttpClients.createDefault();
40      try {
41      //5、执行post请求，获取响应信息（状态码、响应报文、响应头等）。相当于jmeter上点击运行按钮，然后赋值给HttpResponse对象接收
42         HttpResponse httpresponse=httpclient.execute(get);
43         
44      //6、获取响应状态码和响应报文，并输出
45         int code=httpresponse.getStatusLine().getStatusCode();
46         System.out.print(code);
47         String result=EntityUtils.toString((httpresponse.getEntity()));
48         System.out.print(result);
49     } catch (Exception e) {
50         e.printStackTrace();
51     } 
52  }
53 
54 }

2、拆分postDemo类

(1)实现步骤

  • 主函数中处理url和参数，将参数封装到map集合中，调用doGet方法传入url和参数；
  • 新建doPost方法，处理map中的参数并封装到请求中，之后执行请求，步骤与之前一样。

(2)实现代码如下

拆分postDemo类为主函数调用doPost方法的形式，如下所示：

 1 public class postDemo {
 2     public static void  main(String[] args) throws ClientProtocolException, IOException {
 3         //1、准备测试请求的地址和参数（测试数据）
 4         String url="http://114.135.61.188:58088/api/user/smsCodeLogin";
 5         String mobile="18800000000";
 6         String smsCode="9999";
 7          Map<String,String> parameter=new HashMap<String,String>();
 8          parameter.put("mobile",mobile);
 9          parameter.put("smsCode",smsCode);
10          doPost(url,parameter);
11 
12      }    
13     public static void doPost(String url, Map<String,String> parameter) throws ClientProtocolException, IOException {
14        
15         //2、使用BasicNameValuePair封装post请求中的参数名称和值
16         List<BasicNameValuePair> parameters=new ArrayList<BasicNameValuePair>();
17         Set<String> keys=parameter.keySet();
18         for (String para : keys) {
19             parameters.add(new BasicNameValuePair(para,parameter.get(para)));
20         }
21         
22         //3、创建HttpPost对象，指定接口提交的方式
23         HttpPost post=new HttpPost(url);
24         
25         //4、把请求参数放到请求体中--------定义请求的实体，并把参数传进来，定义编码格式为utf-8
26         post.setEntity(new UrlEncodedFormEntity(parameters,"utf-8"));
27         
28          //5、创建一个可关闭的HttpClient对象
29         HttpClient httpclient=HttpClients.createDefault();
30         
31          //6、执行post请求，获取响应信息（状态码、响应报文、响应头等）。相当于jmeter上点击运行按钮，然后赋值给HttpResponse对象接收
32         HttpResponse httpresponse=httpclient.execute(post);
33         
34         //7、获取响应状态码和响应报文，并输出
35         int code=httpresponse.getStatusLine().getStatusCode();
36         System.out.print(code);
37         String result=EntityUtils.toString((httpresponse.getEntity()));
38         System.out.print(result);      
41     }
42 }

五、封装get、 post请求到HttpUtil类

1、封装思想 

      提取GetDemo和PostDemo类中的doGet和doPost方法，封装到HttpUtil类中，方便之后调用，降低耦合性。

2、封装实现

（1）项目环境搭建：创建maven项目----在pom.xml中配置httpclient，配置如下：

 1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 2   <modelVersion>4.0.0</modelVersion>
 3   <groupId>com.interface.test</groupId>
 4   <artifactId>testInterface</artifactId>
 5   <version>0.0.1-SNAPSHOT</version>
 6   <dependencies>
 7   <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
 8       <dependency>
 9           <groupId>org.apache.httpcomponents</groupId>
10           <artifactId>httpclient</artifactId>
11           <version>4.5.2</version>
12        </dependency>
13   </dependencies>
14 </project>

（2）封装HttpUtil类，并将GetDemo和PostDemo类中的doGet和doPost方法复制粘贴至HttpUtil类中，并将方法修改为静态方法，方便之后调用，如下所示：

 1 public class HttpUtil {
 2     public static void doGet(String url,Map<String,String> parameter) {
 3         //拼接URL
 4         Set<String>  keys=parameter.keySet();
 5         int mark=1;  //定义一个标志位
 6         for (String para : keys) {
 7             if(mark==1) {
 8                 url=url+"?"+para+"="+parameter.get(para);
 9             }else {
10                 url=url+"&"+para+"="+parameter.get(para);
11             }
12             mark++;
13         }
14         System.out.print(url+"
");
15      //2、创建HttpGet对象，指定接口提交的方式
16      HttpGet get =new HttpGet(url);
17      
18      //3、设置请求头
19      get.setHeader("Authorization", "Bearer eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOjMsImxvZ2luVG9rZW4iOiI3YTc3MDYwYy1jMDkzLTRhYzMtYTFlMC04MGJiNGZmYjIyZmMiLCJleHAiOjE1OTM3MDUyNTB9.k2WvdxXOE-XVNdl3zk-Ee8oxDR4Licj5lSC8rhFN2xSPC1lxPDqYkoLnBGfPEB56Aic7_2b100QTmmoByUyfmA");
20      
21      //4、创建一个可关闭的HttpClient对象
22      HttpClient httpclient=HttpClients.createDefault();
23      try {
24      //5、执行post请求，获取响应信息（状态码、响应报文、响应头等）。相当于jmeter上点击运行按钮，然后赋值给HttpResponse对象接收
25         HttpResponse httpresponse=httpclient.execute(get);
26         
27      //6、获取响应状态码和响应报文，并输出
28         int code=httpresponse.getStatusLine().getStatusCode();
29         System.out.print(code);
30         String result=EntityUtils.toString((httpresponse.getEntity()));
31         System.out.print(result);
32     } catch (Exception e) {
33         e.printStackTrace();
34     } 
35  }
36     public static void doPost(String url, Map<String,String> parameter) throws ClientProtocolException, IOException {
37            
38         //2、使用BasicNameValuePair封装post请求中的参数名称和值
39         List<BasicNameValuePair> parameters=new ArrayList<BasicNameValuePair>();
40         Set<String> keys=parameter.keySet();
41         for (String para : keys) {
42             parameters.add(new BasicNameValuePair(para,parameter.get(para)));
43         }
44         
45         //3、创建HttpPost对象，指定接口提交的方式
46         HttpPost post=new HttpPost(url);
47         
48         //4、把请求参数放到请求体中--------定义请求的实体，并把参数传进来，定义编码格式为utf-8
49         post.setEntity(new UrlEncodedFormEntity(parameters,"utf-8"));
50         
51          //5、创建一个可关闭的HttpClient对象
52         HttpClient httpclient=HttpClients.createDefault();
53         
54          //6、执行post请求，获取响应信息（状态码、响应报文、响应头等）。相当于jmeter上点击运行按钮，然后赋值给HttpResponse对象接收
55         HttpResponse httpresponse=httpclient.execute(post);
56         
57         //7、获取响应状态码和响应报文，并输出
58         int code=httpresponse.getStatusLine().getStatusCode();
59         System.out.print(code);
60         String result=EntityUtils.toString((httpresponse.getEntity()));
61         System.out.print(result);
62     
63         
64     }
65 }

六、总结

1、概述

2、实现post、get请求

3、拆分post、get请求

4、将doGet和doPost方法封装到HttpUtil类

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/geqiandeqingmu/p/13253223.html