JMeter关联：JMeter正则表达式提取器与JSON提取器

梦里梦外; 2023-10-18 20:14 75阅读 0赞

#### JMeter使用正则表达式和JSON提取器实现关联 ####

*  前言
 *  1 关联的释义与示例
 *  2 常用正则表达式详解
 *  3 正则表达式提取器
 *   *  3.1 参数详解
     *  3.2 使用示例
 *  4 JSON提取器
 *   *  4.1 参数详解
     *  4.2 使用示例
 *  5 疑难杂症
 *   *  5.1 提取多个值
     *  5.2 多个值合并
     *  5.3 左右边界不好确定
     *  5.4 多个匹配结果
     *  5.5 其他特殊用法

## 前言 ##

本文主要内容是：使用使用正则表达式提取器和JSON提取器实现关联。

> 下文中会多次使用到`BeanShell Sampler`和`Debug Sampler`，前者其实是起到一个`mock server`的作用，返回自定义的响应结果，后者能够输出`JMeter`的变量情况。

关于JMeter的使用，花费大量精力写了JMeter的一系列文章，有图有案例，一方面总结起来作为备忘，一方面希望能给初学者一些帮助。觉得有所帮助的朋友，请点个赞，对于疏漏之处也欢迎指教。

*  **JMeter逻辑控制器**：[https://blog.csdn.net/mu\_wind/article/details/91879280][https_blog.csdn.net_mu_wind_article_details_91879280]
 *  **JMeter配置元件**：[https://blog.csdn.net/mu\_wind/article/details/92796646][https_blog.csdn.net_mu_wind_article_details_92796646]
 *  **JMeter操作Mysql数据库**： [https://blog.csdn.net/mu\_wind/article/details/93312052][https_blog.csdn.net_mu_wind_article_details_93312052]
 *  **BeanShell Sampler与BeanShell断言**：[https://blog.csdn.net/mu\_wind/article/details/93506974][https_blog.csdn.net_mu_wind_article_details_93506974]
 *  **JMeter Linux下执行测试**：[https://blog.csdn.net/mu\_wind/article/details/95733081][https_blog.csdn.net_mu_wind_article_details_95733081]
 *  **JMeter自定义日志与日志分析**：[https://blog.csdn.net/mu\_wind/article/details/95752633][https_blog.csdn.net_mu_wind_article_details_95752633]

## 1 关联的释义与示例 ##

关联在接口测试中是一个非常重要的概念，它的意思是在两个或多个接口间建立逻辑上的依赖与联系。

关联的使用场景往往要满足以下条件：

1.  A接口响应结果中的数据被后续的接口所引用
2.  A接口响应结果中被后续接口引用的数据是动态变化且无法提前预知的

例如，登录接口-下订单接口这样2个接口组成的流程，就是非常典型的关联案例。

首先，登录接口返回包含用户身份认证信息的`token`，后续的下订单接口需要附带上这个`token`才能被服务器识别身份。

> Token是服务端生成的一串字符串，以作客户端进行请求的一个令牌，当第一次登录后，服务器生成一个Token便将此Token返回给客户端，以后客户端只需带上这个Token前来请求数据即可，无需再次带上用户名和密码。

要想实现这个场景，我们需要这么做：

1.  在登录接口响应结果中将`token`提取出来并保存在变量中，这里可以使用【正则表达式提取器】和【JSON提取器】。
2.  在后续接口中引用已经保存好的`token`，一般通过【HTTP信息头管理器】

形成的脚本如下。

1、登录接口的响应结果：

{
        
    	"code" : 200,
    	"msg" : "SUCCESS",
    	"data" : {
        
    		"accessToken" : "PJqx4566Ggf10qJv6firYAFS408p0us",
    		"info" : {
        
    			"id" : 10000,
    			"level" : 0,
    			"twiceGoogleAuth" : false,
    			"twiceMobileAuth" : true,
    			"twiceEmailAuth" : false,
    			"tradePwdAlways" : false,
    			"tradePwdHours" : false,
    			"lastLoginDate" : null,
    			"lastLoginAddress" : null,
    			"depositFlag" : true,
    			"loginCount" : 0,
    			"emailRegister" : false,
    			"nation" : 211,
    			"webLoginCount" : 0
    		}
    	}
    }

2、从登录接口响应结果中提取`token`的值，并保存到名称为`myToken`的变量中：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70]

3、引用前面保存的token值（前面保存变量为什么，这里就引用什么）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 1]  
4、后续接口中，成功引用了到了`myToken`的值：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 2]

接下来，我们以 [WeatherWS][] 这个网站的两个接口为示例，使用【正则表达式提取器】完成一个关联实现。

接下来的测试场景是这样的：

1.  请求 `getRegionProvince` 接口，得到包含各个省份 `code` 的列表，并在这个列表里提取**北京**的 `code`
2.  将北京的 `code` 作为`getSupportCityDataSet`接口 `theRegionCode` 参数的参数值，请求接口得到北京下辖的行政区域列表。

![在这里插入图片描述][20190620175154185.png]  
**getRegionProvince**的接口说明如下：

GET /WebServices/WeatherWS.asmx/getRegionDataset? HTTP/1.1
    Host: ws.webxml.com.cn
    HTTP/1.1 200 OK
    Content-Type: text/xml; charset=utf-8
    Content-Length: length
    
    <?xml version="1.0" encoding="utf-8"?>
    <DataSet xmlns="http://WebXml.com.cn/">
      <schema xmlns="http://www.w3.org/2001/XMLSchema">schema</schema>xml</DataSet>

**getSupportCityDataSet**的接口说明如下：

GET /WebServices/WeatherWS.asmx/getSupportCityDataset?theRegionCode=string HTTP/1.1
    Host: ws.webxml.com.cn
    HTTP/1.1 200 OK
    Content-Type: text/xml; charset=utf-8
    Content-Length: length
    
    <?xml version="1.0" encoding="utf-8"?>
    <DataSet xmlns="http://WebXml.com.cn/">
      <schema xmlns="http://www.w3.org/2001/XMLSchema">schema</schema>xml</DataSet>

根据上面的接口说明，先建立下面的脚本：  
![在这里插入图片描述][20200610165215732.png]  
整体的脚本结构如上图所示，下面依次看每个组件的内容和作用。

1、【HTTP请求】`getRegionProvince`：  
![在这里插入图片描述][20200610165534157.png]

1.  IP：ws.webxml.com.cn
2.  路径：/WebServices/WeatherWS.asmx/getRegionDataset
3.  作用：获得中国省份、直辖市、地区；国家名称（国外）和与之对应的ID
4.  相应结果（为节省篇幅，删除了大量无关数据）：

<?xml version="1.0" encoding="utf-8"?>
    <DataSet xmlns="http://WebXml.com.cn/">
      <xs:schema id="getRegion" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
      </xs:schema>
      <diffgr:diffgram xmlns:msdata="urn:schemas-microsoft-com:xml-msdata" xmlns:diffgr="urn:schemas-microsoft-com:xml-diffgram-v1">
        <getRegion xmlns="">
          <Province diffgr:id="Province5" msdata:rowOrder="4">
            <RegionID>3117</RegionID>
            <RegionName>河北</RegionName>
          </Province> 
          <Province diffgr:id="Province29" msdata:rowOrder="28" diffgr:hasChanges="inserted">
            <RegionID>311101</RegionID>
            <RegionName>北京</RegionName>
          </Province>
         <Country diffgr:id="Country1" msdata:rowOrder="0">
            <RegionID>3320</RegionID>
            <RegionName>阿尔及利亚</RegionName>
          </Country>
        </getRegion>
      </diffgr:diffgram>
    </DataSet>

观察相应结果，北京的`RegionID`是311101，但如何将它提取出来并保存到变量中呢？这就要用到【正则表达式提取器】了。在HTTP请求`getRegionDataset`上添加【后置处理器】-【正则表达式提取器】。

2、【正则表达式提取器】：  
![在这里插入图片描述][20200610165959895.png]

1.  引用名称：code，后面引用该值时，将使用`${code}`的固定写法。
2.  正则表达式：`<RegionID>(.+?)</RegionID>\r\n\ <RegionName>北京</RegionName>`，注意中间的8个空格，不能多一个也不能少一个。
3.  模板：`$1$`，表示取第一列，下文【正则表达式提取器】会有详细解释。
4.  匹配数字：1，表示取第一行，下文【正则表达式提取器】会有详细解释。

3、【HTTP请求】`getSupportCityDataSet`：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 3]

1.  IP：ws.webxml.com.cn
2.  路径：/WebServices/WeatherWS.asmx/getSupportCityDataset?theRegionCode=$\{code\}
3.  作用：获得支持的城市/地区名称和与之对应的ID
4.  相应结果：  
    ![在这里插入图片描述][20200610170932289.png]  
    ![在这里插入图片描述][20200610171651143.png]

## 2 常用正则表达式详解 ##

**正则表达式**描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。

正则表达式是相对繁琐抽象的，理解和记忆难度较高，因此这里对JMeter中能用到的正则表达式语法（主要是限定符）进行一下讲解。

据我个人经验，(.+?)这个表达式基本就够用了，何况正则表达式提取远不如JSON提取器使用频率高，所以这一节大可以略过，直接看第三节。

<table> 
 <thead> 
  <tr> 
   <th>字 符</th> 
   <th>描 述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>.</td> 
   <td>匹配除换行符 \n 之外的任何单字符</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>贪婪，匹配前面的子表达式零次或多次，等价于{0,}</td> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>占有，匹配前面的子表达式一次或多次，等价于{1,}</td> 
  </tr> 
  <tr> 
   <td>?</td> 
   <td>懒惰，匹配前面的子表达式零次或一次 ，等价于 {0,1}</td> 
  </tr> 
  <tr> 
   <td>{n}</td> 
   <td>n 是一个非负整数。匹配确定的 n 次。例如a{3}匹配“aaaaa”，能匹配到“aaa”</td> 
  </tr> 
  <tr> 
   <td>{n,m}</td> 
   <td>重复n到m次，例如正则 “a{3,4}” 将a重复匹配3次或者4次</td> 
  </tr> 
  <tr> 
   <td>*?</td> 
   <td>重复任意次，但尽可能少重复，如 “acbacb” 正则 “a.*?b” 只会取到第一个"acb"</td> 
  </tr> 
  <tr> 
   <td>+?</td> 
   <td>重复1次或更多次，但尽可能少重复，与上面一样，不同的是至少重复一次</td> 
  </tr> 
  <tr> 
   <td>??</td> 
   <td>重复0次或1次，但尽可能少重复，如 “aaacb” 正则 “a.??b” 只会取到最后的三个字符"acb"</td> 
  </tr> 
  <tr> 
   <td>{n,m}?</td> 
   <td>重复n到m次，但尽可能少重复，如 “aaaaaaaa” 正则 “a{0,m}” 因为最少是0次所以取到结果为空</td> 
  </tr> 
  <tr> 
   <td>{n,}?</td> 
   <td>重复n次以上，但尽可能少重复，如 “aaaaaaa” 正则 “a{1,}” 最少是1次所以取到结果为 “a”</td> 
  </tr> 
 </tbody> 
</table>

部分表达式使用【正则表达式测试器】实测结果如下：

1.  `*`：0次或多次，因为0个也被能匹配，所以b、c和末尾被匹配成空  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 4]
2.  `+`：一个或多个，因为至少要匹配一个，不会有空字符串  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 5]
3.  `？`：0个或一个，同\*一样，没有a的被匹配成空字符串  
    ![在这里插入图片描述][20190620200147320.png]
4.  `a{n}`:  
    ![在这里插入图片描述][201906202007289.png]
5.  `a{n,m}`：  
    ![在这里插入图片描述][20190620200806447.png]
6.  `a{n,}`：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 6]

## 3 正则表达式提取器 ##

正则表达式提取器一般在取样器上创建，它的作用是在取样器（包括HTTP请求和BeanShell Sampler及其他取样器）的结果中按照一定的规则提取特定的值，并保存到内存中的某一个字段上，正则表达式所在的取样器之后的组件，都能通过引用方式（格式：`${XXX}`)使用该值。  
![在这里插入图片描述][20200610172622442.png]

### 3.1 参数详解 ###

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>描述</th> 
   <th>必须</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>名称</td> 
   <td>脚本中显示的这个元件的描述性名称</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>Apply to</td> 
   <td>Main sample only：仅适用于主样本，默认用这个就可以了</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>Field to check</td> 
   <td><strong>要检查的响应字段</strong>，即在取样器响应内容的哪个区域进行匹配</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>Name of created variable</td> 
   <td><strong>引用名称</strong>，即匹配到的变量存储的名称，一般会有[refname]_g（匹配数量）、[refname]_g0 （整体）、[refname]_gn（某个具体匹配值）等多个变量，</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>Regular Expression</td> 
   <td><strong>正则表达式</strong>，用于分析响应数据的正则表达式，除非使用$0$组，否则必须至少包含一组括号</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>Template</td> 
   <td><strong>模板</strong>，如果在正则表达式中有多<strong>列</strong>结果，则可以是$2$$3$等等，表示解析到的第几个值给title，如：$1$表示解析到的第1个值</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>Match No. (0 for Random)</td> 
   <td><strong>匹配数字</strong>，取第几<strong>行</strong>，0代表随机取值，-1代表全部取值，1、2、3等表示多行返回值取第几个值。</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>Default Value</td> 
   <td>缺省值,如果表达式没有取得到值，就使用这个默认值</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>Use empty default value</td> 
   <td>勾选此项后，如果未提取到值，则给变量赋予空字符串，而不是null</td> 
   <td>是</td> 
  </tr> 
 </tbody> 
</table>

### 3.2 使用示例 ###

先看这么一个场景，假如响应内容`ccBBmmAABBAAddBBAA`，想在该响应内容中提取`AAddBB`并存储到参数`test`中，该如何处理？

首先，观察待匹配字符串的左右边界分别是`BB`和`AA`，那么正则表达式应写成`BB(.+?)AA`，在【正则表达式测试器】中测试一下：  
![在这里插入图片描述][20190621114913433.png]  
可以看到，第1列（列从0开始计数）第二行是我们想要的结果，因此【正则表达式提取器】中按下图填写：  
![在这里插入图片描述][20200610173105703.png]  
接下来，我们使用【BeanShell Sampler】模拟服务，来测试一下：  
![在这里插入图片描述][20200610173801938.png]  
![在这里插入图片描述][2020061017383746.png]  
HTTP请求IP中引用正则表达式提取器提取到的`test`：  
![在这里插入图片描述][20200610173854578.png]  
![在这里插入图片描述][20200610173949188.png]

## 4 JSON提取器 ##

在【后置处理器】中，有一个【JSON提取器】，与【正则表达式提取器】有类似的作用，不同的是，前者专为处理JSON型的响应结果而生。  
![在这里插入图片描述][20200610174256119.png]

### 4.1 参数详解 ###

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>描述</th> 
   <th>必须</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Name</td> 
   <td><strong>名称</strong>，脚本中显示的这个元件的描述性名称</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>Names of chreated variables</td> 
   <td>匹配到的数据存储的变量名称，后续可以使用<code>${variable name}</code>引用它</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>JSON Path Expressions</td> 
   <td>JSON路径表达式</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>Default Values</td> 
   <td>默认值，如果JSON 路径表达式未能匹配到值，将使用该默认值</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>Match No. (0 for Random)</td> 
   <td>如果匹配到多个结果，选择使用哪个。0代表随机，-1代表全部，x代表第x个</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>Compute concatenation var</td> 
   <td>勾选此项后，如果匹配到多个结果，JMeter会使用","将他们连接起来，存储在的变量中</td> 
   <td>是</td> 
  </tr> 
 </tbody> 
</table>

### 4.2 使用示例 ###

接下来，我们看一个示例：

假如接口返回下面的JSON数据，我们想在其中提取“周芷若”到“name”参数中。

{
        
    	"status":200,
    	"data":[{
        "id":101,"name":"张无忌"},{
        "id":102,"name":"周芷若"}]
    }

首先，构造脚本结果如下图，【BeanShell Sampler】作为mock server返回上面的数据：  
![在这里插入图片描述][20200610183959805.png]

return "{\"status\":200,\"data\":[{\"id\":101,\"name\":\"张无忌\"},{\"id\":102,\"name\":\"周芷若\"}]}";

在【BeanShell Sampler】下面添加【后置处理器】–【JSON Extractor】  
![在这里插入图片描述][20200610181506604.png]  
这里解释一下【JSON Path expression】的写法，

*  . 首先`$.`这部分是固定写法
 *  `data`表示在JSON串以"data"为key获取value，也就是"`[{\"id\":101,\"name\":\"张无忌\"},{\"id\":102,\"name\":\"周芷若\"}]`"。
 *  `data`所对应的值是一个`JSONArray`（JSON数组）格式，里面有两个JSONObject（JSON对象），第二个JSONObject是我们需要的，因此再按索引值"1"去获取，写作`data[1]`，写到这里，我们得到了`{\"id\":102,\"name\":\"周芷若\"}`这个`JSONObject`，接下来再根据`name`这个key去获取相应的值，就得到"周芷若"了。
 *

运行脚本，查看结果树中的【Debug Sampler】的响应数据：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 7]

后来在自己开发接口自动化框架的过程中，借鉴JMeter的这个功能，做了一个工具类，在响应结果是JSON串的接口中提取数据十分方便。

import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONArray;
    import com.alibaba.fastjson.JSONObject;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    /**
     * @author guozhengMu
     * @version 1.0
     * @date 2018/12/20 13:07
     * @description 根据自定义的字符串解析提取json中的特定内容
     * @modify
     */
    public class JsonPathExpression {
        
        public static void main(String[] args) {
        
            String str = "{\"data\" : {\"deth\" : {\"bids\" : [[\"3.637\", \"360000\"]],\"asks\" : [[\"4.273\", \"662\"],[[{\"a\":[1,2]}]]]}}}";
    //      String result = jsonPathExpression("{\"status\" : 200,\"employees\" : [{\"firstName\" : \"Bill\",\"lastName\" : \"Gates\"}, {\"firstName\" : \"George\",\"lastName\" : \"Bush\"}]}", "$.employees[1].firstName");
            String result = jsonPathExpression(str, "$.data.deth.asks[1].[0].[0].a[1]");
            System.out.println(result);
        }
    
        /**
         * 根据路径表达式解析JSON
         *
         * @param jsonString 待处理的字符串
         * @param matcher    路径表达式
         * @return
         */
        public static String jsonPathExpression(String jsonString, String matcher) {
        
            String[] jsons = matcher.split("\\.");
    
            JSONObject object = JSON.parseObject(jsonString);
            JSONArray array = new JSONArray();
            String result = "";
            int index;
    
            for (int i = 1; i < jsons.length; i++) {
        
                if (jsons[i].contains("[")) {
        
                    // 解析数字
                    index = getIndex(jsons[i]);
                    if (i == jsons.length - 1) {
         // 最后一层
                        // 特殊情况处理
                        if (jsons[i].length() <= 3) {
        
                            // []必然是从array中取值
                            result = array.getString(index);
                        } else {
        
                            array = object.getJSONArray(jsons[i].split("\\[")[0]);
                            result = array.getString(index);
                        }
                    } else {
         // 不是最后一层
                        if (jsons[i].length() <= 3) {
        
                            try {
        
                                array = array.getJSONArray(index);
                            } catch (Exception e) {
        
                                object = array.getJSONObject(index);
                            }
                        } else {
        
                            // 不知道下一层是array还是object
                            try {
        
                                array = object.getJSONArray(jsons[i].split("\\[")[0]).getJSONArray(index);
                            } catch (Exception e) {
        
                                object = object.getJSONArray(jsons[i].split("\\[")[0]).getJSONObject(index);
                            }
                        }
                    }
                } else {
        
                    if (i != jsons.length - 1) {
        
                        object = object.getJSONObject(jsons[i]);
                    } else {
        
                        result = object.getString(jsons[i]);
                    }
                }
            }
            return result;
        }
    
        /**
         * 将字符串中的数字解析出来
         *
         * @param string:待处理的字符串
         * @return
         */
        public static int getIndex(String string) {
        
            try {
        
                String regEx = "[^0-9]";
                Pattern pattern = Pattern.compile(regEx);
                Matcher matcher = pattern.matcher(string);
                String index = matcher.replaceAll("").trim();
                return Integer.valueOf(index);
            } catch (Exception e) {
        
                return 0;
            }
        }
    }

## 5 疑难杂症 ##

这一节主要记录一些比较特殊的场景和其解决方案。

### 5.1 提取多个值 ###

*  响应结果：

{
        
    	"result" : {
        
    		"similar" : [{
        
    				"id" : "us-B072HFDHKY",
    				"asin" : "B072HFDHKY"
    			}, {
        
    				"id" : "us-B073WM827B",
    				"asin" : "B073WM827B"
    			}, {
        
    				"id" : "us-B07GY17KFZ",
    				"asin" : "B07GY17KFZ"
    			}, {
        
    				"id" : "us-B076NYPS7M",
    				"asin" : "B076NYPS7M"
    			}, {
        
    				"id" : "us-B07NSBBX7L",
    				"asin" : "B07NSBBX7L"
    			}, {
        
    				"id" : "us-B077W9GHDV",
    				"asin" : "B077W9GHDV"
    			}
    		]
    	},
    	"code" : 0,
    	"message" : "操作成功!"
    }

*  实现目标：在响应结果中前3个 asin 的值。

以上场景，响应结果是JSON格式，在正常情况下，使用【后置处理器】中的【JSON Extractor】显然是很方便的（提取路径：`$.result.similar[0].asin` 即可获取第一个 asin 的值）。但由于要提取不止一个 asin 值，【JSON Extractor】就不太适用了，这时候要用到【正则表达式提取器】。

1.  建立下面的脚本结构：  
    ![在这里插入图片描述][20200610184725785.png]  
    【BeanShell Sampler】的作用依然是模拟接口响应：

return 
    "{\"result\":{\"similar\":[{\"id\":\"us-B072HFDHKY\",\"asin\":\"B072HFDHKY\"},{\"id\":\"us-B073WM827B\",\"asin\":\"B073WM827B\"},{\"id\":\"us-B07GY17KFZ\",\"asin\":\"B07GY17KFZ\"},{\"id\":\"us-B076NYPS7M\",\"asin\":\"B076NYPS7M\"},{\"id\":\"us-B07NSBBX7L\",\"asin\":\"B07NSBBX7L\"},{\"id\":\"us-B077W9GHDV\",\"asin\":\"B077W9GHDV\"}]},\"code\":0,\"message\":\"操作成功!\"}";

1.  【正则表达式提取器】：  
    ![在这里插入图片描述][20200610184904618.png]  
    正则表达式：`"asin":(.+?)"}`
2.  运行脚本，查看结果：  
    ![在这里插入图片描述][20200610185451886.png]  
    可见，所有 asin 值已经被提取并保存在内存中，后续的组件中可以任意引用。
3.  引用值  
    ![在这里插入图片描述][20200610185255552.png]  
    ![在这里插入图片描述][20200610185801453.png]

### 5.2 多个值合并 ###

如果响应内容是`<name = Author value = Muguozheng>`，我们同时提取到`Author:Muguozheng`、`Author`、`Muguozheng`作为下次请求参数，该如何做呢？

首先，去【正则表达式试验器】中测试  
![在这里插入图片描述][20190621150839645.png]  
根据匹配要求和正则表达式的测试结果，【正则表达式提取器】如下：  
![在这里插入图片描述][20200610190431521.png]  
正则表达式：`<name = (.+?) value = (.+?)>`  
模板：`$1$;$2$`

运行后查看结果树，后面的sampler（取样器）引用规则如下：

1.  使用`${test}`可以引用`Author:Muguozheng`
2.  使用`${test_g}`可以引用`2`这个数值
3.  使用`${test_g0}`可以引用`<name = Author value = Muguozheng>`
4.  使用`${test_g1}`可以引用`Author`
5.  使用`${test_g2}`可以引用`Muguozheng`

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 8]

### 5.3 左右边界不好确定 ###

假如响应结果是这么一个字符串：`<name = Readers value = 马云,马化腾,刘强东>`（向三位大佬致敬），想要提取`马化腾`这个值。

这个例子的难点在于，正则表达式的左右边界无法确定，因为`马化腾`的右边界`,刘强东`也是响应内容中的动态值（这里的动态指的是，下次请求整体的响应内容可能变成"<name = Readers value = 张三,李四,王五>"）。

这里，正则表达式写成下面的样式即可：  
![在这里插入图片描述][20190621154201957.png]  
于是，【Beanshell Sampler】写入模拟数据

return "<name = Readers value = 马云,马化腾,刘强东>";

【正则表达式提取器】可以如下图输入：  
![在这里插入图片描述][20200610190933524.png]  
正则表达式：`<name = Readers value = (.+?),(.+?),(.+?)>`  
模板：`$2$`

运行后查看结果树：  
![在这里插入图片描述][20200610191045315.png]

### 5.4 多个匹配结果 ###

在实际工作中，接口响应结果可能是一个集合，具有同样的左右边界，但我们需要的是最新的那条，一般是最后一条。

如下，新建一个【Beanshell Sampler】模拟接口：

return "<td>您的验证码是：400836，切勿将验证码告诉他人<td><td>您的验证码是：54297，切勿将验证码告诉他人<td><td>您的验证码是：65291，切勿将验证码告诉他人<td>";

接下来在【Beanshell Sampler】下创建【正则表达式提取器】（匹配数字写-1，表示取所有匹配结果）：  
![在这里插入图片描述][20200610191447397.png]  
正则表达式：您的验证码是：(.+?)，切勿将

添加【Debug Sampler】和【查看结果树】后运行脚本，在【查看结果树】中可以看到，【正则表达式提取器】匹配结果：  
![在这里插入图片描述][20200610191732513.png]

code_1=400836
    code_1_g=1
    code_1_g0=您的验证码是：400836，切勿将
    code_1_g1=400836
    code_2=54297
    code_2_g=1
    code_2_g0=您的验证码是：54297，切勿将
    code_2_g1=54297
    code_3=65291
    code_3_g=1
    code_3_g0=您的验证码是：65291，切勿将
    code_3_g1=65291
    code_matchNr=3

那么我们想获得匹配结果的最后一个，该怎么操作呢？这个问题的难点在于，事先无法确定匹配结果的数量，而解决这个难点的关键就在于`code_matchNr`这个参数，它的含义是匹配到的结果的数量，它的值就是最后一个匹配结果的索引。

很明显，取`code_${code_matchNr}`就等值于code\_3，无论匹配结果的数量是多少，`code_${code_matchNr}`都代表着最后一条结果。

JMeter不支持嵌套引用，所以`${code_${code_matchNr}}`这种写法是不正确的。想正确引用该值，需要打开【Tools】-【函数助手对话框】，选择`_V`，填入`code_${code_matchNr}`，点击生成：  
![在这里插入图片描述][20200610192042408.png]  
`${__V(code_${code_matchNr})}` 这个表达式就表示引用了匹配结果的最后一个。

### 5.5 其他特殊用法 ###

在身份证中匹配提取出生日期，正则表达式如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 9]

以上就是如何**使用正则表达式提取器和JSON提取器实现关联**的全部内容，觉得不错的朋友请点个赞和收藏，有不准确之处，欢迎指正。

[https_blog.csdn.net_mu_wind_article_details_91879280]: https://blog.csdn.net/mu_wind/article/details/91879280
[https_blog.csdn.net_mu_wind_article_details_92796646]: https://blog.csdn.net/mu_wind/article/details/92796646
[https_blog.csdn.net_mu_wind_article_details_93312052]: https://blog.csdn.net/mu_wind/article/details/93312052
[https_blog.csdn.net_mu_wind_article_details_93506974]: https://blog.csdn.net/mu_wind/article/details/93506974
[https_blog.csdn.net_mu_wind_article_details_95733081]: https://blog.csdn.net/mu_wind/article/details/95733081
[https_blog.csdn.net_mu_wind_article_details_95752633]: https://blog.csdn.net/mu_wind/article/details/95752633
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200810150558225.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200810150640530.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200810151135829.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ=,size_16,color_FFFFFF,t_70
[WeatherWS]: http://ws.webxml.com.cn/WebServices/WeatherWS.asmx
[20190620175154185.png]: https://img-blog.csdnimg.cn/20190620175154185.png
[20200610165215732.png]: https://img-blog.csdnimg.cn/20200610165215732.png
[20200610165534157.png]: https://img-blog.csdnimg.cn/20200610165534157.png
[20200610165959895.png]: https://img-blog.csdnimg.cn/20200610165959895.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200610171451151.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ=,size_16,color_FFFFFF,t_70
[20200610170932289.png]: https://img-blog.csdnimg.cn/20200610170932289.png
[20200610171651143.png]: https://img-blog.csdnimg.cn/20200610171651143.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20190620195836789.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20190620195920952.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ=,size_16,color_FFFFFF,t_70
[20190620200147320.png]: https://img-blog.csdnimg.cn/20190620200147320.png
[201906202007289.png]: https://img-blog.csdnimg.cn/201906202007289.png
[20190620200806447.png]: https://img-blog.csdnimg.cn/20190620200806447.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20190620200905778.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ=,size_16,color_FFFFFF,t_70
[20200610172622442.png]: https://img-blog.csdnimg.cn/20200610172622442.png
[20190621114913433.png]: https://img-blog.csdnimg.cn/20190621114913433.png
[20200610173105703.png]: https://img-blog.csdnimg.cn/20200610173105703.png
[20200610173801938.png]: https://img-blog.csdnimg.cn/20200610173801938.png
[2020061017383746.png]: https://img-blog.csdnimg.cn/2020061017383746.png
[20200610173854578.png]: https://img-blog.csdnimg.cn/20200610173854578.png
[20200610173949188.png]: https://img-blog.csdnimg.cn/20200610173949188.png
[20200610174256119.png]: https://img-blog.csdnimg.cn/20200610174256119.png
[20200610183959805.png]: https://img-blog.csdnimg.cn/20200610183959805.png?
[20200610181506604.png]: https://img-blog.csdnimg.cn/20200610181506604.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200610184137436.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ=,size_16,color_FFFFFF,t_70
[20200610184725785.png]: https://img-blog.csdnimg.cn/20200610184725785.png
[20200610184904618.png]: https://img-blog.csdnimg.cn/20200610184904618.png
[20200610185451886.png]: https://img-blog.csdnimg.cn/20200610185451886.png
[20200610185255552.png]: https://img-blog.csdnimg.cn/20200610185255552.png
[20200610185801453.png]: https://img-blog.csdnimg.cn/20200610185801453.png
[20190621150839645.png]: https://img-blog.csdnimg.cn/20190621150839645.png
[20200610190431521.png]: https://img-blog.csdnimg.cn/20200610190431521.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200610190540726.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ=,size_16,color_FFFFFF,t_70
[20190621154201957.png]: https://img-blog.csdnimg.cn/20190621154201957.png
[20200610190933524.png]: https://img-blog.csdnimg.cn/20200610190933524.png
[20200610191045315.png]: https://img-blog.csdnimg.cn/20200610191045315.png
[20200610191447397.png]: https://img-blog.csdnimg.cn/20200610191447397.png
[20200610191732513.png]: https://img-blog.csdnimg.cn/20200610191732513.png
[20200610192042408.png]: https://img-blog.csdnimg.cn/20200610192042408.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20190621155010909.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211X3dpbmQ=,size_16,color_FFFFFF,t_70