Java + Excel 接口自动化

最近项目比较悠闲，想找点事干，写了个 Excel 接口测试的 "框架" 以前用 python 写过一个，这次用 java, 应该说框架都不算，反正就是写了，能帮我解决问题就行。

当然咯，也许会问干嘛那么麻烦直接用 feed4testng, 或者 testng 就行了，没事找事干还专门写个这玩意... 呵呵，就闲的蛋疼！

文笔有限不知道怎么写，直接上代码：

欢迎各位指定，或提出好的意见，总觉得还有很多不好的地方。

结构就这破样了， E 文也不好， 随便捣鼓，开心就好。 哈哈

ExcelUtil.java 类：

 package com.hozhu.excel;

 import java.io.BufferedInputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import org.apache.log4j.Logger;
 import org.apache.poi.ss.usermodel.CellStyle;
 import org.apache.poi.ss.usermodel.IndexedColors;
 import org.apache.poi.xssf.usermodel.XSSFCell;
 import org.apache.poi.xssf.usermodel.XSSFCellStyle;
 import org.apache.poi.xssf.usermodel.XSSFRow;
 import org.apache.poi.xssf.usermodel.XSSFSheet;
 import org.apache.poi.xssf.usermodel.XSSFWorkbook;

 /**
  * 只支持读取 .xlsx 所有方法读取数据时, 未对 Excel 格式类型进行判断处理 如 Excel 中有特殊数据类型, 需在 Excel
  * 中标注为文本类型, 程序才能正常处理
  *
  * @author Roger
  * @version 1.0
  */
 public class ExcelUtil {
     private static Logger logger = Logger.getLogger(ExcelUtil.class);

     private String filePath = null;
     private String sheetName = null;

     public String getSheetName() {
         return sheetName;
     }

     public void setSheetName(String sheetName) {
         this.sheetName = sheetName;
     }

     public String getFilePath() {
         return filePath;
     }

     public void setFilePath(String filePath) {
         this.filePath = filePath;
     }

     /**
      * 判断成员变量 filePath 是否为空
      *
      * @return
      */
     private boolean isFilePathEmpty() {
         boolean flag = false;
         if ((null != filePath && (!filePath.equals("")))) {
             flag = true;
         }
         return flag;
     }

     private boolean isSheetNameEmpty() {
         boolean flag = false;
         if ((null != sheetName && (!sheetName.equals("")))) {
             flag = true;
         }
         return flag;
     }

     // 使用静态内部类创建外部类对象
     private static class Excel {
         private static ExcelUtil excelUtil = new ExcelUtil();
     }

     private ExcelUtil() {
     }

     // 获取 ExcelUtil 实例
     public static ExcelUtil getInstance() {
         return Excel.excelUtil;
     }

     /**
      * 检查传入的文件后缀是否为 xlsx
      *
      * @param filePacht
      * @return
      */
     public boolean checkXlsx(File file) {
         boolean flag = false;

         if (file.exists()) {
             String str = file.getName();
             if (str.substring(str.lastIndexOf(".") + 1).equals("xlsx"))
                 flag = true;
         } else {
             logger.info(file.getName() + ", 文件不存在...");
             // System.out.println("文件不存在...");
         }

         return flag;
     }

     /**
      *
      * @param file
      * @return true: 文件未被操作; false: 文件正在被操作.
      */
     public boolean isFile(File file) {
         return file.renameTo(file);
     }

     public File createFile() {
         File file = null;
         if (isFilePathEmpty()) {
             file = new File(filePath);
         } else {
             logger.error("filePath 不能为: "
                     + filePath
                     + ", 请先使用 'ExcelUtil.getInstance().setFilePath(filePath)' 设置!");
             // System.out.println("filePath 不能为: " + filePath +
             // ", 请先使用 'ExcelUtil.getInstance().setFilePath(filePath)' 设置!");
             System.exit(-1);
         }
         return file;
     }

     /**
      * 创建 XSSFWorkbook
      *
      * @param 文件路径
      * @return
      */
     public XSSFWorkbook createExcelWorkBook() {
         File file = createFile();

         BufferedInputStream in = null;
         XSSFWorkbook book = null;

         if (checkXlsx(file)) {
             try {
                 in = new BufferedInputStream(new FileInputStream(file));
                 book = new XSSFWorkbook(in);
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         return book;
     }

     /**
      * 创建 XSSFSheet
      *
      * @param sheetName
      * @return
      */
     public XSSFSheet createExcelSheet(String sheetName) {
         XSSFSheet sheet = null;
         if (isSheetNameEmpty()) {
             XSSFWorkbook book = createExcelWorkBook();
             if (book != null) {
                 int sheetCount = book.getNumberOfSheets();
                 for (int i = 0; i < sheetCount; i++) {
                     if (sheetName.equals(book.getSheetName(i))) {
                         sheet = book.getSheet(sheetName);
                         break;
                     }
                 }
             }
         } else {
             logger.error("sheetName 不能为: "
                     + sheetName
                     + ", 请先使用 'ExcelUtil.getInstance().setSheetName(SheetName)' 设置!");
             // System.out.println("sheetName 不能为: " + sheetName +
             // ", 请先使用 'ExcelUtil.getInstance().setSheetName(SheetName)' 设置!");
             System.exit(-1);
         }

         return sheet;
     }

     /**
      * 获取指定行
      *
      * @param sheetName
      * @param line
      *            行索引, 从 0 开始
      * @return
      */
     public XSSFRow getExcelRow(int line) {
         XSSFRow row = null;
         if (line <= getSheetMaxRow())
             row = createExcelSheet(sheetName).getRow(line);
         return row;
     }

     /**
      * 获取指定 sheet 中最大行数
      *
      * @param sheetName
      * @return
      */
     public int getSheetMaxRow() {
         int maxRow = -1;
         if (createExcelSheet(sheetName) != null)
             maxRow = createExcelSheet(sheetName).getLastRowNum();
         return maxRow;
     }

     /**
      * 使用正则表达式去掉多余的.与0
      *
      * @param s
      * @return
      */
     private String subZeroAndDot(String s) {
         if (s.indexOf(".") > 0) {
             // 去掉多余的 0
             s = s.replaceAll("0+?$", "");
             // 如果最后一位是.则去掉
             s = s.replaceAll("[.]$", "");
         }
         return s;
     }

     /**
      * 获取 Excel 指定行数据
      *
      * @param sheetName
      * @param line
      * @return 返回一个一维数组
      */
     public String[] readExcelRows(int line) {
         String[] result = null;
         XSSFRow row = getExcelRow(line);
         int maxRow = getSheetMaxRow();
         if (row != null && maxRow > -1) {
             int columnNum = row.getLastCellNum();
             result = new String[columnNum];
             for (int i = 0; i < columnNum; i++) {
                 // 判断单元格是否为空, 不进行判断时, 如遇到空白单元格时, 抛出空指针异常
                 if (null != row.getCell(i))
                     result[i] = subZeroAndDot(row.getCell(i).toString().trim());
             }
         }
         return result;
     }

     /**
      * 获取指定单元格中内容
      *
      * @param sheetName
      * @param line
      *            行
      * @param column
      *            列
      * @return
      */
     public String readExcelCell(int line, int column) {
         String[] value = null;
         String result = "";
         value = readExcelRows(line);
         if (value != null) {
             result = value[column];
         }
         return result;
     }

     /**
      * 从指定行开始读取 Excel 中所有数据
      *
      * @param sheetName
      *            sheet 名称
      * @param line
      *            表标题所在行
      * @return 返回一个包含 HashMap<String, String> 的 ArrayList; 格式：[{第一行数据},{第二行数据}]
      *         {列 1 标题 = 列 1 值, 列 2 标题 = 列 2 值}
      */
     public List<Map<String, String>> readExcelAllData(int line) {
         List<Map<String, String>> result = new ArrayList<Map<String, String>>();
         // 读取标题行
         String[] titleRow = readExcelRows(line);
         int maxRow = getSheetMaxRow();
         XSSFRow row;
         if (null != titleRow && maxRow != -1) {
             // i = line + 1; 标题的下一行开始取数据
             for (int i = line + 1; i <= maxRow; i++) {
                 row = getExcelRow(i);
                 Map<String, String> map = new HashMap<String, String>();
                 for (int j = 0; j < row.getLastCellNum(); j++) {
                     if (null != row.getCell(j)) {
                         String value = subZeroAndDot(row.getCell(j).toString()
                                 .trim());
                         map.put(titleRow[j], value);
                     }
                 }
                 result.add(map);
             }
         }
         return result;
     }

     /**
      * 从指定数据行开始读取 Excel 所有数据
      *
      * @param sheetName
      *            sheet 名称
      * @param line
      *            数据读取开始行
      * @return
      */
     public String[][] readDataArrayAll(int line) {
         ArrayList<Object> list = new ArrayList<Object>();
         int maxRow = getSheetMaxRow();
         XSSFRow row = null;
         int columnNum = 0;
         if (maxRow != -1) {
             for (int i = line; i <= maxRow; i++) {
                 row = getExcelRow(i);
                 columnNum = row.getLastCellNum();
                 String[] values = new String[columnNum];

                 for (int j = 0; j < columnNum; j++) {
                     if (null != row.getCell(j)) {
                         String tempStr = subZeroAndDot(row.getCell(j)
                                 .toString().trim());
                         values[j] = tempStr;
                     }
                 }
                 list.add(values);
             }
         }

         String[][] result = new String[list.size()][columnNum];

         for (int i = 0; i < result.length; i++) {
             result[i] = (String[]) list.get(i);
         }
         return result;
     }

     /**
      * 从指定数据行开始读取 Excel 所有数据
      *
      * @param sheetName
      *            sheet 名称
      * @param line
      *            数据读取开始行
      * @return 返回一个包含 list 的 list; 格式 [[第一行数据],[第二行数据]]
      */
     public List<List<String>> readDataListAll(int line) {
         List<List<String>> result = new ArrayList<List<String>>();

         int maxRow = getSheetMaxRow();
         XSSFRow row = null;

         if (maxRow != -1) {
             for (int i = line; i <= maxRow; i++) {
                 row = getExcelRow(i);
                 List<String> list = new ArrayList<String>();
                 for (int j = 0; j < row.getLastCellNum(); j++) {
                     if (null != row.getCell(j)) {
                         String value = subZeroAndDot(row.getCell(j).toString()
                                 .trim());
                         list.add(value);
                     }
                 }
                 result.add(list);
             }
         }
         return result;
     }

     /**
      * 将数据写入指定单元格
      *
      * @param sheetName
      *            sheet 名称
      * @param line
      *            需写入的行
      * @param column
      *            需写入的列
      * @param content
      *            需写入的内容
      * @throws IOException
      */
     public void writeExcelCell(int line, int column, String content)
             throws IOException {
         XSSFWorkbook book = createExcelWorkBook();
         XSSFSheet sheet = book.getSheet(sheetName);

         if (line <= sheet.getLastRowNum() && line >= 0) {
             XSSFRow row = sheet.getRow(line);

             if (column < row.getLastCellNum() && column >= 0) {
                 if (isFile(createFile())) {
                     FileOutputStream out = new FileOutputStream(createFile());
                     XSSFCell cell = row.getCell(column);
                     if (null == cell) {
                         cell = row.createCell(column);
                     }
                     cell.setCellValue(content);
                     book.write(out);
                     out.close();
                 } else {
                     logger.error("文件: " + filePath + ", 正被使用, 请关闭! 程序执行终止...");
                     // System.out.println("文件: " + filePath
                     // + ", 正被使用, 请关闭! 程序执行终止...");
                     System.exit(-1);
                 }
             } else
                 logger.error("列索引越界...");
             // System.out.println("列索引越界...");
         } else
             logger.error("行索引越界...");
         // System.out.println("行索引越界...");
     }

     /**
      * 从指定行的下一行开始读取某列的所有数据
      * @param titleLineIndex  指定行读取
      * @param columnName         列名
      * @return
      */
     public String[] readExcelColumnData(int titleLineIndex, String columnName) {
         String[] result = null;
         int columnIndex = getColumnIndex(titleLineIndex, columnName);
         int maxRow = getSheetMaxRow();

         if (columnIndex != -1 && maxRow != -1) {
             result = new String[maxRow - titleLineIndex];

             for (int i = 0; i < maxRow - titleLineIndex; i++) {
                 result[i] = readExcelCell(titleLineIndex + 1 + i, columnIndex);
             }
         }
         return result;
     }

     /**
      * 获取列的索引
      *
      * @param sheetName
      *            sheet 名称
      * @param line
      *            需要获取的行
      * @param columnName
      *            列名
      * @return
      */
     public int getColumnIndex(int line, String columnName) {
         int index = -1;
         String[] title = readExcelRows(line);

         if (null != title) {
             for (int i = 0; i < title.length; i++) {
                 if (columnName.equals(title[i]))
                     index = i;
             }
         }
         return index;
     }

     /**
      * 设置单元格背景色
      *
      * @param sheetName
      *            sheet 名称
      * @param titleRow
      *            列标题所在行号, 索引 0 开始
      * @param columnName
      *            需要获取列索引的列名称
      * @param line
      *            需要设置颜色单元格所在行
      * @param color
      *            需设置的颜色; 0: 红色; 1: 绿色; 2: 灰色; 3: 黄色; 4: 白色.
      * @throws IOException
      */
     public void setCellBackgroundColor(int titleRow, String columnName,
             int line, int color) throws IOException {
         XSSFWorkbook book = createExcelWorkBook();
         XSSFSheet sheet = book.getSheet(sheetName);

         int columnIndex = getColumnIndex(titleRow, columnName);
         XSSFRow row = sheet.getRow(line);
         XSSFCell cell = row.getCell(columnIndex);
         XSSFCellStyle old = cell.getCellStyle();
         XSSFCellStyle temp = book.createCellStyle();
         temp.cloneStyleFrom(old); // 拷贝旧的样式

         switch (color) {
         case 0:
             // 红色
             temp.setFillForegroundColor(IndexedColors.RED.getIndex());
             break;
         case 1:
             // 绿色
             temp.setFillForegroundColor(IndexedColors.BRIGHT_GREEN.getIndex());
             break;
         case 2:
             // 灰色
             temp.setFillForegroundColor(IndexedColors.GREY_50_PERCENT
                     .getIndex());
             break;
         case 3:
             // 黄色
             temp.setFillForegroundColor(IndexedColors.YELLOW.getIndex());
             break;
         case 4:
             // 白色
             temp.setFillForegroundColor(IndexedColors.WHITE.getIndex());
             break;
         default:
             System.out.println("设定颜色参数 (color) 错误...");
             break;
         }

         temp.setFillPattern(CellStyle.SOLID_FOREGROUND);
         // XSSFFont font = book.createFont();
         // font.setFontHeightInPoints((short)9); // 字体大小
         // font.setFontName("宋体");
         // temp.setFont(font);
         cell.setCellStyle(temp);
         if (isFile(createFile())) {
             FileOutputStream out = new FileOutputStream(createFile());
             book.write(out);
             out.close();
         } else {
             logger.error("文件: " + filePath + ", 正被使用, 请关闭! 程序执行终止...");
             // System.out.println("文件: " + filePath + ", 正被使用, 请关闭! 程序执行终止...");
             System.exit(-1);
         }
     }

 }

HttpRequester.java类：

 package com.hozhu.api;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.PrintWriter;
 import java.net.HttpURLConnection;
 import java.net.URL;
 import java.util.HashMap;
 import java.util.Map;

 public class HttpRequester {
     /**
      * 向指定 URL 发送POST方法的请求
      *
      * @param method
      *            指定请求方法：GET, POST 等
      * @param url
      *            发送请求的 URL
      * @param param
      *            请求参数，请求参数是 name1=value1&name2=value2 的形式。
      * @return result 返回结果
      */
     public static Map<String, String> sendPost(String method, String url,
             String param) {
         PrintWriter out = null;
         BufferedReader br = null;
         String result = "";
         int responseCode = 0;
         Map<String, String> map = new HashMap<String, String>();
         try {
             // 打开和URL之间的连接
             HttpURLConnection httpConn = (HttpURLConnection) new URL(url)
                     .openConnection();

             // 发送POST请求必须设置如下两行
             // 设置可输入、 可输出
             httpConn.setDoInput(true);
             httpConn.setDoOutput(true);

             httpConn.setReadTimeout(150000);
             httpConn.setConnectTimeout(15000);

             // 连接后不自动跳转
             httpConn.setInstanceFollowRedirects(false);

             // 设置通用的请求属性
             httpConn.setRequestProperty("Accept-Charset", "utf-8");
             httpConn.setRequestProperty("User-Agent", "systempatch");
             httpConn.setRequestProperty("Accpet-Encoding", "gzip");

             // 设置提交方式
             httpConn.setRequestMethod(method);

             // httpConn.connect();

             // 获取HttpURLConnection对象对应的输出流
             out = new PrintWriter(httpConn.getOutputStream());

             // 发送请求参数
             out.print(param);
             out.flush();
             responseCode = httpConn.getResponseCode();
             map.put("code", String.valueOf(responseCode));
             // 打印 http 状态码
             // System.out.println("responseCode: " + responseCode);

             if (HttpURLConnection.HTTP_OK == responseCode) {
                 // 定义BufferedReader输入流来读取URL的响应
                 br = new BufferedReader(new InputStreamReader(
                         httpConn.getInputStream(), "utf-8"));
                 String strLine;
                 StringBuffer responseBuf = new StringBuffer();

                 while ((strLine = br.readLine()) != null) {
                     responseBuf.append(strLine);
                 }

                 result = responseBuf.toString();
                 map.put("result", result);
             }

         } catch (Exception e) {
             System.out.println("发送 POST 请求出现异常！" + e);
             e.printStackTrace();
         }
         // 使用finally块来关闭输出流、输入流
         finally {
             try {
                 if (out != null) {
                     out.close();
                 }
                 if (br != null) {
                     br.close();
                 }
             } catch (IOException ex) {
                 ex.printStackTrace();
             }
         }
         return map;
     }
 }

MobileApiTools.java 类

 package com.hozhu.api;

 import java.io.IOException;
 import java.text.SimpleDateFormat;
 import java.util.Date;

 import com.hozhu.excel.ExcelUtil;

 public class MobileApiTools {
     private MobileApiTools() {
     }

     /**
      * 获取当前系统时间
      *
      * @return
      */
     public static String getDate() {
         SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         return df.format(new Date());
     }

     /**
      * 期望结果与实际结果比较
      *
      * @param expectedResult
      * @param actualResult
      * @return
      */
     public static String assertResult(String expectedResult, String actualResult) {
         String result;
         if (expectedResult.equals(actualResult))
             result = "OK";
         else
             result = "NG";
         return result;

     }

     /**
      * 初始化 Excel 中指定列数据
      *
      * @param filePath
      *            文件路径
      * @param sheetName
      *            sheet 名称
      * @param titleLineIndex
      *            表标题所在行索引
      * @param columnName
      *            列名称
      * @param content
      *            需写入的内容
      * @param color
      *            需设置的单元格颜色
      * @throws IOException
      */
     public static void initializeData(int titleLineIndex, String columnName,
             String content, int color) throws IOException {
         int maxRow = ExcelUtil.getInstance().getSheetMaxRow();
         int columnIndex = ExcelUtil.getInstance().getColumnIndex(
                 titleLineIndex, columnName);
         if (maxRow != -1 && columnIndex != -1) {
             for (int i = titleLineIndex + 1; i <= maxRow; i++) {
                 // 初始化单元格内容
                 ExcelUtil.getInstance().writeExcelCell(i, columnIndex, content);
                 // 设置单元格颜色
                 ExcelUtil.getInstance().setCellBackgroundColor(titleLineIndex,
                         columnName, i, color);
             }
         }
     }

     /**
      * 将执行结果写入 Excel 中
      *
      * @param filePath
      *            文件路径
      * @param sheetName
      *            sheet 名称
      * @param titleLineIndex
      *            标题所在索引行
      * @param writeStartRow
      *            写入起始行
      * @param columnName
      *            列名称
      * @param content
      *            写入内容
      */
     public static void writeResult(int titleLineIndex, int writeStartRow,
             String columnName, String content) {

         int columnIndex = ExcelUtil.getInstance().getColumnIndex(
                 titleLineIndex, columnName);
         if (columnIndex != -1) {
             try {
                 ExcelUtil.getInstance().writeExcelCell(writeStartRow,
                         columnIndex, content);
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }

     /**
      * 表标题行是否包含指定参数
      * @param argLineIndex            参数名称所在单元格行索引
      * @param argColumnIndex        参数名称所在单元格列索引
      * @param titleLineIndex        表标题所在行索引
      * @return
      */
     public static boolean isArgEquals(int argLineIndex, int argColumnIndex,
             int titleLineIndex) {
         String[] argArray = null;
         boolean flag = false;

         // 获取所在单元格的参数列表
         String args = ExcelUtil.getInstance().readExcelCell(argLineIndex, argColumnIndex);
         if (!args.equals("")) {
             argArray = args.split("\\|");
         } else {
             System.out.println("文件: " + ExcelUtil.getInstance().getFilePath()
                     + ", sheetName: " + ExcelUtil.getInstance().getSheetName()
                     + ", 获取参数失败...");
         }

         if (argArray != null) {
             for (int i = 0; i < argArray.length; i++) {
                 int tempIndex = ExcelUtil.getInstance().getColumnIndex(
                         titleLineIndex, argArray[i]);
                 if (tempIndex >= 0)
                     flag = true;
                 else
                     System.out.println("参数: " + argArray[i]
                             + ", 不存在表标题行中, 请检查...");
             }
         }
         return flag;
     }

     public void info() {

     }
 }

LoginAPI.java 类

 package com.hozhu.cases;

 import java.io.IOException;
 import java.util.List;
 import java.util.Map;

 import org.apache.log4j.Logger;
 import org.json.JSONException;
 import org.json.JSONObject;

 import com.hozhu.api.HttpRequester;
 import com.hozhu.api.MobileApiTools;
 import com.hozhu.excel.ExcelUtil;

 public class LoginAPI {
     private static Logger logger = Logger.getLogger(LoginAPI.class);

     private final String FILE_PATH = "mobileApiCase.xlsx";
     private final String SHEET_NAME = "Login";
     private final int TITLE_LINE_INDEX = 4;

     private final String RESULT_CODE = "ResultCode";
     private final String TEST_RESULT = "TestResult";
     private final String RUNNING_TIME = "RunningTime";
     private final String ACTUAL_RESULT = "ActualResult";
     private final String RUN = "Run";

     // 需要的参数常量
     private final String MAIL = "mail";
     private final String MOBILE = "mobile";
     private final String PASS_WORD = "password";

     public LoginAPI() {
         try {
             logger.info(LoginAPI.class);

             ExcelUtil.getInstance().setFilePath(FILE_PATH);
             ExcelUtil.getInstance().setSheetName(SHEET_NAME);

             logger.info("初始化: " + ExcelUtil.getInstance().getFilePath() + ", " + ExcelUtil.getInstance().getSheetName());

             MobileApiTools.initializeData(TITLE_LINE_INDEX, RUN, "N", 4);
             MobileApiTools.initializeData(TITLE_LINE_INDEX, ACTUAL_RESULT, "",
                     4);
             MobileApiTools.initializeData(TITLE_LINE_INDEX, RESULT_CODE, "", 4);
             MobileApiTools.initializeData(TITLE_LINE_INDEX, TEST_RESULT, "NT",
                     2);
             MobileApiTools
                     .initializeData(TITLE_LINE_INDEX, RUNNING_TIME, "", 4);

             logger.info(ExcelUtil.getInstance().getFilePath() + ", " + ExcelUtil.getInstance().getSheetName() + "初始化完成");
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

     public void login() throws JSONException, IOException {
         String url = "";
         String act = "";
         String method = "";
         List<Map<String, String>> data = null;
         boolean flag = false;

         url = ExcelUtil.getInstance().readExcelCell(0, 1);
         act = ExcelUtil.getInstance().readExcelCell(1, 1);
         method = ExcelUtil.getInstance().readExcelCell(2, 1);
         flag = MobileApiTools.isArgEquals(3, 1, TITLE_LINE_INDEX);

         if (url.equals("") || act.equals("") || method.equals("") || !flag) {
             logger.error("请检查 Excel 中 Interface、Act、Method、ArgName 是否设置正确...");
             //System.out
             //        .println("请检查 Excel 中 Interface、Act、Method、ArgName 是否设置正确...");
             System.exit(-1);
         }

         data = ExcelUtil.getInstance().readExcelAllData(4);

         if (data != null) {
             for (int i = 0; i < data.size(); i++) {
                 Map<String, String> map = data.get(i);
                 String mail = map.get(MAIL);
                 String mobile = map.get(MOBILE);
                 String password = map.get(PASS_WORD);
                 String state = map.get("State");
                 String expectedResult = map.get("ExpectedResult");
                 String loginName;

                 // 如果 state == 0 则用 邮箱登录, 否则使用手机号码登录
                 if (Integer.parseInt(state) == 0)
                     loginName = mail;
                 else
                     loginName = mobile;

                 String param = "Act=" + act + "&" + "LoginName=" + loginName
                         + "&" + "Pwd=" + password;

                 Map<String, String> result = HttpRequester.sendPost(method,
                         url, param);
                 String code = result.get("code");
                 String rsTmp = result.get("result");

                 // 将字符串转换为 JSON
                 JSONObject object = new JSONObject(rsTmp);
                 String actualResult = object.getString("msg");

                 String testResult = MobileApiTools.assertResult(expectedResult,
                         actualResult);

                 // 写入 Run 列, 执行纪录
                 MobileApiTools.writeResult(TITLE_LINE_INDEX, TITLE_LINE_INDEX
                         + 1 + i, RUN, "Y");

                 // 写入 http code
                 MobileApiTools.writeResult(TITLE_LINE_INDEX, TITLE_LINE_INDEX
                         + 1 + i, RESULT_CODE, code);

                 // 设置单元格颜色
                 if (Integer.parseInt(code) == 200)
                     ExcelUtil.getInstance().setCellBackgroundColor(
                             TITLE_LINE_INDEX, RESULT_CODE,
                             TITLE_LINE_INDEX + 1 + i, 1);
                 else
                     ExcelUtil.getInstance().setCellBackgroundColor(
                             TITLE_LINE_INDEX, RESULT_CODE,
                             TITLE_LINE_INDEX + 1 + i, 1);

                 // 写入实际结果
                 MobileApiTools.writeResult(TITLE_LINE_INDEX, TITLE_LINE_INDEX
                         + 1 + i, ACTUAL_RESULT, actualResult);

                 // 写入测试通过与否
                 MobileApiTools.writeResult(TITLE_LINE_INDEX, TITLE_LINE_INDEX
                         + 1 + i, TEST_RESULT, testResult);

                 if (testResult.equals("OK"))
                     ExcelUtil.getInstance().setCellBackgroundColor(
                             TITLE_LINE_INDEX, TEST_RESULT,
                             TITLE_LINE_INDEX + 1 + i, 1);
                 else
                     ExcelUtil.getInstance().setCellBackgroundColor(
                             TITLE_LINE_INDEX, TEST_RESULT,
                             TITLE_LINE_INDEX + 1 + i, 0);

                 // 写入执行时间
                 MobileApiTools.writeResult(TITLE_LINE_INDEX, TITLE_LINE_INDEX
                         + 1 + i, RUNNING_TIME, MobileApiTools.getDate());

                 logger.info("CaseID: " + map.get("CaseID") + ", CaseName: " + map.get("CaseName") + ", ExpectedResult: " +
                 map.get("ExpectedResult") + ", ActualResult: " + actualResult + ", ResultCode: " + code +
                 ", TestResult: " + testResult);
             }
         }

     }

     public static void main(String[] args) throws JSONException, IOException {
         LoginAPI loginAPI = new LoginAPI();
         loginAPI.login();

     }

 }

RunCase.java : 所有的 case 都放这里运行

 package com.hozhu.cases;

 import java.io.IOException;

 import org.json.JSONException;
 import org.testng.Assert;
 import org.testng.annotations.Test;

 import com.hozhu.excel.ExcelUtil;

 public class RunCase {
     @Test
     public void testLogin() throws JSONException, IOException {
         LoginAPI login = new LoginAPI();
         login.login();
         String [] result = ExcelUtil.getInstance().readExcelColumnData(4, "TestResult");
         for (int i = 0; i < result.length; i++) {
             Assert.assertEquals(result[i], "OK");
         }
     }
 }

好了， 上传完毕，等等， 还有那 excel 也上截图吧，呵呵