记录java+testng运行selenium（三）---xml、ini、excel、日志等配置

一： ini文件

ini目前只用处存储浏览类型及需要打开的url，ini文件放在configs文件夹下面。

读取ini代码如下：

package toolskit.documents;

import java.io.*;
import java.util.*;

/**
 * @ ClassName: ReadIni
 * @ Author: DingDong
 * @ Date: 2019/8/23 10:57
 * @ Version: 1.0
 * @ desc: 读取ini后缀名的文件
 */

public class ReadIni {

    /**
     * 去除ini文件中的注释，以";"或"#"开头，顺便去除UTF-8等文件的BOM头
     * @param source
     * @return
     */
    private static String removeIniComments(String source) {

        String result = source;

        if (result.contains(";")) {
            result = result.substring(0, result.indexOf(";"));
        }

        if (result.contains("#")) {
            result = result.substring(0, result.indexOf("#"));
        }

        return result.trim();
    }


    public static Map<String, Object> readIni(String filename,String filepath) {
        Map<String, List<String>> listResult = new HashMap<>();
        Map<String, Object> result = new HashMap();
        String globalSection = "global";

        if (filepath.equalsIgnoreCase("") || filepath == null){
            filepath = ".\\src\\main\\java\\configs\\";
            filename = filepath + filename;
        }
        File file = new File(filename);
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
            String str = null;
            String currentSection = globalSection; //处理缺省的section
            List<String> currentProperties = new ArrayList<>();
            boolean lineContinued = false;
            String tempStr = null;

            //一次读入一行（非空），直到读入null为文件结束
            //先全部放到listResult<String, List>中
            while ((str = reader.readLine()) != null) {
                str = removeIniComments(str).trim(); //去掉尾部的注释、去掉首尾空格

                if ("".equals(str) || str == null) {
                    continue;
                }

                //如果前一行包括了连接符'\'
                if (lineContinued == true) {
                    str = tempStr + str;
                }

                //处理行连接符'\'
                if (str.endsWith("\\")) {
                    lineContinued = true;
                    tempStr = str.substring(0, str.length() - 1);
                    continue;
                } else {
                    lineContinued = false;
                }

                //是否一个新section开始了
                if (str.startsWith("[") && str.endsWith("]")) {
                    String newSection = str.substring(1, str.length() - 1).trim();

                    //如果新section不是现在的section，则把当前section存进listResult中
                    if (!currentSection.equals(newSection)) {
                        listResult.put(currentSection, currentProperties);
                        currentSection = newSection;

                        //新section是否重复的section
                        //如果是，则使用原来的list来存放properties
                        //如果不是，则new一个List来存放properties
                        currentProperties = listResult.get(currentSection);
                        if (currentProperties == null) {
                            currentProperties = new ArrayList<>();
                        }
                    }
                } else {
                    currentProperties.add(str);
                }
            }
            //把最后一个section存进listResult中
            listResult.put(currentSection, currentProperties);

            reader.close();


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e1) {
                }
            }
        }


        //整理拆开name=value对，并存放到MAP中：
        //从listResult<String, List>中，看各个list中的元素是否包含等号“=”，如果包含，则拆开并放到Map中
        //整理后，把结果放进result<String, Object>中
        for (String key : listResult.keySet()) {
            List<String> tempList = listResult.get(key);

            //空section不放到结果里面
            if (tempList == null || tempList.size() == 0) {
                continue;
            }

            if (tempList.get(0).contains("=")) { //name=value对，存放在MAP里面
                Map<String, String> properties = new HashMap<>();
                for (String s : tempList) {
                    int delimiterPos = s.indexOf("=");
                    //处理等号前后的空格
                    properties.put(s.substring(0, delimiterPos).trim(), s.substring(delimiterPos + 1, s.length()).trim());
                }
                result.put(key, properties);
            } else { //只有value，则获取原来的list
                result.put(key, listResult.get(key));
            }
        }
        return result;
    }

}

 

二： xml文件读取

xml文件主要存储excel所在路径以及用例类所对应的sheet名

参考：https://www.jianshu.com/p/8e333a0ec42a

代码如下：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
 * @ ClassName: toolskit.documents
 * @ Author: DingDong
 * @ Date: 2019/10/21 14:36
 * @ Version: 1.0
 * @ desc:
 */

public class XmlUtil {

    public static List getXmlComent(String path){
        //获取xml文件完全路径
        System.out.println("xml·path"+path);

        List contList=new ArrayList();
        //dom4j中读取xml文件的方法
        SAXReader saxR=new SAXReader();
        try {
            Document doc=saxR.read(path);
            //存放顶结点
            Element eleroot=doc.getRootElement();
            //parMap，存放顶结点下一级结点
            Map parMap=null;
            Map sonMap=null;
            for(Iterator i=eleroot.elementIterator();i.hasNext();){
                //parMap中存放的结点的子结点
                parMap=new HashMap();
                sonMap=new HashMap();
                Element elepar=(Element)i.next();
                for(Iterator j=elepar.elementIterator();j.hasNext();){
                    Element eleSon=(Element)j.next();
                    System.out.println("+++++"+eleSon.getName()+"    "+ eleSon.getText());
                    sonMap.put(eleSon.getName(), eleSon.getText());
                }

                parMap.put(elepar.getName(),sonMap);
                System.out.println("*****"+elepar.getName() +"*********" + sonMap);
                contList.add(parMap);
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }

        return contList;
    }
}

其中parMap和sonMap要在for里面清空已有的内容，不然contList存储的数据都是重复的

 

 

四：excel文件读写

ExcelOperating作为父类，用于区分文件类型及文件是否存在

ReadExcel：用于用户读取excel的内容并存在Map里面然后返回

WriteExcel ：让用户将输入写入excel里面

ExcelOperating代码如下：

package toolskit.documents;

import java.io.*;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.apache.commons.io.IOCase;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;

import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.poi.ss.usermodel.DateUtil;





public class ExcelOperating {

    private final String XLS_VERSION = "xls";
    private final String XLSX_VERSION = "xlsx";

    /**
     * 判断Excel的版本,获取Workbook
     * @param fileName 文件名
     * @return sheet对象
     */
    public Workbook distinguishWorkbook(String fileName) {
        Workbook workbook = null;
        InputStream is = null;
        try {
            File file = new File(fileName);
            is = new FileInputStream(file);

            if (IOCase.SENSITIVE.checkEndsWith(fileName, XLS_VERSION)) {

                workbook = new HSSFWorkbook(is);

            } else if (IOCase.SENSITIVE.checkEndsWith(fileName, XLSX_VERSION)) {

                workbook = new XSSFWorkbook(is);

            } else {
                System.out.println("该文件不是excle表格:" + fileName);

            }
        } catch (FileNotFoundException e) {
            System.out.println(">>>>>>>>>>  读取excel文件时出错了！！！");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println(">>>>>>>>>>  读取excel文件时出错了！！！");
            e.printStackTrace();
        }finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return workbook;
    }


    public   String getIntTypeValue(Cell cell) {
        String cellValue = "";
        double value = cell.getNumericCellValue();
        if (cell.getCellStyle().getDataFormat() == 176) {

            // 处理自定义日期格式:M月D日(通过判断单元格的格式id解决,ID的值是58)
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date date = DateUtil.getJavaDate(value);
            cellValue = sdf.format(date);

        } else {
            CellStyle style = cell.getCellStyle();
            DecimalFormat format = new DecimalFormat();
            String temp = style.getDataFormatString();

            // 把数字当成String来读，避免出现1读成1.0的情况.这个方式没这么灵活
            //        if (cell.getCellType() == CellType.NUMERIC) {
            //            cell.setCellType(CellType.STRING);
            //        }

            // 单元格设置成常规
            if (temp.equals("General")) {
                format.applyPattern("#");
            }
            cellValue = format.format(value);
        }
        return cellValue;
    }

    /**
     * 判断获取当前内容的格式，然后进行返回内容
     * 把单元格的内容转为字符串
     * 高版本的import org.apache.poi.ss.usermodel.CellType变为了import org.apache.poi.ss.usermodel.Cell;
     * 同时cellRowName.setCellType(CellType.STRING);变为了cellRowName.setCellType(Cell.CELL_TYPE_STRING);
     * 并且xssfCell.getCellTypeEnum()变成xssfCell.getCellType()
     * CellType                    类型            值
     * NUMERIC                    数值型            0
     * STRING                    字符串型        1
     * FORMULA                    公式型            2
     * BLANK                    空值            3
     * BOOLEAN                    布尔型            4
     * ERROR                    错误            5
     * @param cell 单元格
     * @return 字符串
     */
    @SuppressWarnings("deprecation")
    public  String getCellValue(Cell cell) {
        String cellValue = "";
        if (cell == null) {
            return cellValue;
        }

        //判断数据的类型，低版本中switch里面的case写法不一样。
        CellType cellType = cell.getCellType();

        switch (cellType) {
            case NUMERIC: //数字
                cellValue = getIntTypeValue(cell);
                break;
            case STRING: //字符串
                cellValue = String.valueOf(cell.getStringCellValue());
                break;
            case BOOLEAN: //Boolean
                cellValue = String.valueOf(cell.getBooleanCellValue());

                break;
            case FORMULA: //公式
                cellValue = String.valueOf(cell.getCellFormula());
                break;
            case BLANK: //空值
                cellValue = "";
                break;
            case ERROR: //故障
                cellValue = "非法字符";
                break;
            case _NONE: //故障
                cellValue = "非法字符";
                break;
            default:
                cellValue = "未知类型";
                break;
        }
        return cellValue;
    }

}

ReadExcel代码如下：

package toolskit.documents;

import java.io.*;
import java.util.*;

import org.apache.poi.ss.usermodel.*;


public class ReadExcel extends ExcelOperating {
//    public static void main(String[] args) {
//        ReadExcel re = new ReadExcel();
//        String load = "C:\\Users\\LGYY-USER\\Desktop\\红包发放.xlsx";


//         方式一: 指定sheet来读取
//        List<Map<String, String>> excelList = re.readExcel(load, "登录");
//        System.out.println("从excel读取数据并开始使用:");
//        for (Map<String, String> list : excelList) {
//            System.out.println(list);
//            for (Map.Entry<String, String> entry : list.entrySet()) {
//                System.out.println(entry.getValue());
//            }
//            System.out.println();
//        }

//         方式二: 读取单个文件,单行数据
//            Map<String, String> stringStringMap = re.singleReadXlsx(load, "登录", 2);
//        System.out.println(stringStringMap);
//            for(Map.Entry<String, String> entry : stringStringMap.entrySet()){
//                System.out.print("Key = "+entry.getKey()+",value="+entry.getValue() + "\n");
//            }

//         方式三: 读取全部sheet的数据
//        List<Map<Integer, Object>> lists = re.wholeReadXlsx(load);
//        for (Map<Integer, Object> i : lists) {
//            System.out.print(i);
//        }

//    }

    /**
     * 通过Workbook来读取excle表格上的数据
     *
     * @param load 文件所在路径
     * @return 获取到的数据
     */
    public List<Map<Integer, Object>> wholeReadXlsx(String load) {
        // excel中第几列 ： 对应的表头
        Map<Integer, String> colAndNameMap = new HashMap<Integer, String>();
        List<Map<Integer, Object>> resultList = new ArrayList<Map<Integer, Object>>();
        Workbook wb = null;
        try {
            wb = distinguishWorkbook(load);
            for (int sheetIndex = 0; sheetIndex < wb.getNumberOfSheets(); sheetIndex++) {
                //获取sheet数据
                Sheet st = wb.getSheetAt(sheetIndex);
                //遍历一个sheet中每一行
                for (int rowIndex = 0; rowIndex <= st.getLastRowNum(); rowIndex++) {
                    // 表头：值
                    Map<Integer, Object> nameAndValMap = new HashMap<Integer, Object>();
                    // 获取到一行数据
                    Row row = st.getRow(rowIndex);
                    for (int cellIndex = 0; cellIndex < row.getPhysicalNumberOfCells(); cellIndex++) {

                        if (rowIndex == 0) {
                            colAndNameMap.put(cellIndex, row.getCell(cellIndex).getStringCellValue());
                        } else if (!colAndNameMap.isEmpty()) {
                            nameAndValMap.put(cellIndex, getCellValue(row.getCell(cellIndex)));
                        }
                    }
                    if (!nameAndValMap.isEmpty()) {
                        resultList.add(nameAndValMap);
                    }
                }
            }
            return resultList;
        } catch (Exception e) {
            System.out.println(">>>>>>>>>>  读取excel文件时出错了！！！");
            e.printStackTrace();
        } finally {
            try {
                wb.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }


    /**
     * 读取指定工作薄里的指定行的内容
     * load文档所在地
     * numSheet当前文档中所读写的工作薄
     * rowNum当前工作薄中的第几个数据
     * @param load 文件所在路径
     * @param sheetName sheet表格名字
     * @param rowNum 指定行数
     * @return 找到的全部数据
     */
    public Map<String, String> singleReadXlsx(String load, String sheetName, int rowNum) {
        Workbook xssfWorkbook = distinguishWorkbook(load);
        Map<String, String> aMap = new HashMap<String, String>();
        Sheet xssfSheet;
        if (sheetName.equals("")) {
            // 默认取第一个子表
            xssfSheet = xssfWorkbook.getSheetAt(0);
        } else {
            xssfSheet = xssfWorkbook.getSheet(sheetName);
        }

        if (xssfSheet != null) {
            // 获取指定行
            Row xssfRow = xssfSheet.getRow(rowNum);//获取该行的全部数据
            if (xssfRow != null) {

                int firstCellNum = (int) xssfRow.getFirstCellNum();// 首列
                int lastCellNum = (int) xssfRow.getLastCellNum();// 最后一列

                for (int col = firstCellNum; col < lastCellNum; col++) {
                    String sEnum = col + "";
                    aMap.put(sEnum, getCellValue(xssfRow.getCell(col)));
                }
            } else {
                System.out.println("xssfRow为空");
            }
        }

        return aMap;
    }


    /**
     *  指定表格中行的数据长度
     * @param load 文件名
     * @param nameSheet 表格名字
     * @return 表格行的总数
     */
    public int singleXlsx(String load, String nameSheet) {
        int row = 0;
        // 获取每一个工作薄
        Sheet sheetAt = distinguishWorkbook(load).getSheet(nameSheet);
        if (sheetAt != null) {
            row = sheetAt.getLastRowNum();
        }
        return row;

    }

    /**
     * 读取Excel文件中指定sheet的内容
     *
     * @param load      excel文件的所在路径
     * @param sheetName sheet名字
     * @return 以List返回excel中内容
     */
    public List<Map<String, String>> readExcel(String load, String sheetName) {

        Workbook xssfWorkbook = distinguishWorkbook(load);

        //定义工作表
        Sheet xssfSheet;

        if (sheetName.equals("")) {
            // 默认取第一个子表
            xssfSheet = xssfWorkbook.getSheetAt(0);
        } else {
            xssfSheet = xssfWorkbook.getSheet(sheetName);
        }

        List<Map<String, String>> list = new ArrayList<Map<String, String>>();

        // 默认第一行为标题行，index = 0
        Row titleRow = xssfSheet.getRow(0);

        // 根据第一行返回该行中单元格的数量
        int cellNumber = titleRow.getPhysicalNumberOfCells();

        // 返回sheet标中行的总数
        int rownumber = xssfSheet.getPhysicalNumberOfRows();

        // 循环取每行的数据
        for (int rowIndex = 1; rowIndex < rownumber; rowIndex++) {
            Row xssfRow = xssfSheet.getRow(rowIndex);
            if (xssfRow == null) {
                continue;
            }

            Map<String, String> map = new LinkedHashMap<String, String>();

            //循环取每个单元格(cell)的数据
            for (int cellIndex = 0; cellIndex < cellNumber; cellIndex++) {
                Cell titleCell = titleRow.getCell(cellIndex);
                Cell xssfCell = xssfRow.getCell(cellIndex);
                map.put(getCellValue(titleCell), getCellValue(xssfCell));
            }
            list.add(map);
        }
        return list;
    }

    /**
     * 把一个Map中的所有键和值分别放到一个list中，
     * 再把这两个list整个放到一个大的list里面，即 [ [key1,key2,key3...] , [value1,value2,value3...] ]
     *
     * @param map 需要转换的map
     * @return 已转换后的list
     */
    public static List<List> convertMapToList(Map map) {
        List<List> list = new ArrayList<List>();
        List<String> key_list = new LinkedList<String>();
        List<String> value_list = new LinkedList<String>();

        Set set = map.entrySet();
        Iterator<Map.Entry<String, String>> iter1 = set.iterator();
        while (iter1.hasNext()) {
            key_list.add(iter1.next().getKey());
        }
        list.add(key_list);

        Collection<String> value = map.values();
        Iterator<String> iter2 = value.iterator();
        while (iter2.hasNext()) {
            value_list.add(iter2.next());
        }
        list.add(value_list);
        return list;
    }
}

 

WriteExcel写法如下：很少使用这个类

package toolskit.documents;

import java.io.*;
import java.util.List;

import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;



public class WriteExcel extends ExcelOperating{

    // 当前文件已经存在
    private String excelPath = "E:/MyFirstExcel.xlsx";

    // 从第几行插入进去
    private int insertStartPointer;

    // 根据工作薄名进行插入
    private String sheetName;

    // 根据工作薄所在位置进行插入
    private int sheetInsert = 0;

    public WriteExcel(String excelPath, int insertStartPointer, String sheetName, int sheetInsert) {
        this.excelPath = excelPath;
        this.insertStartPointer = insertStartPointer;
        this.sheetName = sheetName;
        this.sheetInsert = sheetInsert;
    }

    public WriteExcel() {
    }

    /**
     * 总的入口方法
     */
    public static void main(String[] args){
        WriteExcel crt = new WriteExcel();
        int i = new ReadExcel().singleXlsx(crt.excelPath, "sheet");
        crt.insertStartPointer = i + 1;
        crt.insertRows();
    }

    /**
     * 在已有的Excel文件中插入一行新的数据的入口方法
     */
    public void insertRows() {
        Workbook wb = returnWorkBookGivenFileHandle();
        // XSSFSheet sheet1 = wb.getSheet(sheetName);
        sheetName = wb.getSheetName(sheetInsert);
        Sheet sheet = wb.getSheet(sheetName);
        Row row = createRow(sheet, insertStartPointer);
        createCell(row);
        saveExcel(wb);

    }

    /**
     * 保存工作薄
     *
     * @param wb
     */
    private void saveExcel(Workbook wb) {
        FileOutputStream fileOut;
        try {
            fileOut = new FileOutputStream(excelPath);
            wb.write(fileOut);
            fileOut.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * 创建要出入的行中单元格
     *
     * @param row
     * @return
     */
    private Cell createCell(Row row) {
        Cell cell = row.createCell((short) 0);
        cell.setCellValue(999999);
        row.createCell(1).setCellValue(1.2);
        row.createCell(2).setCellValue("This is a string cell");
        return cell;
    }

    /**
     * 得到一个已有的工作薄的POI对象
     *
     * @return
     */
    private Workbook returnWorkBookGivenFileHandle() {
        Workbook wb = null;
        File f = new File(excelPath);
        try {
            if (f != null) {
                wb = distinguishWorkbook(excelPath);
            }
        } catch (Exception e) {
            return null;
        }
        return wb;
    }

    /**
     * 找到需要插入的行数，并新建一个POI的row对象
     *
     * @param sheet
     * @param rowIndex
     * @return
     */
    private Row createRow(Sheet sheet, Integer rowIndex) {
        Row row = null;
        if (sheet.getRow(rowIndex) != null) {
            int lastRowNo = sheet.getLastRowNum();
            sheet.shiftRows(rowIndex, lastRowNo, 1);
        }
        row = sheet.createRow(rowIndex);
        return row;
    }

    /**
     * 把内容写入Excel
     *
     * @param list         传入要写的内容，此处以一个List内容为例，先把要写的内容放到一个list中
     * @param outputStream 把输出流怼到要写入的Excel上，准备往里面写数据
     */
    public void writeExcel(List<List> list, OutputStream outputStream) {
        //创建工作簿
        XSSFWorkbook xssfWorkbook;
        xssfWorkbook = new XSSFWorkbook();

        //创建工作表
        XSSFSheet xssfSheet;
        xssfSheet = xssfWorkbook.createSheet();

        //创建行
        XSSFRow xssfRow;

        //创建列，即单元格Cell
        XSSFCell xssfCell;

        //把List里面的数据写到excel中
        for (int i = 0; i < list.size(); i++) {
            //从第一行开始写入
            xssfRow = xssfSheet.createRow(i);
            //创建每个单元格Cell，即列的数据
            List sub_list = list.get(i);
            for (int j = 0; j < sub_list.size(); j++) {
                xssfCell = xssfRow.createCell(j); //创建单元格
                xssfCell.setCellValue((String) sub_list.get(j)); //设置单元格内容
            }
        }

        //用输出流写到excel
        try {
            xssfWorkbook.write(outputStream);
            outputStream.flush();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

 

五：日志输出

日志输出一般有两个方式:

1. 定义全局的System.out.println统一进行输出

2. 由log日志进行输出

 

由System.out.println输出的模板：

package toolskit;

import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * @ ClassName: SystemOut
 * @ Author: DingDong
 * @ Date: 2019/8/13 11:33
 * @ Version: 1.0
 * @ desc:
 */


public class SystemOut {

    public static void textStringOut(String data, String text) {
        System.out.println(data + ":" + text);
    }

    public static void textStringOut(String status, String data, String text) {
        System.out.println(status + ":" + data + ":" + text);
    }

    public static void textStringOut(String text) {
        System.out.println(text);
    }

    /**
     * 用例成功,并且编辑成功
     *
     * @param massage   用例编号
     * @param parameter 用例输入的内容
     */
    public static void caseSuccess(String massage, String parameter) {
        System.out.println(massage + "用例执行成功，编辑内容为：" + parameter);
    }

    /**
     * 编辑判断成功
     *
     * @param massage 执行编号
     */
    public static void caseEditSuccess(String massage) {
        System.out.println(massage + "用例中的元素对象不需要编辑,程序判断成功。。");
    }

    /**
     * 用例执行成功
     *
     * @param massage
     */
    public static void caseSuccess(String massage) {
        System.out.println(massage + "用例执行成功");
    }


    /**
     * 用例执行失败，并且打印出输入信息
     *
     * @param massage
     */
    public static void caseFail(String massage) {
        System.out.println(massage + "用例执行失败。。。。");
    }

    /**
     * 不需要进行编辑时发生失败
     *
     * @param massage 用例编号
     */
    public static void caseEditFail(String massage) {
        System.out.println(massage + "用例中的元素对象不需要编辑，程序判断失败。");
    }

    public static void caseFail(String massage, String parameter) {
        System.out.println(massage + "用例执行失败，编辑内容为：" + parameter);
    }

    /**
     * @param li
     */
    public static void getStringOut(List<List> li) throws InterruptedException {
        textStringOut("打印list开始" + li.size());
        for (int i = 0; i < li.size(); i++) {
            textStringOut(li.get(i).toString());
        }
    }


    public static void getStringOut(Map<String, String> aMap) throws InterruptedException {
        textStringOut("打印list开始" + aMap.size());
        Iterator<Map.Entry<String, String>> iterator = aMap.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, String> next = iterator.next();
            System.out.println("Key = " + next.getKey() + ", Value = " + next.getValue());
        }
    }
}

 

log日志输出：

1. 在resources文件夹下面创建以下两个文件：common-logging.properties 和 log4j.properties

2. 配置两个dependency，分别是commons-logging 和 log4j

common-logging.properties 里面内容为：

org.apache.commons.logging.Log=org.apache.commons.logging.impl.Log4JLogger

 

log4j.properties 里面内容为：

#设置logger级别DEBUG、INFO、WRNING、ERROR和输出格式A、B、C或D
log4j.rootLogger=debug , stdout , D , E
### 输出INFO级别以上的日志到控制台 ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.Threshold=DEBUG
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### 输出到日志文件 ###
log4j.appender.D=org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File=E:/logs/log.log
log4j.appender.D.Append=true
## 输出DEBUG级别以上的日志
log4j.appender.D.Threshold=DEBUG
log4j.appender.D.layout=org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %c{1}:%L %m%n
### 保存异常信息到单独文件 ###
log4j.appender.E=org.apache.log4j.DailyRollingFileAppender
## 异常日志文件名
log4j.appender.E.File=E:/logs/error.log
log4j.appender.E.Append=true
## 只输出ERROR级别以上的日志!!!
log4j.appender.E.Threshold=ERROR
log4j.appender.E.layout=org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n

pom文件配置：dependency

 <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
        <!--日志文件-->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

 

log代码：

package toolskit;

import org.apache.log4j.Logger;

/**
 * @ ClassName: InformationLog
 * @ Author: DingDong
 * @ Date: 2019/8/9 17:39
 * @ Version: 1.0
 * @ desc:
 */
public class InformationLog {
    protected static final Logger logger = Logger.getLogger(InformationLog.class);

    public static void inputLogInfo(String infoData) {
        logger.info(infoData);
    }

    public static void inputLogDebug(String infoData) {
        logger.debug(infoData);
    }

    public static void inputLogWarn(String infoData) {
        logger.warn(infoData);
    }

    public static void inputLogError(String infoData) {
        logger.error(infoData);
    }

    public static void inputLogFatal(String infoData) {
        logger.fatal(infoData);
    }

}

 

 

 

 

 

说明：

定义文件地址的时候，都是写死；文件地址这边写死（动态又高级的写法不懂如何编写）