-----------------------------------------------------------------------------------------------------------------------------------------

说明：

>1.首先必须在指定目录创建 指定文件 ； c:/c/TEST1.xlsx

>2.ExcleUtil类只读取了TEST1.xlsx 前4列的值 ；

>3.ExcleUtil类将接口的返回的json值写入到excle中 ；

>4.HttpInterfaceTest 类中的testSendPost（）方法使用Object ... obj 进行参数接收 ；

------------------------------------------------------------------------------------------------------------------------------------------

1.ExcelReader  --读取*.xls,*.xlsx 格式的 excle ；

  1.  package main.java;
  2.  
  3.  import org.apache.poi.hssf.usermodel.HSSFDateUtil;
  4.  import org.apache.poi.ss.usermodel.*;
  5.  
  6.  import java.io.File;
  7.  import java.io.FileInputStream;
  8.  import java.io.IOException;
  9.  import java.util.ArrayList;
  10.  import java.util.HashMap;
  11.  import java.util.List;
  12.  import java.util.Map;
  13.  
  14.  public class ExcelReader {
  15.      public Object[][] results;
  16.      private String filePath;
  17.      private String sheetName;
  18.      private Workbook workBook;
  19.      private Sheet sheet;
  20.      private List<String> columnHeaderList;
  21.      private List<List<String>> listData;
  22.      private List<Map<String, String>> mapData;
  23.      private boolean flag;
  24.  
  25.      public ExcelReader(String filePath, String sheetName) {
  26.          this.filePath = filePath;
  27.          this.sheetName = sheetName;
  28.          this.flag = false;
  29.          this.load();
  30.      }
  31.  
  32.      public static void main(String[] args) {
  33.  
  34.          Object[][] obj1;
  35.          ExcelReader eh = new ExcelReader("C:\\C\\TEST1.xlsx", "Sheet1");
  36.          Object[][] sheetData2 = eh.getSheetData2();
  37.          System.out.println(sheetData2.length + "------------");
  38.          for (int i = 1; i < sheetData2.length - 1; i++) {
  39.              for (int j = 0; j < sheetData2[i].length - 1; j++) {
  40.                  System.out.print(sheetData2[i][j] + " | ");
  41.              }
  42.              System.out.println();
  43.          }
  44.  
  45.      }
  46.  
  47.      private void load() {
  48.          FileInputStream inStream = null;
  49.          try {
  50.              File files = new File(filePath);
  51.              if (files.exists()) {
  52.                  inStream = new FileInputStream(files);
  53.                  workBook = WorkbookFactory.create(inStream);
  54.                  sheet = workBook.getSheet(sheetName);
  55.              } else {
  56.                  System.out.println("请在这个目录下创建这个文件,不然程序无法执行！; C:/C/TEST1.xlsx");
  57.              }
  58.  
  59.          } catch (Exception e) {
  60.              e.printStackTrace();
  61.          } finally {
  62.              try {
  63.                  if (inStream != null) {
  64.                      inStream.close();
  65.                  }
  66.              } catch (IOException e) {
  67.                  e.printStackTrace();
  68.              }
  69.          }
  70.      }
  71.  
  72.      private String getCellValue(Cell cell) {
  73.          String cellValue = "";
  74.          DataFormatter formatter = new DataFormatter();
  75.          if (cell != null) {
  76.              switch (cell.getCellType()) {
  77.                  case Cell.CELL_TYPE_NUMERIC:
  78.                      if (HSSFDateUtil.isCellDateFormatted(cell)) {
  79.                          cellValue = formatter.formatCellValue(cell);
  80.                      } else {
  81.                          double value = cell.getNumericCellValue();
  82.                          int intValue = (int) value;
  83.                          cellValue = value - intValue == 0 ? String.valueOf(intValue) : String.valueOf(value);
  84.                      }
  85.                      break;
  86.                  case Cell.CELL_TYPE_STRING:
  87.                      cellValue = cell.getStringCellValue();
  88.                      break;
  89.                  case Cell.CELL_TYPE_BOOLEAN:
  90.                      cellValue = String.valueOf(cell.getBooleanCellValue());
  91.                      break;
  92.                  case Cell.CELL_TYPE_FORMULA:
  93.                      cellValue = String.valueOf(cell.getCellFormula());
  94.                      break;
  95.                  case Cell.CELL_TYPE_BLANK:
  96.                      cellValue = "";
  97.                      break;
  98.                  case Cell.CELL_TYPE_ERROR:
  99.                      cellValue = "";
  100.                      break;
  101.                  default:
  102.                      cellValue = cell.toString().trim();
  103.                      break;
  104.              }
  105.          }
  106.          return cellValue.trim();
  107.      }
  108.  
  109.      private void getSheetData() {
  110.  
  111.          listData = new ArrayList<>();
  112.          mapData = new ArrayList<>();
  113.          columnHeaderList = new ArrayList<>();
  114.          int numOfRows = sheet.getLastRowNum() + 1;
  115.          for (int i = 0; i < numOfRows; i++) {
  116.              Row row = sheet.getRow(i);
  117.              Map<String, String> map = new HashMap<>();
  118.              List<String> list = new ArrayList<>();
  119.  
  120.              if (row != null) {
  121.                  for (int j = 0; j < row.getLastCellNum(); j++) {
  122.                      Cell cell = row.getCell(j);
  123.                      if (i == 0) {
  124.                          columnHeaderList.add(getCellValue(cell));
  125.                      } else {
  126.  
  127.                          map.put(columnHeaderList.get(j), this.getCellValue(cell));
  128.  
  129.                      }
  130.                      list.add(this.getCellValue(cell));
  131.                  }
  132.              }
  133.              if (i > 0) {
  134.                  mapData.add(map);
  135.              }
  136.              listData.add(list);
  137.  
  138.          }
  139.  
  140.          flag = true;
  141.  
  142.          for (int i = 0; i < listData.size(); i++) {
  143.              for (int j = 0; j < listData.get(i).size(); j++) {
  144.                  System.out.println(listData.get(i).get(j).toString());
  145.              }
  146.          }
  147.  
  148.      }
  149.  
  150.      public String getCellData(int row, int col) {
  151.          if (row <= 0 || col <= 0) {
  152.              return null;
  153.          }
  154.          if (!flag) {
  155.              this.getSheetData();
  156.          }
  157.          if (listData.size() >= row && listData.get(row - 1).size() >= col) {
  158.              return listData.get(row - 1).get(col - 1);
  159.          } else {
  160.              return null;
  161.          }
  162.      }
  163.  
  164.      public String getCellData(int row, String headerName) {
  165.          if (row <= 0) {
  166.              return null;
  167.          }
  168.          if (!flag) {
  169.              this.getSheetData();
  170.          }
  171.          if (mapData.size() >= row && mapData.get(row - 1).containsKey(headerName)) {
  172.              return mapData.get(row - 1).get(headerName);
  173.          } else {
  174.              return null;
  175.          }
  176.      }
  177.  
  178.      public Object[][] getSheetData2() {
  179.  
  180.          List<Object[]> result = new ArrayList<>();
  181.          listData = new ArrayList<>();
  182.          mapData = new ArrayList<>();
  183.          columnHeaderList = new ArrayList<>();
  184.  
  185.          int numOfRows = sheet.getLastRowNum() + 1;
  186.          //    System.out.println("总共有 " + numOfRows + " 行 ！");
  187.          for (int i = 0; i < numOfRows; i++) {
  188.              Row row = sheet.getRow(i);
  189.              Map<String, String> map = new HashMap<>();
  190.              List<String> list = new ArrayList<>();
  191.              Object[] o1 = new Object[row.getLastCellNum()];
  192.  
  193.              if (row != null) {
  194.                  for (int j = 0; j <= 3/*row.getLastCellNum()*/; j++) {
  195.                      //   System.out.println("第 "+i+" 行--- row.getLastCellNum()===="+row.getLastCellNum());
  196.                      Cell cell = row.getCell(j);
  197.                      if (i == 0) {
  198.                          o1[j] = this.getCellValue(cell);
  199.                          //       System.out.println(j+"------this.getCellValue(cell)="+this.getCellValue(cell));
  200.                          columnHeaderList.add(getCellValue(cell));
  201.                      } else {
  202.                          o1[j] = this.getCellValue(cell);
  203.                          // System.out.println(j+"------this.getCellValue(cell)="+this.getCellValue(cell));
  204.                          map.put(columnHeaderList.get(j), this.getCellValue(cell));
  205.  
  206.                      }
  207.                      list.add(this.getCellValue(cell));
  208.                  }
  209.              }
  210.              if (i > 0) {
  211.                  mapData.add(map);
  212.              }
  213.              result.add(o1);
  214.              listData.add(list);
  215.          }
  216.          // 测试数据excel数据用 ；
  217.        /*    for (int i = 0; i < result.size(); i++) {
  218.              for (int j = 0; j < result.get(i).length; j++) {
  219.                  System.out.print(result.get(i)[j]+" | ");
  220.              }
  221.              System.out.println();
  222.          }*/
  223.          results = new Object[result.size()][];
  224.  
  225.          for (int i = 0; i < result.size(); i++) {
  226.              results[i] = result.get(i);
  227.          }
  228.          flag = true;
  229.  
  230.          System.out.println("results.length==" + results.length);
  231.          return results;
  232.      }
  233.  }

1.1 20180131——setCellData2（）方法的更新 ；

  1.      public static void setCellData2(int rownum, int colnum, String result) {
  2.          FileOutputStream out = null;
  3.          if (null == sheet.getRow(rownum)) {
  4.              Row row1 = sheet.createRow(rownum);
  5.              if (null == row1.getCell(colnum)) {
  6.                  row1.createCell(colnum).setCellValue(result);
  7.              } else {
  8.                  row.getCell(colnum).setCellValue(result);
  9.              }
  10.          } else {
  11.              sheet.getRow(rownum).createCell(colnum).setCellValue(result);
  12.  
  13.          }
  14.  
  15.          try {
  16.              out = new FileOutputStream(ExcelFilePath);
  17.              workBook.write(out);
  18.              out.flush();
  19.  
  20.          } catch (IOException e) {
  21.              e.printStackTrace();
  22.          }finally {
  23.              try {
  24.                  out.close();
  25.                  System.out.println("-----写入成功！------");
  26.              } catch (Exception e) {
  27.                  e.printStackTrace();
  28.              }
  29.          }
  30.  
  31.      }

2.ExcleUtil --读取和设置单元格的值 ；

  1.  package main.java;
  2.  
  3.  import java.io.File;
  4.  import java.io.FileInputStream;
  5.  import java.io.FileOutputStream;
  6.  import java.util.ArrayList;
  7.  import java.util.List;
  8.  
  9.  import org.apache.poi.hssf.usermodel.HSSFWorkbook;
  10.  import org.apache.poi.ss.usermodel.Row;
  11.  import org.apache.poi.ss.usermodel.Sheet;
  12.  import org.apache.poi.ss.usermodel.Workbook;
  13.  import org.apache.poi.xssf.usermodel.XSSFCell;
  14.  import org.apache.poi.xssf.usermodel.XSSFRow;
  15.  import org.apache.poi.xssf.usermodel.XSSFSheet;
  16.  import org.apache.poi.xssf.usermodel.XSSFWorkbook;
  17.  
  18.  public class ExcleUtil {
  19.      private static XSSFSheet ExcelWSheet;
  20.      private static XSSFWorkbook ExcelWBook;
  21.      private static XSSFCell Cell;
  22.      private static XSSFRow Row;
  23.      private static String ExcelFilePath="C:\\C\\TEST1.xlsx";
  24.  
  25.      // 设定要设置的Excel的文件路径和Excel 中Sheet名；
  26.      // 在读/写Excel 的时候先要调用此方法
  27.      public static void setExcleFile(String FilePath, String sheetName) throws Exception {
  28.          FileInputStream ExcleFile;
  29.          try {
  30.              // 实例化Excle文件的FileInputStream 对象；
  31.              ExcleFile = new FileInputStream(FilePath);
  32.              // 实例化Excle文件的XSSFWorkbook 对象；
  33.              ExcelWBook = new XSSFWorkbook(ExcleFile);
  34.              /*
  35.               * 实例化XSSFSheet 对象，指定ExcelFile中的sheet名称，用于后续对sheet中行和列的操作；
  36.               *
  37.               */
  38.              ExcelWSheet = ExcelWBook.getSheet(sheetName);
  39.  
  40.          } catch (Exception e) {
  41.              e.getStackTrace();
  42.          }
  43.  
  44.      }
  45.      /*
  46.       * 读取excle文件指定单元格的函数 ；
  47.       *
  48.       */
  49.  
  50.      public static String getCell(int row, int col) throws Exception {
  51.  
  52.          try {
  53.              // 通过函数参数指定单元格的行号和列，获取指定单元格的对象；
  54.              Cell = ExcelWSheet.getRow(row).getCell(col);
  55.              /*
  56.               * 1.如果单元格的类型为字符串类型，使用getStringCellValue();来获取单元格的内容；
  57.               * 2.如果单元格的类型为数字类型，使用getNumberricCellValue();来获取单元格的内容；
  58.               * 注意：getNumberricCellValue();返回的值为double类型，转为为字符串类型，必须在
  59.               * getNumberricCellValue();前面加上（" "）双引号，用于强制转换为String类型，不加双引号
  60.               * 则会抛错；double类型无法转换为String类型的异常；
  61.               *
  62.               */
  63.              String CellData = Cell.getCellType() == XSSFCell.CELL_TYPE_STRING ? Cell.getStringCellValue() + ""
  64.                      : String.valueOf(Math.round(Cell.getNumericCellValue()));
  65.              return CellData;
  66.          } catch (Exception e) {
  67.              e.getStackTrace();
  68.              return "";
  69.          }
  70.  
  71.      }
  72.      /*
  73.       * 在Excle中执行单元格写入数据；
  74.       *
  75.       *
  76.       */
  77.  
  78.      public static void setCellData(int rownum, int colnum, String Result) throws Exception {
  79.  
  80.          try {
  81.              // 获取excle文件的中行对象；
  82.              Row = ExcelWSheet.getRow(rownum);
  83.              // 如果单元格为空则返回null；
  84.              Cell = Row.getCell(colnum, Row.RETURN_BLANK_AS_NULL);
  85.              if (Cell == null) {
  86.                  // 当单元格为空是则创建单元格
  87.                  // 如果单元格为空无法调用单元格对象的setCellValue方法设定单元格的值 ；
  88.                  Cell = Row.createCell(colnum);
  89.                  // 创建单元格和后可以通过调用单元格对象的setCellValue方法设置单元格的值了；
  90.                  Cell.setCellValue(Result);
  91.              } else {
  92.                  // 单元格中有内容，则可以直接调用单元格对象的 setCellValue 方法来设置单元格的值；
  93.                  Cell.setCellValue(Result);
  94.              }
  95.              FileOutputStream fileout = new FileOutputStream(ExcelFilePath);
  96.              // 将内容写到Excel文件中 ；
  97.              ExcelWBook.write(fileout);
  98.              // j调用flush方法强制刷新写入文件；
  99.              fileout.flush();
  100.              fileout.close();
  101.              System.out.println("-----写入成功！------");
  102.          } catch (Exception e) {
  103.              System.out.println(e.getMessage() + e.getStackTrace());
  104.              throw (e);
  105.          }
  106.  
  107.      }
  108.  
  109.      public static void TangsetCellData(int RowNum, int ColNum, String Result) {
  110.          try {
  111.              // 获取行对象
  112.              Row = ExcelWSheet.getRow(RowNum);
  113.              // 如果单元格为空，则返回null
  114.              Cell = Row.getCell(ColNum, Row.RETURN_BLANK_AS_NULL);
  115.              if (Cell == null) {
  116.                  // 当单元格对象是Null时，则创建单元格
  117.                  // 如果单元格为空，无法直接调用单元格的setCellValue方法设定单元格的值
  118.                  Cell = Row.createCell(RowNum);
  119.                  // 调用setCellValue方法设定单元格的值
  120.                  Cell.setCellValue(Result);
  121.              } else {
  122.                  // 单元格中有内容，则可以直接调用seCellValue方法设定单元格的值
  123.                  Cell.setCellValue(Result);
  124.              }
  125.              // 实例化写入Excel文件的文件输出流对象
  126.              FileOutputStream fileOut = new FileOutputStream(ExcelFilePath);
  127.              // 将内容写入Excel中
  128.              ExcelWBook.write(fileOut);
  129.              fileOut.flush();
  130.              fileOut.close();
  131.          } catch (Exception e) {
  132.              // TODO: handle exception
  133.              e.printStackTrace();
  134.          }
  135.      }
  136.  
  137.      // 从excel 文件中获取测试数据的静态方法；
  138.      public static Object[][] getTestData(String excelFilePath, String sheetName) throws Exception {
  139.          // 根据参数传入的数据文件路径和文件名称，组合出Excel 数据文件的绝对路径
  140.          // 声明一个文件；
  141.          File file = new File(excelFilePath);
  142.          // 创建FileInputStream 来读取Excel文件内容；
  143.          FileInputStream inputStream = new FileInputStream(file);
  144.          // 声明Workbook 对象；
  145.          Workbook workbook = null;
  146.          // 获取文件名参数的扩展名，判断是“.xlsx” 还是 “.xls” ；
  147.          String fileExtensionName = excelFilePath.substring(excelFilePath.indexOf('.'));
  148.          if (fileExtensionName.equals(".xlsx")) {
  149.              workbook = new XSSFWorkbook(inputStream);
  150.  
  151.          } else if (fileExtensionName.equals(".xls")) {
  152.              workbook = new HSSFWorkbook(inputStream);
  153.  
  154.          }
  155.          Sheet sheet = workbook.getSheet(sheetName);
  156.          // 获取Excel 数据文件Sheet1 中数据的行数，getLastRowNum 方法获取数据的最后一行的行号，
  157.          // getFistRowNum 获取第一行 最后一行减去第一行就是总行数了
  158.          // 注意excle 的行和列都是从0开始的；
  159.          int rowCount = sheet.getLastRowNum() - sheet.getFirstRowNum();
  160.          // 创建名为records 的List对象来存储从Excel文件中读取的数据；
  161.          List<Object[]> records = new ArrayList<Object[]>();
  162.          // 使用for循环遍历Excel 数据文件的所有数据（除了第一行，第一行为标题行），所以i从1开始而不是从0开始；
  163.  
  164.          for (int i = 1; i < rowCount + 1; i++) {
  165.              // 使用getRow来获取行对象；
  166.              Row row = sheet.getRow(i);
  167.              /*
  168.               * 声明一个数据，用来存储Excel数据文件每行中的测试用例和数据，数据的大小用getLastCellNum-2
  169.               * 来进行动态声明，实现测试数据个数和数组大小一致，
  170.               * 因为Excel数据文件中的测试数据行的最后一个单元格是测试执行结果，倒数第二个单元格为此测试数据行是否运行的状态位，
  171.               * 所以最后俩列的单元格数据并
  172.               * 不需要传入测试方法中，所以是用getLastCellNum-2的方式去掉每行中的最后俩个单元格数据，计算出需要存储的测试数据个数，
  173.               * 并作为测试数据数组的初始化大小
  174.               *
  175.               */
  176.              String fields[] = new String[row.getLastCellNum() - 2];
  177.  
  178.              /*
  179.               * 判断数据行是否要参与测试的执行，Excel 文件的倒数第二列为数据行的状态位， 标记为“y”
  180.               * 表示此数据行要被测试脚本执行，标记为非“y”的数据行均被认为不会参数测试脚本执行，会被跳过；
  181.               */
  182.  
  183.              if (row.getCell(row.getLastCellNum() - 2).getStringCellValue().equals("y")) {
  184.                  for (int j = 0; j < row.getLastCellNum() - 2; j++) {
  185.                      /*
  186.                       * 判断Excel 单元格的内容是数字还是字符， 字符格式调用：
  187.                       * row.getCell(j).getStringCellValue()；
  188.                       * 数字格式调用：row.getCell(j).getNumericCellValue()；
  189.                       */
  190.                      fields[j] = (String) (row.getCell(j).getCellType() == XSSFCell.CELL_TYPE_STRING
  191.                              ? row.getCell(j).getStringCellValue() : "" + row.getCell(j).getNumericCellValue());
  192.  
  193.                  }
  194.                  // fields 存储到数组当中；
  195.                  records.add(fields);
  196.  
  197.              }
  198.          }
  199.  
  200.          /*
  201.           * 定义函数的返回值，即Object[] [] 将存储测试数据的list 转换为一个Object 的二维数组；
  202.           */
  203.          Object[][] results = new Object[records.size()][];
  204.          for (int i = 0; i < records.size(); i++) {
  205.              results[i] = records.get(i);
  206.          }
  207.  
  208.          return results;
  209.  
  210.      }
  211.  
  212.      public static int getLastColumnNum() {
  213.  
  214.          return ExcelWSheet.getRow(0).getLastCellNum() - 1;
  215.      }
  216.  
  217.      public static void main(String[] args) throws Exception {
  218.  
  219.          //ExcleUtil.setCellData(3,3,"hellojava!");
  220.          //System.out.println(ExcleUtil.getCell(3,1) );
  221.                 ;
  222.  
  223.      }
  224.  
  225.  }

3.HttpInterfaceTest --接口 get 和 post 的方法 ；

  1.  package main.java;
  2.  import net.sf.json.JSONObject;
  3.  import java.io.BufferedReader;
  4.  import java.io.IOException;
  5.  import java.io.InputStreamReader;
  6.  import java.io.PrintWriter;
  7.  import java.net.URL;
  8.  import java.net.URLConnection;
  9.  import java.util.List;
  10.  import java.util.Map;
  11.  
  12.  /**
  13.   * Created by ty on 2017/8/17.
  14.   */
  15.  public class HttpInterfaceTest {
  16.  
  17.      public String sendGet(String url, String param) {
  18.          String result = "";
  19.          BufferedReader in = null;
  20.          try {
  21.              String urlName = url + "?" + param;
  22.              System.out.println("Get请求接口:" + urlName);
  23.              URL realUrl = new URL(urlName);
  24.              // 打开和URL之间的连接
  25.              URLConnection conn = realUrl.openConnection();
  26.              // 设置通用的请求属性
  27.              conn.setRequestProperty("accept", "*/*");
  28.              conn.setRequestProperty("connection", "Keep-Alive");
  29.              conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");
  30.              // 建立实际的连接
  31.              conn.connect();
  32.              // 获取所有响应头字段
  33.              Map<String, List<String>> map = conn.getHeaderFields();
  34.              // 遍历所有的响应头字段
  35.              for (String key : map.keySet()) {
  36.                  System.out.println(key + "--->" + map.get(key));
  37.              }
  38.              // 定义BufferedReader输入流来读取URL的响应
  39.              in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
  40.              String line;
  41.              while ((line = in.readLine()) != null) {
  42.                  result += "\n" + line;
  43.              }
  44.          } catch (Exception e) {
  45.           //   System.out.println("发送GET请求出现异常！" + e);
  46.              e.printStackTrace();
  47.          }
  48.          // 使用finally块来关闭输入流
  49.          finally {
  50.              try {
  51.                  if (in != null) {
  52.                      in.close();
  53.                  }
  54.              } catch (IOException ex) {
  55.                  ex.printStackTrace();
  56.              }
  57.          }
  58.          return result;
  59.      }
  60.  
  61.      /**
  62.       * 向指定URL发送POST方法的请求
  63.       *
  64.       * @param url   发送请求的URL
  65.       * @param param 请求参数，请求参数应该是name1=value1&name2=value2的形式或者是json。
  66.       * @return URL所代表远程资源的响应
  67.       */
  68.      public String sendPost(String url, String param) {
  69.          PrintWriter out = null;
  70.          BufferedReader in = null;
  71.          String result = "";
  72.          String jsonName="Content=";
  73.          try {
  74.              URL realUrl = new URL(url);
  75.              // 打开和URL之间的连接
  76.              URLConnection conn = realUrl.openConnection();
  77.              // 设置通用的请求属性
  78.              conn.setRequestProperty("accept", "*/*");
  79.              conn.setRequestProperty("connection", "Keep-Alive");
  80.           conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)") ;
  81.              //Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0)
  82.             // conn.setRequestProperty("Content-Type", "application/json; charset=utf-8");
  83.              conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=utf-8");
  84.             // application/x-www-form-urlencoded
  85.              // 发送POST请求必须设置如下两行
  86.              conn.setDoOutput(true);
  87.              conn.setDoInput(true);
  88.  
  89.              // 获取URLConnection对象对应的输出流
  90.              out = new PrintWriter(conn.getOutputStream());
  91.              // 发送请求参数
  92.              out.print(jsonName+param);
  93.              System.out.println("jsonName+param="+jsonName+param);
  94.              // flush输出流的缓冲
  95.              out.flush();
  96.              // 定义BufferedReader输入流来读取URL的响应
  97.              in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
  98.              String line;
  99.              while ((line = in.readLine()) != null) {
  100.                  result += "\n" + line;
  101.              }
  102.          } catch (Exception e) {
  103.              System.out.println("Send Post Excepion :" + e);
  104.              e.printStackTrace();
  105.          }
  106.          // 使用finally块来关闭输出流、输入流
  107.          finally {
  108.              try {
  109.                  if (out != null) {
  110.                      out.close();
  111.                  }
  112.                  if (in != null) {
  113.                      in.close();
  114.                  }
  115.              } catch (IOException ex) {
  116.                  ex.printStackTrace();
  117.              }
  118.          }
  119.          return result;
  120.      }
  121.  
  122.    /*  public static void main(String[] args) {
  123.  
  124.          HttpInterfaceTest httpInterfaceTest = new HttpInterfaceTest();
  125.  
  126.          System.out.println("----------------");
  127.           String cissUrl="http://192.168.1.110:7001/CISS/MSG/callTrxMsgManager.action";
  128.          String PostValue = "{MESSAGEID:'ZTS00120170914110859000043',\n" +
  129.                  "INTERFACETYPE:'S001',\n" +
  130.                  "UNITID:'10001',\n" +
  131.                  "CNFULLNAME:'测试机构12222',\n" +
  132.                  "CNABBRNAME:'测试机构12222',\n" +
  133.                  "PINYIN:'CSJG1222',\n" +
  134.                  "ENFULLNAME:'CESHIJIGOU',\n" +
  135.                  "ENABBRNAME:'CESHIJIGOU'\n" +
  136.                  "}";
  137.  
  138.          JSONObject CissjsonPostParams = JSONObject.fromObject(PostValue);
  139.          String postResult = httpInterfaceTest.sendPost(cissUrl, CissjsonPostParams.toString());
  140.          System.out.println("POST请求参数二：" + CissjsonPostParams);
  141.          System.out.println( postResult);
  142.      }*/
  143.  }

4.TestHttpInterfaceTest ---1 。2 。3 联合测试接口；

  1.  package main.test;
  2.  
  3.  import main.java.DateUtil;
  4.  import main.java.ExcelReader;
  5.  import main.java.ExcleUtil;
  6.  import main.java.HttpInterfaceTest;
  7.  import net.sf.json.JSONException;
  8.  import net.sf.json.JSONObject;
  9.  import org.testng.annotations.BeforeTest;
  10.  import org.testng.annotations.DataProvider;
  11.  import org.testng.annotations.Test;
  12.  
  13.  import java.text.SimpleDateFormat;
  14.  import java.util.Date;
  15.  
  16.  /**
  17.   * Created by  on 2017/9/5.
  18.   */
  19.  public class TestHttpInterfaceTest {
  20.      public static HttpInterfaceTest ht;
  21.      static ExcleUtil excleUtil;
  22.      ExcelReader ex;
  23.      SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  24.      ;
  25.      @BeforeTest
  26.      public void init() {
  27.          String ExcelFilePath = "C:\\C\\TEST1.xlsx";
  28.          String sheetName = "Sheet1";
  29.          ht = new HttpInterfaceTest();
  30.          ex = new ExcelReader(ExcelFilePath, sheetName);
  31.          try {
  32.              excleUtil.setExcleFile(ExcelFilePath, sheetName);
  33.          } catch (Exception e) {
  34.              e.printStackTrace();
  35.          }
  36.      }
  37.  
  38.      @Test(dataProvider = "dp")
  39.      public void testSendPost(Object... obj) throws Exception {
  40.          String rowNum = "";
  41.          String Url = "";
  42.          String effect = "";
  43.          String paras = "";
  44.          String Contents = "";
  45.          String times = "";
  46.          for (int i = 0; i < obj.length; i++) {
  47.              rowNum = (String) obj[0];
  48.              Url = (String) obj[1];
  49.              effect = (String) obj[2];
  50.              paras = (String) obj[3];
  51.  
  52.          }
  53.          //String rowNum, String Url, String effect, String paras,String Contents ,String times
  54.          System.out.println("rowNum=" + rowNum + "；  URL=" + Url + " ;" + effect + "   paras=" + paras + Contents + times);
  55.          Integer it = new Integer(rowNum);
  56.          int row = it.intValue();
  57.          if (paras.contains("&")) {
  58.              String s1 = ht.sendPost(Url, paras);
  59.              String date = DateUtil.format();
  60.              excleUtil.setCellData(row, 3, s1);
  61.              excleUtil.setCellData(row, 4, date);
  62.              System.out.println(s1);
  63.          } else {
  64.              try {
  65.                 /* JSONObject jsonObject = JSONObject.fromObject(paras);
  66.                  String s  =  ht.sendPost(Url, jsonObject.toString());*/
  67.                  String testTimes =df.format(new Date());
  68.                  String s = ht.sendPost(Url, paras);
  69.                  JSONObject jsonObject = JSONObject.fromObject(s);
  70.                  String MESSAGEID = jsonObject.getString("MESSAGEID");
  71.                  String RESULTCODE = jsonObject.getString("RESULTCODE");
  72.                  if (RESULTCODE.equals("0")) {
  73.                      excleUtil.setCellData(row, 4, RESULTCODE + ":ACK成功");
  74.                      excleUtil.setCellData(row, 5, df.format(new Date()));
  75.                  } else if (RESULTCODE.equals("E000")) {
  76.                      excleUtil.setCellData(row, 4, RESULTCODE + "其他");
  77.                      excleUtil.setCellData(row, 5, df.format(new Date()));
  78.                  } else if (RESULTCODE.equals("E001")) {
  79.                      excleUtil.setCellData(row, 4, RESULTCODE + "必填项数据为空值");
  80.                      excleUtil.setCellData(row, 5, df.format(new Date()));
  81.                  } else if (RESULTCODE.equals("E002")) {
  82.                      excleUtil.setCellData(row, 4, RESULTCODE + "必填项在数据库中没有匹配数据");
  83.                      excleUtil.setCellData(row, 5, df.format(new Date()));
  84.                  } else if (RESULTCODE.equals("E003")) {
  85.                      excleUtil.setCellData(row, 4, RESULTCODE + "唯一项在数据库中重复");
  86.                      excleUtil.setCellData(row, 5, df.format(new Date()));
  87.                  } else if (RESULTCODE.equals("E004")) {
  88.                      excleUtil.setCellData(row, 4, RESULTCODE + "传过来的关键字段不同属于一条记录;");
  89.                      excleUtil.setCellData(row, 5, df.format(new Date()));
  90.                  } else if (RESULTCODE.equals("E005")) {
  91.                      excleUtil.setCellData(row, 4, RESULTCODE + "没有满足前提条件。如：当前日期范围内还没有维护汇率信息，请先行维护！");
  92.                      excleUtil.setCellData(row, 5, df.format(new Date()));
  93.                  } else if (RESULTCODE.equals("E006")) {
  94.                      excleUtil.setCellData(row, 4, RESULTCODE + "类型转化异常,");
  95.                      excleUtil.setCellData(row, 5, df.format(new Date()));
  96.                  } else if (RESULTCODE.equals("E007")) {
  97.                      excleUtil.setCellData(row, 4, RESULTCODE + " 所填数据不在给定范围内 ");
  98.                      excleUtil.setCellData(row, 5, df.format(new Date()));
  99.                  } else if (RESULTCODE.equals("E008")) {
  100.                      excleUtil.setCellData(row, 4, RESULTCODE + " 数据格式不正确 ");
  101.                      excleUtil.setCellData(row, 5, df.format(new Date()));
  102.                  } else if (RESULTCODE.equals("E009")) {
  103.                      excleUtil.setCellData(row, 4, RESULTCODE + "在当前数据状态下不能进行操作");
  104.                      excleUtil.setCellData(row, 5, df.format(new Date()));
  105.                  } else if (RESULTCODE.equals("E010")) {
  106.                      excleUtil.setCellData(row, 4, RESULTCODE + " 该经纪人已在清算系统中存在，状态：正常 ");
  107.                      excleUtil.setCellData(row, 5, df.format(new Date()));
  108.                  } else if (RESULTCODE.equals("E011")) {
  109.                      excleUtil.setCellData(row, 4, RESULTCODE + " 该经纪人已在清算系统中存在，状态：禁用");
  110.                      excleUtil.setCellData(row, 5, df.format(new Date()));
  111.                  }
  112.  
  113.                  System.out.println(s);
  114.              } catch (JSONException jsonException) {
  115.                  excleUtil.setCellData(row, 4, " 响应结果 ");
  116.                  excleUtil.setCellData(row, 5, " 响应时间 ");
  117.                  System.out.println("标题行不能进行转换！");
  118.              } catch (Exception e) {
  119.                  excleUtil.setCellData(row, 4, " Exception  ");
  120.                  excleUtil.setCellData(row, 5, "  Exception");
  121.                  e.printStackTrace();
  122.                  System.out.println("标题行不能进行转换！");
  123.              }
  124.  
  125.          }
  126.  
  127.      }
  128.  
  129.      @DataProvider
  130.      public Object[][] dp() {
  131.          Object[][] sheetData2 = ex.getSheetData2();
  132.          System.out.println(sheetData2.length + "------------");
  133.          for (int i = 1; i < sheetData2.length; i++) {
  134.              for (int j = 0; j < sheetData2[i].length - 1; j++) {
  135.                  System.out.print(sheetData2[i][j] + " | ");
  136.              }
  137.              System.out.println();
  138.          }
  139.  
  140.          return sheetData2;
  141.      }
  142.  }

第二版_TestNG+Excel+(HTTP+JSON) 简单接口测试的更多相关文章

  1. TestNG+Excel+(HTTP+JSON) 简单接口测试

    说明: 1.使用Exce作为数据存放地: 2.使用TestNG的Datarprovide 做数据供应: 3.不足的地方没有指定明确的result_code , error_code , ERROR_M ...

  2. 《代码大全(第二版)》【PDF】下载

    <代码大全(第二版)>[PDF]下载链接: https://u253469.pipipan.com/fs/253469-230382264 内容简介 <代码大全(第2版)>是著 ...

  3. 利用MYSQL的函数实现用户登录功能，进出都是JSON(第二版)

    利用MYSQL的函数实现用户登录功能,进出都是JSON(第二版) CREATE DEFINER=`root`@`%` FUNCTION `uc_session_login`( `reqjson` JS ...

  4. 一套简单的web即时通讯——第二版

    前言 接上一版,这一版的页面与功能都有所优化,具体如下: 1.优化登录拦截 2.登录后获取所有好友并区分显示在线.离线好友,好友上线.下线都有标记 3.将前后端交互的值改成用户id.显示值改成昵称ni ...

  5. 简单的web三层架构系统【第二版】

    昨天写了 web三层架构的第一版,准确的说是三层架构的前期,顶多算是个二层架构,要慢慢完善. 第一版里,程序虽说能运行起来,但是有一个缺陷,就是里面的SQL语句,是使用的拼接字符进行执行.这样安全系数 ...

  6. Lucene.net站内搜索—6、站内搜索第二版

    目录 Lucene.net站内搜索—1.SEO优化 Lucene.net站内搜索—2.Lucene.Net简介和分词Lucene.net站内搜索—3.最简单搜索引擎代码Lucene.net站内搜索—4 ...

  7. 锋利的jQuery（第二版）学习总结

    通过对<锋利的jQuery>(第二版)一书的学习,发现此书讲解通俗易懂,是学习jQuery的一本很好的指导书,特作如下总结. 此书主要讲解了jQuery的常用操作,包括认识jQuery,j ...

  8. Python核心编程(第二版)PDF

    Python核心编程(第二版) 目录 第1部分 Python核心第1章 欢迎来到Python世界1.1 什么是Python1.2 起源1.3 特点1.3.1 高级1.3.2 面向对象1.3.3 可升级 ...

  9. Python——Excel转Json工具

    Python工具Excel转Json 前置条件 1.安装python 下载python 我下载的是2.7: 2.配置环境变量 我的电脑右键--属性--高级系统设置--环境变量: 添加python的安装 ...

随机推荐

  1. Noip前的大抱佛脚----图论

    目录 图论 知识点 二分图相关 DFS找环 并查集维护二分图 二分图匹配的不可行边 最小生成树相关 最短路树 最短路相关 负环 多源最短路 差分约束系统 01最短路 k短路 网络流 zkw费用流 做题 ...

  2. 一维码Codabar简介及其解码实现(zxing-cpp)

    一维码Codabar:由4条黑色线条,3条白色线条,合计7条线条所组成,每一个字元与字元之间有一间隙Gap做区隔. 条形码Codabar包含21个字元: (1).10个数字0~9; (2)." ...

  3. iTerm的安装以及配置Oh My Zsh

    iTerm说简单点就是Windows的命令提示符,可能说这个大家感觉没用过,其实也就是人们经常使用CMD,相当于苹果的终端,但是比自带的终端强大多了. 本文就是简单的说一下安装和简单的配置过程. 首先 ...

  4. excel 取前几位文字

    1L.2L的分别用mid函数和left函数都没有问题. 问题是,如果用left函数,必须先确认,字符串中汉字必须排在左边第一个,接下来几个也必须是汉字:mid函数则是根据从左边第某个字符开始,一共取几 ...

  5. python的类和对象2（self参数）

    python的类和对象2(self参数) 1.python里面对象的方法都会有self参数,它就相当于C++里面的this指针:绑定方法,据说有了这个参数,Python 再也不会傻傻分不清是哪个对象在 ...

  6. 《杜增强讲Unity之Tanks坦克大战》2-场景设置

    2  场景设置 2.1 本节效果预览   2.2 项目目录设置 点击Project面板的Create按钮,在根目录下面新建wm文件夹   Wm文件夹用于存放我们自己生成的Prefab和脚本等其他资源, ...

  7. TP里where的查询方式，比如or应该怎么写？

    这应该是个基础..只是我没有系统的学TP,所以用到了临时查了手册. 正常来说,thinkphp里的查询方式是: ThinkPHP可以支持直接使用字符串作为查询条件,但是大多数情况推荐使用数组或者对象来 ...

  8. log4cpp简单使用及踩到的坑

    log4cpp是log4j的一个扩展, C++开发者可用该库记录日志,可输出到终端,亦可保存到文件. 下面简单demo展示如何输出日志到输出终端. #include <iostream> ...

  9. Spring Boot之拦截器与过滤器（完整版）

    作者:liuxiaopeng 链接:http://www.cnblogs.com/paddix 作者:蓝精灵lx原文:https://blog.csdn.net/liuxiao723846/artic ...

  10. Hyperledger Fabric CA User’s Guide——CA用户指南（一）

    Fabric CA用户指南 Hyperledger Fabric CA是一种用于Hyperledger Fabric的认证机构(CA). 它提供了如下特性: 登记身份(注册ID),或者连接到作为用户注 ...