我们在做性能测试时,有时需要自己编写测试脚本,很多测试工具都支持自定义编写测试脚本,比如LoadRunner就有很多自定义脚本的协议,比如"C Vuser","Java Vuser"等协议.同样,Jmeter也支持自定义编写的测试代码,不过与LoadRunner不同的是,Jmeter没有自带编译器,需要借助第三方编译器才能实现.下面举一个简单的Java自定义测试代码例子,使用Java编译器编写测试代码(Java编译器可以用Eclipse,JBulider等),实现功能为:在测试前输入任意一个字符串,然后判断该字符串的长度是否大于5,如果大于则测试结果成功,否则测试结果位失败,然后在放到Jmeter中模拟10个用户测试,同时运行这段代码,具体实现如下:
创新互联建站成立以来不断整合自身及行业资源、不断突破观念以使企业策略得到完善和成熟，建立了一套“以技术为基点，以客户需求中心、市场为导向”的快速反应体系。对公司的主营项目，如中高端企业网站企划 / 设计、行业 / 企业门户设计推广、行业门户平台运营、成都app软件开发、手机网站开发、微信网站制作、软件开发、西部信息中心等实行标准化操作，让客户可以直观的预知到从创新互联建站可以获得的服务效果。
1.打开Java编译器,新建一个项目"TestLength",然后新建一个包"app".
2.从Jmeter的安装目录lib/ext中拷贝两个文件"ApacheJMeter_core.jar"和"ApacheJMeter_java.jar"到"Tester"的项目中,然后引入这两个JAR文件.(具体的引入方法参考各个Java编译器的使用方法)
3.在"app"包中新建一个类,名字叫"TestLength",不过这个类要继承"AbstractJavaSamplerClient"类,如果项目引入步骤二中的两个文件,就可以找到"AbstractJavaSamplerClient"类了.
4."TestLength"类在继承"AbstractJavaSamplerClient"类的同时也会继承四个方法,分别是"getDefaultParameters","setupTest","runTest"和"teardownTest"方法."getDefaultParameters"方法主要用于设置传入的参数;"setupTest"方法为初始化方法,用于初始化性能测试时的每个线程."runTest"方法为性能测试时的线程运行体;"teardownTest"方法为测试结束方法,用于结束性能测试中的每个线程.
5.具体实现代码如下:
package app;
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 com.passpod.core.t8.*;
/**
* @author乐以忘忧
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class TestLength extends AbstractJavaSamplerClient{
private SampleResult results;
private String testStr;
//初始化方法，实际运行时每个线程仅执行一次，在测试方法运行前执行，类似于LoadRunner中的init方法
public void setupTest(JavaSamplerContext arg0) {
results = new SampleResult();
testStr = arg0.getParameter("testString", "");
if (testStr != null testStr.length() 0) {
results.setSamplerData(testStr);
}
}
//设置传入的参数，可以设置多个，已设置的参数会显示到Jmeter的参数列表中
public Arguments getDefaultParameters() {
Arguments params = new Arguments();
params.addArgument("testStr", ""); //定义一个参数，显示到Jmeter的参数列表中，第一个参数为参数默认的显示名称，第二个参数为默认值
return params;
}
//测试执行的循环体，根据线程数和循环次数的不同可执行多次，类似于LoadRunner中的Action方法
public SampleResult runTest(JavaSamplerContext arg0) {
int len = 0;
results.sampleStart(); //定义一个事务，表示这是事务的起始点，类似于LoadRunner的lr.start_transaction
len = testStr.length();
results.sampleEnd(); //定义一个事务，表示这是事务的结束点，类似于LoadRunner的lr.end_transaction
if(len 5){
System.out.println(testStr);
results.setSuccessful(false); //用于设置运行结果的成功或失败，如果是"false"则表示结果失败，否则则表示成功
}else
results.setSuccessful(true);
return results;
}
//结束方法，实际运行时每个线程仅执行一次，在测试方法运行结束后执行，类似于LoadRunner中的end方法
public void teardownTest(JavaSamplerContext arg0) {
}
}
6.把上面的例子打包,然后把生成的"TestLength.jar"文件拷贝到Jmeter的安装目录lib/ext下.
7.运行Jmeter,添加一个线程组,然后在该线程组下面添加一个Java请求(在Sampler中),在Java请求的类名称中选择咱们刚创建的类"app.TestLength",在下面参数列表的"testStr"后面输入要测试的字符串,然后添加一个监听器(聚合报告),设置一下模拟的用户数就可以测试了.如果测试不成功,Jmeter会在它自己个输出框中抛出这个字符串.
通过上面的例子我们可以发现,使用Jmeter自定义Java测试代码,配合Jmeter自带的函数,就可以实现出LoadRunner中"Java Vuser"协议的绝大多数功能,而且是没有用户数限制和完全免费的(嘿嘿).上面的例子非常简单,而且没有任何实际意义,只是一个简单的Jmeter测试代码示例,用于抛砖引玉,希望大家一起交流,共同 进步.
首先你要知道jsonp工作原理，实质上也就是利用了一些旁门左道（浏览器对资源文件无限制的特点）来进行的跨域访问，能共用的技术是http，所以在java里可以使用httpclient工具来发送http请求，并把请求做成jsonp的请求模样就行了。
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.net.*;
import java.io.*;
public class Client extends JFrame
{
/**
*
*/
private static final long serialVersionUID = -4733717749265129757L;
Container con=null;
JTextArea jta = null;
JTextField jtf = null;
//ArrayList al = new ArrayList();
//ServerSocket ss = null;
Socket s = null;
Client(String ip,int port)
{
try
{
s = new Socket(ip,port); //创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
launchFrame();
}
catch(Exception e)
{
e.printStackTrace();
}
new Thread(new ClientR()).start();
}
public void sent(String str)
{ //发送消息方法
try
{
DataOutputStream dos = new DataOutputStream(s.getOutputStream()); // 创建一个新的数据输出流，将数据写入指定 返回s的套接字的输出流。
dos.writeUTF(str);
}
catch(Exception e)
{
e.printStackTrace();
}
}
public void disconnect() throws Exception
{
s.close(); //失去连接，关闭线程s
}
class ClientR implements Runnable
{//客户端运行
/*Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。
设计该接口的目的是为希望在活动时执行代码的对象提供一个公共协议。例如，Thread 类实现了 Runnable。
激活的意思是说某个线程已启动并且尚未停止。
此外，Runnable 为非 Thread 子类的类提供了一种激活方式。
通过实例化某个 Thread 实例并将自身作为运行目标，就可以运行实现 Runnable 的类而无需创建 Thread 的子类。
大多数情况下，如果只想重写 run() 方法，而不重写其他 Thread 方法，那么应使用 Runnable 接口。这很重要，
因为除非程序员打算修改或增强类的基本行为，否则不应为该类创建子类。
*/
public void run()
{
try
{
DataInputStream dis = new DataInputStream(s.getInputStream());//使用指定的底层 s.getInputStream（s的套接字的输入流） 创建一个 DataInputStream(数据输入流）
String str = dis.readUTF();
while(true)
{
jta.append(str+"\n");
str = dis.readUTF();
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
public void startClient()
{ //客户端启用
try
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); //读取数据流
String str = br.readLine();
System.out.println(str);
while(true)
{
sent(str); //发送数据
if(str.equals("q"))
{ //如果读取的字符为q
disconnect(); //断开连接
return ;
}
str=br.readLine();
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
public void launchFrame() throws IOException
{ //客户端面板布局
con = this.getContentPane();
jta = new JTextArea();
jtf = new JTextField();
final JTextField jtf1=new JTextField(10);
final JButton jb=new JButton("确认");
Panel p=new Panel();
//Panel p1=new Panel();
JLabel jl=new JLabel();
jl.setText("your name:");
//jl.getVerticalTextPosition();
jtf1.setBackground(Color.PINK);
jtf1.setBounds(10, 10, 10, 10);
p.add(jl);
p.add(jtf1);
p.add(jb);
jb.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
//e.getWhen();
e.getActionCommand();
jtf.setText(jtf1.getText().toString()+"say:");
}
});
jta.setBackground(Color.LIGHT_GRAY);
jta.setEditable(false); //不可编辑文本域
JScrollPane jsp = new JScrollPane(jta, //jta上滚动条的创建
JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
//con.add(jb,BorderLayout.WEST);
con.add(jsp,BorderLayout.CENTER);
con.add(p,BorderLayout.NORTH);
con.add(jtf,BorderLayout.SOUTH);
jtf.addActionListener(new ActionListener()
{ ///事件监听
public void actionPerformed(ActionEvent e)
{
String str = jtf.getText().toString();
Client.this.sent(str);
jtf.setText(jtf1.getText().toString()+"say:");
}
});
this.setTitle("聊天客户端，袭风版");
this.setBounds(200,200,300,400);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setBackground(Color.blue);
this.setVisible(true);
}
public static void main (String[] args)
{
System.out.println("===1");
Client cli = new Client("127.168.1.1",3456); //创建一个客户端，并将其连接到指定 IP 地址的指定端口号，其端口号与服务器端一致。与服务器建立连接
System.out.println("===2");
cli.startClient(); //127.0.0.1为本机端口
}
}
//
//import java.net.*;
//import java.io.*;
//
///*
// 发送给服务器端
//*/
//class Send implements Runnable
//{
// private Socket socket;
// Send(Socket socket)
// {
// this.socket = socket;
// }
// public void run()
// {
// try
// {
// BufferedReader bufr =
// new BufferedReader(new InputStreamReader(System.in));
//
// String line = null;
// while((line=bufr.readLine())!=null)
// {
// if("886".equals(line))
// {
// socket.close();
// break;
// }
// byte[] bufString = line.getBytes();
//
// //通过socket对象获取socket流中的输出流对象。
// OutputStream out = socket.getOutputStream();
// out.write(bufString);
//
// InputStream in = socket.getInputStream();
// byte[] buf = new byte[1024];
// int num = in.read(buf);
// String str = new String(buf,0,num);
//
// System.out.println("server:"+str);
// }
//
//
// }
// catch (Exception e)
// {
// System.out.println(e.toString());
// }
// }
//}
//
///*
// 建立服务器
//*/
//class Rece implements Runnable
//{
// //1，建立服务端的socket服务。并监听一个端口。以获取客户端发来的数据。
// private ServerSocket serverSocket;
// Rece(ServerSocket serverSocket)
// {
// this.serverSocket = serverSocket;
// }
// public void run()
// {
// try
// {
// while(true){
// System.out.println("============4");
// Socket socket = serverSocket.accept();
// System.out.println("============5");
// String ip = socket.getInetAddress().getHostAddress();
// System.out.println("============6");
// System.out.println(ip+"...connected");
// System.out.println("============7");
// BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// System.out.println("============8");
// String line ="";
// System.out.println("============9");
//
// OutputStream out = socket.getOutputStream();
// out.write("开始".getBytes());
//
// while((line= in.readLine())!=null){
// System.out.println(line);
// }
//
// }
// }
// catch (Exception e)
// {
// System.out.println(e.toString());
// }
// }
//}
//
//
//class ChatDemoServer
//{
// public static void main(String[] args) throws Exception
// {
// //1，建立服务端的socket服务。并监听一个端口。以获取客户端发来的数据。
// System.out.println("========1");
// ServerSocket rece = new ServerSocket(8082);
// rece.close();
// System.out.println("========2");
// new Thread(new Rece(rece)).start();
// System.out.println("========3");
// }
//}
//
//
//class ChatClient
//{
// public static void main(String[] args) throws Exception
// {
// //1，建立服务端的socket服务。并监听一个端口。以获取客户端发来的数据。
// //建立客户端socket服务。并去连接指定的服务端。
// Socket send = new Socket("169.254.1.60",10086);
// if(send == null){
// System.out.println("【创建Socket失败！】");
// return;
// }
// new Thread(new Send(send)).start();
// }
//}
import java.net.*;
import java.io.*;
import java.util.*;
//import java.awt.event.*;
import javax.swing.*;
import java.awt.*;
public class Server extends JFrame
{
/**
* 套接字接口可分为三类：公认端口 注册端口 动态和/或私有端口
套接字，简单的说就是通信的两方的一种约定，用套接字中的相关函数来完成通信过程
*/
private static final long serialVersionUID = 4130666237241201704L;
Container con = null; //容器
JTextArea jta = null; //文本区
ServerSocket ss = null; //初始化服务器套接字
ArrayList al = new ArrayList();//ArrayList容器
Server(int port)
{ //构造函数
try
{
ss=new ServerSocket(port); // 创建绑定到特定端口的服务器套接字。
}
catch(Exception e)
{
e.printStackTrace();
}
launchFrame();
}
public void severStart()
{ //线程开始
while(true)
{
try{
Socket s = ss.accept(); //侦听并接受到此套接字(port)的连接。
al.add(new ServerR(s));
jta.append("New Client:"+"\n Ip: "+s.getInetAddress()+":"+s.getPort()+"\n" //得到客户端本地地址，端口和客户端数量
+"Clients count:"+al.size()+"\n");
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
class ServerR implements Runnable
{
Socket s = null; //创建新服务线程
ServerR(Socket s)
{
this.s = s;
new Thread(this).start();//启动新线程
}
public void sent(String str)
{ //发送数据流方法
try
{
DataOutputStream dos = new DataOutputStream(s.getOutputStream()); //从s套接字中读出输出数据流
dos.writeUTF(str); //使用 UTF-8 修改版编码将一个字符串写入基础输出流。
}
catch(Exception e)
{
e.printStackTrace();
}
}
public void run()
{
try
{
DataInputStream dis = new DataInputStream(s.getInputStream());
String str = dis.readUTF(); //读出输入的数据流
while(true)
{
// System.out.println (str);
Iterator ite = al.iterator(); //生成list迭代器
while(ite.hasNext())
{ //如果仍有可迭代的元素，返回true
((ServerR)ite.next()).sent(str); //返回(ServerR)的下一个元素，并发送它
//先遍历ServerR中的所有线程
}
str=dis.readUTF();
}
}
catch(Exception e)
{
try{ //客户端关闭捕捉
s.close(); //关闭一个相关客户端线程
al.remove(this); //从迭代器指向的集合中移除迭代器返回的最后一个元素
jta.append("A client quit!\nClients count:"+al.size()+"\n"); //统计客户端现有的数量
}
catch(Exception e2)
{
e2.printStackTrace();
}
e.printStackTrace();
}
}
}
public void launchFrame()
{ //服务器端面板布局
con = this.getContentPane();
jta = new JTextArea();
jta.setEditable(false); //不可编辑文本域
JScrollPane jsp = new JScrollPane(jta,
JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
con.add(jsp,BorderLayout.CENTER);
this.setTitle("聊天服务端，袭风版");
this.setBounds(200,200,300,400);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main (String[] args)
{
Server s = new Server(3456); //创建服务器S 端口为3456
s.severStart();
}
}
