Apache Jmeter进阶-RPC服务压测

声明：原创文章，转载请注明出处。https://www.jianshu.com/p/28af8acd7ad5

在上一节Apache Jmeter入门中，我们简单介绍了Jmeter的使用方法。
本节中，我们将着重介绍Jmeter压测，以Thrift RPC为例子进行讲解。

1、准备

我们依然采用Thrift RPC这节中的RPC服务作为服务端程序并运行。

服务端

2、Jmeter测试类编写

2.1 Jmeter测试类简介

新建一个普通的Java工程
添加JMeter Maven依赖。


    org.apache.jmeter
    ApacheJMeter_core
    2.13
 
 
    org.apache.jmeter
    ApacheJMeter_java
    2.13

新建一个Java Class，如下例中的TestThriftByJmeter，并继承AbstractJavaSamplerClient。
AbstractJavaSamplerClient中默认实现了四个可以覆盖的方法，分别是getDefaultParameters()，setupTest()，runTest()和teardownTest()方法。
getDefaultParameters 方法主要用于设置传入界面的参数；
setupTest方法为初始化方法，用于初始化性能测试时的每个线程；
runTest方法为性能测试时的线程运行体；
teardownTest方法为测试结束方法，用于结束性能测试中的每个线程。

2.2 RPC Thrift测试类编写

ThriftClient

public class ThriftClient {
    private ComputeServer.Client client = null;
    private TTransport transport = null;

    protected ThriftClient(String ip, int port) {
        try {
            TTransport transport = new TFramedTransport(new TSocket(ip, port));
            transport.open();
            TProtocol protocol = new TBinaryProtocol(transport);
            client = new ComputeServer.Client(protocol);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    protected ComputeResponse getResponse(ComputeRequest request) {
        try {
            ComputeResponse response = client.getComputeResult(request);
            return response;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    protected void close() {
        if (transport != null && transport.isOpen()) {
            transport.close();
        }
    }
}

TestThriftByJmeter

public class TestThriftByJmeter extends AbstractJavaSamplerClient {
    private ThriftClient client;
    private ComputeRequest request;
    private ComputeResponse response;

    @Override
    public Arguments getDefaultParameters() {
        Arguments arguments = new Arguments();
        arguments.addArgument("ip", "127.0.0.1");
        arguments.addArgument("port", "9000");
        arguments.addArgument("X", "0");
        arguments.addArgument("Y", "0");
        arguments.addArgument("type", "0");
        return arguments;
    }

    @Override
    public void setupTest(JavaSamplerContext context) {
        try {
            // 获取参数
            String ip = context.getParameter("ip");
            int port = context.getIntParameter("port");
            int x = context.getIntParameter("X");
            int y = context.getIntParameter("Y");
            ComputeType type = getComputeType(context.getIntParameter("type"));

            // 创建客户端
            client = new ThriftClient(ip, port);
            // 设置request请求
            request = new ComputeRequest(x, y, type);
        } catch (Exception e) {
            e.printStackTrace();
        }
        super.setupTest(context);
    }
    
    public SampleResult runTest(JavaSamplerContext context) {
        SampleResult result = new SampleResult();
        result.sampleStart();
        try {
            long begin = System. currentTimeMillis();
            response = client.getResponse(request);
            long cost = (System.currentTimeMillis() - begin);
            System.out.println(response.toString() + " cost:[" + cost + "ms]");

            if (response == null) {
                result.setSuccessful(false);
                return result;
            }
            if (response.getErrorNo() == 0) {
                result.setSuccessful(true);
            } else {
                result.setSuccessful(false);
            }
        } catch (Exception e) {
            result.setSuccessful(false);
            e.printStackTrace();
        }  finally {
            result.sampleEnd();
        }
        return result;
    }
    
    public void tearDownTest(JavaSamplerContext context) {
        if (client != null) {
            client.close();
        }
        super.teardownTest(context);
    }

    ComputeType getComputeType(int type) {
        ComputeType computeType;
        switch (type) {
            case 0: computeType = ComputeType.ADD; break;
            case 1: computeType = ComputeType.SUB; break;
            case 2: computeType = ComputeType.MUL; break;
            case 3: computeType = ComputeType.DIV; break;
            default: computeType = ComputeType.ADD; break;
        }
        return computeType;
    }
}

代码结构：