Jmeter测试及应用--使用Java请求进行Dubbo接口的测试

如何构建一个Dubbo接口测试的通用框架

从上面的流程我们可以看出，测试类大致的一个结构：

• 使用json文件来构造测试数据
• java程序只对json文件进行解析
• 接口调用成功后，用json文件中的期望数据来对接口返回数据进行比对，判断调用是否成功

json文件的定义

{
  "Connection": {
    "URL": "101.219.255.73:50883",
    "SERVICE_NAME": "com.company.mdapi.sdk.material.export.MaterialApiService",
    "VERSION": "1.0.0",
    "METHOD": "queryUnboundListByPage",
    "HELPCLASS": "com.utils.common.helper.MaterialApiService.QueryUnboundListByPageHelper"
  },
  "Random": false,
  "Args": {
    "sourceSystem": 2,
    "querySourceSystem": null,
    "materialCode": "MD_S6006",
    "materialName": null,
    "materialType": null,
    "pkId": null,
    "shipperCode": "ZA01",
    "storageCenterCode": "HZA1",
    "pager": {
      "page": 1,
      "rows": 5,
      "totalCount": null,
      "pageOffset": null,
      "sort": "ID",
      "order": "ASC",
      "totalPage": null,
      "pageCode": 7,
      "startPageIndex": null,
      "endPageIndex": null,
      "previewPage": null,
      "nextPage": null
    }
  },
  "Verify": false
}

参数具体定义：

• Connection：Dubbo服务的地址URL、服务名称SERVICE_NAME、版本号VERSION、远程接口调用的方法METHOD、
  数据转化处理的辅助类HELPCLASS。
• Random：用来是能随机数设置，压力测试类似Add数据库操作时可以绕过数据库预设好的唯一性校验。
• Args：调用接口时，传入的参数，这里提供的参数需要在辅助类中转换成接口参数，然后调用接口。
• Verify：保留值，暂无使用

Java程序实现数据转换及接口调用

• 辅助的Help类，需要继承SampleHelper类，同时实现其中的两个抽象方法readJsonFile和callRemoteMethod，
  分别用来读取json配置文件和调用远程方法（实际测试人员只需要实现这两个方法就可以进行Dubbo接口测试）。

public class AddMaterialListHelper extends SampleHelper<Result<List<FailData>>> {

    public static final String[] RANDOM_FIELD = {"materialCode","materialName"};
    
    @Override
    public Map<String, Object> readJsonFile(String jsonPath) {
        JsonParser parser = new JsonParser();

        try {
            JsonObject json=(JsonObject) parser.parse(new FileReader(jsonPath));
            Map<String, Object> values = new HashMap<String, Object>();
            UtilsHelper.getInstance().getConnectionArgument(values, json);

            JsonObject args=json.get("Args").getAsJsonObject();
            if (!args.get("data").isJsonNull()) {
                String jsonArray = args.get("data").getAsJsonArray().toString();
                //TODO
                Gson gson = new Gson();
                @SuppressWarnings("serial")
				List<MaterialInterfaceDTO> dtoList = gson.fromJson(jsonArray,
                        new TypeToken<List<MaterialInterfaceDTO>>() {
                        }.getType());
                RandomNum.setRandom(json , RANDOM_FIELD , dtoList);
                values.put("data", dtoList);
            }

            if (!args.get("sourceSystem").isJsonNull()) {
                values.put("sourceSystem", new Integer(args.get("sourceSystem").getAsInt()));
            }

            return values;

        } catch (JsonIOException e) {
            e.printStackTrace();
        } catch (JsonSyntaxException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public Result<List<FailData>> callRemoteMethod(Object object, Map<String, Object> values) {
    	 MaterialInterfaceService service = (MaterialInterfaceService) object;
         @SuppressWarnings("unchecked")
		Result<List<FailData>> callResult = service.addMaterialList (
        		 (int) values.get("sourceSystem"),
                 (List<MaterialInterfaceDTO>) values.get("data"));
         return callResult;
    }
}

• 这里有个注意点，由于个博主所在的团队把接口参数封装成了一个可序列化的class类，所以需要进行数据转化，有些公司的
  接口参数直接传json字符串，那么只需要把json转换为字符串进行传参就可以。
  
  参数封装为序列化的class类：

  public class MaterialInterfaceDTO implements Serializable {
      private static final long serialVersionUID = -3725469669741557392L;
      private String materialCode;
      private String materialName;
      private Integer materialType;
      private Integer importFlag;
      private String sixNineCode;
      private Long expirationDate;
      private Long packingSpecification;
      private String basicUnit;
      private String minSaleUnit;
      private String basicUnitName;
      private String minSaleUnitName;
      private String materialImageUrl;
      private Integer transportFlag;
      private Integer sourceSystem;
      private String createName;
      private String updaterName;
  
      public MaterialInterfaceDTO() {
      }
  
      public String getMaterialCode() {
          return this.materialCode;
      }
  
      public void setMaterialCode(String materialCode) {
          this.materialCode = materialCode;
      }
  
      public String getMaterialName() {
          return this.materialName;
      }
  
      public void setMaterialName(String materialName) {
          this.materialName = materialName;
      }
  
      public Integer getMaterialType() {
          return this.materialType;
      }

   

• 在init中通过java反射机制，获取json配置文件中设置好的辅助类的对象，然后在runTest中调用对应辅助类中
  callRemoteMethod，返回的结果解析后放到SampleResult的responeData，用来在jmeter中使用后置处理器进行
  结果判断。

  package com.utils.common;
  
  import com.alibaba.dubbo.config.ApplicationConfig;
  import com.alibaba.dubbo.config.ReferenceConfig;
  import com.google.gson.JsonObject;
  import com.google.gson.JsonParser;
  import org.apache.jmeter.config.Arguments;
  import org.apache.jmeter.protocol.java.sampler.AbstractJavaSamplerClient;
  import org.apache.jmeter.protocol.java.sampler.JavaSamplerContext;
  import org.apache.jmeter.samplers.SampleResult;
  
  import java.util.Map;
  
  public class RunMethodTest extends AbstractJavaSamplerClient {
      private static String JMX_PATH = null;
      private static String TAG = Thread.currentThread().getStackTrace()[1].getClassName();
      private SampleHelper helper = null;
      private Map<String, Object> values = null;
      private Map<String, Object> config = UtilsHelper.getInstance().getConfigProperties();
      private String ARGS_FILE;
      private Object object;
  
      public void setupTest(){
          //定义测试初始值，setupTest只在测试开始前使用
          System.out.println("setupTest");
      }
  
      public void init() {
          // 当前应用配置
          ApplicationConfig application = new ApplicationConfig();
          application.setName(TAG);
  
          // 获取具体参数配置路径
          if ("true".equals(config.get("DEBUG").toString())) {
              JMX_PATH = ARGS_FILE;
          } else {
              JMX_PATH = UtilsHelper.getInstance().getScriptPath(config.get("SCRIPT_HOME").toString(), ARGS_FILE);
          }
          Map<String, Object> helpArgs = UtilsHelper.getInstance().getHelpClassAndMethod(JMX_PATH);
          helper = (SampleHelper)UtilsHelper.getInstance().invokeStaticMethodByReflect(
                  (String) helpArgs.get("HELPCLASS"),
                  (String) helpArgs.get("HELPMETHOD")
          ) ;
  
          values = helper.readJsonFile(JMX_PATH);
  
          // 注意：ReferenceConfig为重对象，内部封装了与注册中心的连接，以及与服务提供方的连接
          // 引用远程服务，配置dubbo服务版本、服务名称、url地址
          ReferenceConfig reference = new ReferenceConfig(); // 此实例很重，封装了与注册中心的连接以及与提供者的连接，请自行缓存，否则可能造成内存和连接泄漏
          reference.setApplication(application);
          reference.setTimeout(20000);
          reference.setVersion(values.get("conn_version").toString());
          reference.setInterface(values.get("conn_service_name").toString());
          reference.setUrl(values.get("conn_url").toString());
  
          // 和本地bean一样使用xxxService
          object = reference.get(); // 注意：此代理对象内部封装了所有通讯细节，对象较重，请缓存复用\
      }
  
      public SampleResult runTest(JavaSamplerContext arg0) {
          SampleResult sr = new SampleResult(); ;
          try {
              //获取参数
              ARGS_FILE = arg0.getParameter("ARGS_FILE");
  
              //dubbo初始化
              init();
  
              //jmeter结果对象
  //            sr.setSampleLabel(TAG);
              sr.sampleStart();
              sr.setSuccessful(true);
  
              String res = helper.handleResult(helper.callRemoteMethod(object, values));
  
              sr.sampleEnd(); // jmeter 结束统计响应时间标记
              if (res != null) {
                  JsonObject response = new JsonParser().parse(res).getAsJsonObject();
                  System.out.println("\n*************测试返回值****************\n");
                  System.out.print(response.toString()+"\n");
                  if (response.get("code").getAsInt() != 0) {
                      sr.setSuccessful(false);
                  }
                  sr.setResponseData(response.toString(), "UTF-8");
  //                if (null != response.get("data")) {
  //                    sr.setResponseData(response.get("data").toString(), "UTF-8");
  //                    System.out.print(response.get("data").toString()+"\n");
  //                } else if (null != response.get("result")) {
  //                    sr.setResponseData( response.get("result").toString(), "UTF-8");
  //                }
              } else {
                  System.out.print("handleResult return null\n");
              }
  
  
          } catch (Exception e) {
              e.printStackTrace();
              sr.setResponseCode("999");
              sr.setResponseMessage(e.getMessage());
              sr.setSuccessful(false);
          }
          return sr;
      }
  
      public Arguments getDefaultParameters(){
          //参数定义，显示在前台，也可以不定义
          Arguments params = new Arguments();
          params.addArgument("ARGS_FILE", "");
          return params;
      }
  
      public void teardownTest(JavaSamplerContext arg0){
          super.teardownTest(arg0);
      }
  
  }