Jmeter 如何集成JAVA请求采样器&x2B；Red5客户端库

如何为Java请求采样器实现Java类

用JMeter进行RTMP性能测试

Red5—最早的RTMP服务器之一，用Java编写 如何实现Jmeter到Red5 pro服务器 如何测试视频场景 请帮帮我

我想测试RTMP视频流录制是否正确。

示例实现假设如下：

package RTMPSubscriber;

import  org.apache.jmeter.config.Arguments;
import org.apache.jmeter.protocol.java.sampler.AbstractJavaSamplerClient;
import org.apache.jmeter.protocol.java.sampler.JavaSamplerClient;
import org.apache.jmeter.protocol.java.sampler.JavaSamplerContext;
import org.apache.jmeter.samplers.SampleResult;


public class App implements JavaSamplerClient {



    @Override
    public void setupTest(JavaSamplerContext javaSamplerContext) {

    }

    @Override
    public SampleResult runTest(JavaSamplerContext javaSamplerContext) {
        String url = javaSamplerContext.getParameter("url");
        int port = Integer.parseInt(javaSamplerContext.getParameter("port"));
        String app = javaSamplerContext.getParameter("app");
        String streamName = javaSamplerContext.getParameter("name");
        int timeout = Integer.parseInt(javaSamplerContext.getParameter("timeout"));


        SampleResult result = new SampleResult();
        result.sampleStart();
        result.setSampleLabel("Test Sample");
        Subscriber sub = new Subscriber( url, port, app, streamName, timeout);
        sub.Subscribe();
        result.sampleEnd();
        if(!sub.exception) {
            result.setResponseMessage("OK");
            result.setSuccessful(true);
        } else {
            result.setResponseMessage("Error. See logs. If the log does not " +
                    "contain information about the error, I forgot about some exceptions and I am really sorry. T_T");
            result.setSuccessful(false);
        }
        return result;
    }

    @Override
    public void teardownTest(JavaSamplerContext javaSamplerContext) {

    }

    @Override
    public Arguments getDefaultParameters() {
        Arguments defaultParameters = new Arguments();
        defaultParameters.addArgument("url","localhost");
        defaultParameters.addArgument("port","1935");
        defaultParameters.addArgument("app","live");
        defaultParameters.addArgument("name","stream");
        defaultParameters.addArgument("timeout","600");

        return defaultParameters;
    }
}

参考的<代码>订阅者类别：

package RTMPSubscriber;

import org.red5.client.net.rtmp.ClientExceptionHandler;
import org.red5.client.net.rtmp.INetStreamEventHandler;
import org.red5.client.net.rtmp.RTMPClient;
import org.red5.io.utils.ObjectMap;
import org.red5.server.api.event.IEvent;
import org.red5.server.api.event.IEventDispatcher;
import org.red5.server.api.service.IPendingServiceCall;
import org.red5.server.api.service.IPendingServiceCallback;
import org.red5.server.api.stream.IStreamPacket;
import org.red5.server.net.rtmp.event.Notify;
import org.red5.server.net.rtmp.status.StatusCodes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class Subscriber  {

    private Logger log = LoggerFactory.getLogger(Subscriber.class);
    private final String url;
    private final int port;
    private final String application;
    private final String streamName;
    private int timeout;
    private RTMPClient client;
    public boolean exception = false;

    /**
     * @param url
     * @param port
     * @param application
     * @param streamName
     */
    public Subscriber(String url, int port, String application, String streamName, int timeout) {
        this.url = url;
        this.port = port;
        this.application = application;
        this.streamName = streamName;
        this.timeout = timeout;
    }


    public void Subscribe() {

        client = new RTMPClient();
        client.setServiceProvider(this);

        client.setExceptionHandler(new ClientExceptionHandler() {
            @Override
            public void handleException(Throwable throwable) {
                exception=true;
                throwable.printStackTrace();
            }
        });


        client.setStreamEventDispatcher(new IEventDispatcher() {
            @Override
            public void dispatchEvent(IEvent event) {
               // @SuppressWarnings("unused")
                IStreamPacket data = (IStreamPacket) event;
                System.out.println("dispatchEvent: " + event);
                if(event.toString().contains("Video"))
                {
                    System.out.println("dispatchEvent: " + event);
                }
            }
        });


        final INetStreamEventHandler netStreamEventHandler = new INetStreamEventHandler() {
            @Override
            public void onStreamEvent(Notify notify) {
                System.out.println("ClientStream.onStreamEvent: " + notify);
            }
        };
        client.setStreamEventHandler(netStreamEventHandler);


        final IPendingServiceCallback streamCallback = new IPendingServiceCallback() {
            @Override
            public void resultReceived(IPendingServiceCall call) {
                if (call.getServiceMethodName().equals("createStream")) {
                    Number streamId = (Number) call.getResult();
                    // -2: live then recorded, -1: live, >=0: recorded
                    // streamId, streamName, mode, length
                    System.out.println("streamCallback:resultReceived: (streamId " + streamId + ")");
                    client.play(streamId, streamName, -1, 0);

                }
            }
        };

        IPendingServiceCallback connectCallback = new IPendingServiceCallback() {
            @Override
            public void resultReceived(IPendingServiceCall call) {
                ObjectMap<?, ?> map = (ObjectMap<?, ?>) call.getResult();
                String code = (String) map.get("code");
                System.out.println("connectCallback: (code " + code + ")");
                // Server connection established, but issue in connection.
                if (StatusCodes.NC_CONNECT_FAILED.equals(code) || StatusCodes.NC_CONNECT_REJECTED.equals(code) || StatusCodes.NC_CONNECT_INVALID_APPLICATION.equals(code)) {
                    log.error("Rejected: " + map.get("description"));
                    exception=true;
                    client.disconnect();
                    }
                // If connection successful, establish a stream
                else if (StatusCodes.NC_CONNECT_SUCCESS.equals(code)) {
                    client.createStream(streamCallback);
                } else {
                    exception=true;
                    log.error("ERROR code:" + code);
                }
            }
        };
        client.connect(url, port, client.makeDefaultConnectionParams(url, port, application), connectCallback);

            try {
                Thread.sleep(timeout*1000);
            } catch (InterruptedException e) {
                exception=true;
                log.error("Exception: " + e);
            }

        client.disconnect();
        System.out.println("End");
    }

    public void onBWCheck(Object params) {
        System.out.println("onBWCheck: " + params);
    }

    /**
     * Called when bandwidth has been configured.
     */
    public void onBWDone(Object params) {
        System.out.println("onBWDone: " + params);
    }

    public void onStatus(Object params) {
        System.out.println("onStatus: " +  params);
        String status = params.toString();
        // if stream is stopped or unpublished
        if (status.indexOf("Stop") != -1 || status.indexOf("UnPublish") != -1) {
            client.disconnect();
        }
    }
}

包rtmps订户；
导入org.red5.client.net.rtmp.ClientExceptionHandler；
导入org.red5.client.net.rtmp.inetstreamventhandler；
导入org.red5.client.net.rtmp.RTMPClient；
导入org.red5.io.utils.ObjectMap；
导入org.red5.server.api.event.IEvent；
导入org.red5.server.api.event.IEventDispatcher；
导入org.red5.server.api.service.IPendingServiceCall；
导入org.red5.server.api.service.IPendingServiceCallback；
导入org.red5.server.api.stream.IStreamPacket；
导入org.red5.server.net.rtmp.event.Notify；
导入org.red5.server.net.rtmp.status.StatusCodes；
导入org.slf4j.Logger；
导入org.slf4j.LoggerFactory；
公共类订户{
私有日志记录器log=LoggerFactory.getLogger（Subscriber.class）；
私有最终字符串url；
私人最终国际港口；
私有最终字符串应用程序；
私有最终字符串streamName；
私有int超时；
私有rtmpc客户端；
公共布尔异常=false；
/**
*@param-url
*@param端口
*@param应用程序
*@param streamName
*/
公共订阅服务器（字符串url、int端口、字符串应用程序、字符串流名称、int超时）{
this.url=url；
this.port=端口；
这个应用程序=应用程序；
this.streamName=streamName；
this.timeout=超时；
}
公开无效订阅（）{
client=新的RTMPClient（）；
client.setServiceProvider（本）；
client.setExceptionHandler（新的ClientExceptionHandler（）{
@凌驾
公共无效句柄例外（可丢弃可丢弃）{
异常=真；
printStackTrace（）；
}
});
client.setStreamEventDispatcher（新的IEventDispatcher（）{
@凌驾
公共无效调度事件（IEvent事件）{
//@SuppressWarnings（“未使用”）
IStreamPacket数据=（IStreamPacket）事件；
System.out.println（“dispatchEvent:+事件”）；
if（event.toString（）包含（“视频”））
{
System.out.println（“dispatchEvent:+事件”）；
}
}
});
最终InetStreamVenthandler netStreamEventHandler=新的InetStreamVenthandler（）{
@凌驾
公共无效onStreamEvent（通知）{
System.out.println（“ClientStream.onStreamEvent:+notify”）；
}
};
client.setStreamEventHandler（netStreamEventHandler）；
最终IPendingServiceCallback streamCallback=新IPendingServiceCallback（）{
@凌驾
已接收公共无效结果（IPendingServiceCall调用）{
if（调用.getServiceMethodName（）.equals（“createStream”））{
Number streamId=（Number）call.getResult（）；
//-2:直播然后录制，-1:直播，>=0:录制
//streamId、streamName、模式、长度
System.out.println（“streamCallback:resultReceived:（streamId“+streamId+”）；
play（streamId，streamName，-1,0）；
}
}
};
IPendingServiceCallback connectCallback=新的IPendingServiceCallback（）{
@凌驾
已接收公共无效结果（IPendingServiceCall调用）{
ObjectMap=（ObjectMap）调用.getResult（）；
字符串代码=（字符串）map.get（“代码”）；
System.out.println（“connectCallback:（code“+code+”）；
//已建立服务器连接，但连接中出现问题。
如果（StatusCodes.NC|U CONNECT_失败。等于（代码）|状态代码。NC|U CONNECT_被拒绝。等于（代码）|状态代码。NC|U CONNECT_无效_应用程序。等于（代码））{
log.error（“拒绝：”+map.get（“说明”）；
异常=真；
client.disconnect（）；
}
//如果连接成功，则建立流
else if（StatusCodes.NC\u CONNECT\u SUCCESS.equals（code））{
createStream（streamCallback）；
}否则{
异常=真；
日志错误（“错误代码：+代码”）；
}
}
};
connect（url、端口、client.makeDefaultConnectionParams（url、端口、应用程序）、connectCallback）；
试一试{
线程睡眠（超时*1000）；
}捕捉（中断异常e）{
异常=真；
日志错误（“异常：+e”）；
}
client.disconnect（）；
系统输出打印项次（“结束”）；
}
公共void onBWCheck（对象参数）{
System.out.println（“onBWCheck:+params”）；
}
/**
*配置带宽后调用。
*/
公共void onBWDone（对象参数）{
System.out.println（“onBWDone:+params”）；
}
public void onStatus（对象参数）{
System.out.println（“onStatus:+params”）；
字符串状态=params.toString（）；
//如果流已停止或未发布
if（status.indexOf（“停止”）！=-1 | | status.indexOf（“取消发布”）！=-1）{
client.disconnect（）；
}
}
}

更多信息：

---

只有这两个类添加了subcriber code和publicer sampler请求类