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

最新推荐文章于 2024-05-28 11:06:04 发布

哈布哥

最新推荐文章于 2024-05-28 11:06:04 发布

阅读量2.6k

点赞数

分类专栏： Jmeter测试及应用文章标签： jmeter java请求 dubbo 接口测试

本文链接：https://blog.csdn.net/nitibu/article/details/80977484

版权

Jmeter测试及应用专栏收录该内容

6 篇文章 1 订阅

订阅专栏

如何构建一个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);
    }

}

哈布哥

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Jmeter测试及应用--使用Java请求进行Dubbo接口的测试

如何构建一个Dubbo接口测试的通用框架从上面的流程我们可以看出，测试类大致的一个结构：使用json文件来构造测试数据 java程序只对json文件进行解析接口调用成功后，用json文件中的期望数据来对接口返回数据进行比对，判断调用是否成功json文件的定义{ "Connection": { "URL": "101.219.255.73:50883", "S...
复制链接

扫一扫