测开学习五：正则表达式&json工具介绍&测试结果提取

1.正则表达式

正则表达式(Regular Expression)是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。
. 匹配除换行符以外的任意字符
\w 匹配字母或数字或下划线或汉字 等价于 ‘[^A-Za-z0-9_]’
\s 匹配任意的空白符
\d 匹配数字(\D 非数字)
\b 匹配单词的开始或结束
^ 匹配字符串的开始
$ 匹配字符串的结束

package com.api;

import org.apache.commons.collections.MapUtils;

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ParamsTest {
    public static void main(String[] args) {
        List<Map<String,String>> resultList = new ArrayList<>();
        Map<String,String> map1 = new LinkedHashMap<>();
        map1.put("loginname","abc");
        map1.put("loginpass","ab1c");
        resultList.add(map1);
        Map<String,String> map2 = new LinkedHashMap<>();
        map2.put("loginname","test");
        map2.put("loginpass","tes1t");
        resultList.add(map2);
        System.out.println(resultList);
        for(Map<String,String> map:resultList){
            String str="http://1.15.86.29:8080/goods/UserServlet?method=loginMobile&loginname=${loginname}&loginpass=${loginpass}";
            String regex ="\\$\\{(.*?)\\}";//？非贪婪
            Pattern p =Pattern.compile(regex);
            Matcher m = p.matcher(str);
            while (m.find()){
                str=str.replace(m.group(), MapUtils.getString(map,m.group(1),""));
            }
            System.out.println(str);
        }
    }
}

2.fastjson

参考另一片博客：
https://blog.csdn.net/qq_33214066/article/details/105835854https://editor.csdn.net/md/?articleId=105835854

3.JsonPath

fastjson 1.2.0之后的版本支持JSONPath，支持路径查找

package com.api;

import com.alibaba.fastjson.JSONPath;

import java.util.List;

public class JsonPathTest {
    public static void main(String[] args) {
        String jsonStr = "{\n" +
                "    \"store\": {\n" +
                "        \"bicycle\": {\n" +
                "            \"color\": \"red\",\n" +
                "            \"price\": 19.95\n" +
                "        },\n" +
                "        \"book\": [\n" +
                "            {\n" +
                "                \"author\": \"刘慈欣\",\n" +
                "                \"price\": 8.95,\n" +
                "                \"category\": \"科幻\",\n" +
                "                \"title\": \"三体\"\n" +
                "            },\n" +
                "            {\n" +
                "                \"author\": \"itguang\",\n" +
                "                \"price\": 12.99,\n" +
                "                \"category\": \"编程语言\",\n" +
                "                \"title\": \"go语言实战\"\n" +
                "            }\n" +
                "        ]\n" +
                "    }\n" +
                "}";
        //第一本书title
        String title=(String)JSONPath.read(jsonStr,"store.book[0].title");
        System.out.println(title);
        List<String> titles =(List<String>)JSONPath.read(jsonStr,"store.book.title");
        System.out.println(titles);
        List<Double> prices =  (List<Double>) JSONPath.read(jsonStr, "$.store.book.price");
        System.out.println(prices);
        //多层结构 相对路径
        System.out.println(JSONPath.read(jsonStr,"..title"));
    }
}

测试结果提取到下一个请求

package com.api;

import com.fourthcourse.readtranfer.FileReadConvertible;
import com.github.crab2died.annotation.ExcelField;
import lombok.Data;

@Data
public class TestCase implements Comparable<TestCase>{
    @ExcelField(title = "顺序")
    private int order;
    @ExcelField(title = "是否开启")
    private String isRun;

    @ExcelField(title = "地址")
    private String url;
    @ExcelField(title = "类型")
    private String type;

    @ExcelField(title = "用例名称")
    private String caseName;

    //读写转换
    @ExcelField(title = "参数", readConverter = FileReadConvertible.class)
    private String params;

    @ExcelField(title = "头部")
    private String headers;

    @ExcelField(title = "数据提取json格式")
    private String resultJson;

    @ExcelField(title = "数据提取正则")
    private String resultRegx;

    @Override
    public int compareTo(TestCase o) {
        return this.getOrder()-o.getOrder();
    }
}

package com.utils;

import java.util.HashMap;
import java.util.Map;

public class ParamsUtils {
    public static Map<String, Object> params =new HashMap<String, Object>();
    public static void addMap(Map<String, Object> map) {
        params.putAll(map);
    }

    public static Map<String, Object> get() {
        return params;
    }

    public static void clear() {
        params.clear();
    }
}

package com.utils;

import org.apache.commons.lang3.StringUtils;

import java.util.LinkedHashMap;
import java.util.Map;

public class StringToUtils {
    public static Map<String, Object> convert(String str, String regex) {
        Map<String, Object> resultMap= new LinkedHashMap<>();
        if (StringUtils.isNotBlank(str)) {
            String[] stringArray = str.split(regex);
            System.out.println(stringArray.length);
                for(int i=0;i<stringArray.length;i++) {
                    resultMap.put(stringArray[i].split("=")[0], stringArray[i].split("=")[1]);
                }

        }
        return resultMap;
    }
}

package com.api;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONPath;
import com.github.crab2died.ExcelUtils;
import com.github.crab2died.exceptions.Excel4JException;
import com.utils.ExcelToMapUtils;
import com.utils.HttpClientUtils;
import com.utils.ParamsUtils;
import com.utils.StringToUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;

import java.io.File;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ApiTest {
    public static void main(String[] args) throws Excel4JException, IOException {
        String path =  System.getProperty("user.dir")+ File.separator+"data"+File.separator+"apitest2.xlsx";
        List<Map<String, Object>> mapList= ExcelToMapUtils.importExcel(path,1);
        System.out.println(mapList);
        for(Map<String, Object> map:mapList){
            ParamsUtils.addMap(map);
            List<TestCase> cases = ApiTest.byExcel(path);
            Collections.sort(cases);
            for(TestCase testCase:cases){
                ApiTest.beforeReplace(testCase);
                String result = "";
                if ("get".equals(testCase.getType())) {
                    result = HttpClientUtils.doGet(testCase.getUrl(), testCase.getHeaders());
                } else if ("post".equals(testCase.getType())) {
                    result = HttpClientUtils.doPost(testCase.getUrl(), testCase.getParams(), testCase.getHeaders());
                } else if ("postjson".equals(testCase.getType())) {
                    result = HttpClientUtils.doPostJson(testCase.getUrl(), testCase.getParams(), testCase.getHeaders());
                }
                String resultJson = testCase.getResultJson();
                if(JSON.isValidObject(result)){
                    Map<String,Object> mapJson=StringToUtils.convert(resultJson,";");
                    System.out.println("mapJson:"+mapJson);
                    String finalResult = result;
                    mapJson.forEach((key, value)->mapJson.put(key,JSONPath.read(finalResult, value.toString())));
                    ParamsUtils.addMap(mapJson);
                }
                String resultRegx = testCase.getResultRegx();
                if (StringUtils.isNotBlank(resultRegx)) {
                    Map<String, Object> regxMap = StringToUtils.convert(resultRegx,";");
                    final String regxResult = result;
                    System.out.println(regxMap);
                    regxMap.forEach((k, v) -> {
                        Pattern r = Pattern.compile(v.toString());
                        Matcher m = r.matcher(regxResult);
                        while (m.find()) {
                            System.out.println(m.group(0));
                            System.out.println(m.group(1));
                            regxMap.put(k, m.group(1));
                        }
                    });
                    ParamsUtils.addMap(regxMap);
                }
                System.out.println(testCase + "result " + result);
            }
            System.out.println("ParamsUtils:"+ParamsUtils.get());
            ParamsUtils.clear();
        }
    }
    public static List<TestCase> byExcel(String path) throws Excel4JException, IOException {
        List<TestCase> cases = ExcelUtils.getInstance().readExcel2Objects(path,TestCase.class);
        return cases;
    }
    private static void beforeReplace(TestCase testCase) {
        String url =testCase.getUrl();
        Map<String, Object> map = ParamsUtils.get();
        if(StringUtils.isNotBlank(url)){
            String regex ="\\$\\{(.*?)\\}";//？非贪婪
            Pattern p =Pattern.compile(regex);
            Matcher m = p.matcher(url);
            while (m.find()){
                url=url.replace(m.group(), MapUtils.getString(map,m.group(1),""));
            }
            testCase.setUrl(url);
        }
        String params =testCase.getParams();
        if(StringUtils.isNotBlank(params)){
            String regex ="\\$\\{(.*?)\\}";//？非贪婪
            Pattern p =Pattern.compile(regex);
            Matcher m = p.matcher(params);
            while (m.find()){
                params=params.replace(m.group(), MapUtils.getString(map,m.group(1),""));
            }
            testCase.setParams(params);
        }
        String headers =testCase.getHeaders();
        if(StringUtils.isNotBlank(headers)){
            String regex ="\\$\\{(.*?)\\}";//？非贪婪
            Pattern p =Pattern.compile(regex);
            Matcher m = p.matcher(headers);
            while (m.find()){
                headers=headers.replace(m.group(), MapUtils.getString(map,m.group(1),""));
            }
            testCase.setHeaders(headers);
        }
    }

}

作业：统计test.txt中idcard不为空出现的次数

文本内容：
{“phone”:“123434”, “idcard”:“123231231”,“color”:“red”}
{“phone”:"", “idcard”:“123231231”,“color”:“yellow”}
{“phone”:“123434”, “idcard”:“797979”,“color”:“violet”}
{“phone”:“123434”, “idcard”:“123231231”,“color”:“orange”}
{“phone”:"", “idcard”:"",“color”:“red”}
{“phone”:“123434212”, “idcard”:"",“color”:“red”}
{“phone”:“123434212”, “idcard”:“dasdas”,“color”:“red”}
{“phone”:"", “idcard”:"",“color”:“red”}
{“phone”:“123434212”, “idcard”:“dasdas”,“color”:“violet”}
{“phone”:"", “idcard”:“dasdas”,“color”:“yellow”}

代码实现：

package com.api;

import com.alibaba.fastjson.JSONPath;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringUtils;

import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class IdcardTimes {
    //第一种：正则表达式
    public static int times(String path){
        int times =0;
        try {
            List<String> strings=FileUtils.readLines(new File(path),"utf-8");
            for(String line:strings){
                System.out.println(line);
                String regex = "\"idcard\":\"(\\w{1,})\"";
                Pattern p = Pattern.compile(regex);
                Matcher m = p.matcher(line);
                while (m.find()){
                    System.out.println(m.group());
                    times=times+1;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return times;
    }
    //第二种：JsonPath
    public static int timeJsonpath(String path){
        int times =0;
        try {
            List<String> strings=FileUtils.readLines(new File(path),"utf-8");
            for(String line:strings){
                String id =(String)JSONPath.read(line,"idcard");
                System.out.println(id);
                if(id.length()!=0){
                    times=times+1;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return times;
    }

    public static void main(String[] args) {
        String path = System.getProperty("user.dir")+File.separator+"test.txt";
        System.out.println(IdcardTimes.timeJsonpath(path));
        System.out.println(IdcardTimes.times(path));
    }
}
``