BlogJava-qileilove-随笔分类-jmeter and badboy

Jmeter在命令行运行技巧

顺其自然EVO — Fri, 26 Sep 2014 02:11:00 GMT

　　For non-interactive testing, you may choose to run JMeter without the GUI. To do so, use the following command options

　　-n This specifies JMeter is to run in non-gui mode

　　-t [name of JMX file that contains the Test Plan].

　　-l [name of JTL file to log sample results to].

　　-r Run all remote servers specified in JMeter.properties (or remote servers specified on command line by overriding properties)

　　The script also lets you specify the optional firewall/proxy server information:

　　-H [proxy server hostname or ip address]

　　-P [proxy server port]

　　Example : JMeter -n -t my_test.jmx -l log.jtl -H my.proxy.server -P 8000

　　-n 该参数表示Jmeter运行在非图形化模式下（即命令行模式）。

　　-t 保存有测试用例的JMX文件

　　-l 保存样本结果的JTL文件

　　-r 运行所有在JMeter.properties 中定义的远程服务（或者通过命令行覆盖配置文件中定义的远程服务）。脚本还允许您指定可选的防火墙/代理服务器信息：

　　-H 代理服务器主机名或者IP地址

　　-P 代理服务器的端口号

　　上面这段说明来自 JMeter 的官方用户手册。其中提到了使用命令行方式运行 JMeter 脚本的方法。只有几个简单的参数，很直观，用起来也很方便。好处是可以节省一些系统资源。

　　今天尝试 300 个虚拟用户连续运行 5 分钟时——使用 GUI 方式，发现开始运行后不久 UI 就失去了响应，并提示一个有关 AWT 的错误，最终只能把 Java 进程结束掉。但是使用命令行方式时却很稳定。

　　不过当在命令行方式下尝试 500 个虚拟用户连续运行 5 分钟时，JMeter 抛出了一个 Out of Memory 的异常并退出了进程。

　　Note：

　　1.执行命令前要检查当前目录是否是 %JMeter_Home%\bin 目录；

　　2.如果 JMeter 脚本不在当前目录，需要指定完整的路径；如果要把执行的结果保存在其他地方也要指定完整的路径。

顺其自然EVO 2014-09-26 10:11 发表评论

JMeter中使用Selenium进行测试

顺其自然EVO — Thu, 05 Jun 2014 05:49:00 GMT

JMeter是使用非常广泛的性能测试工具，而Selenium是ThroughtWorks 公司一个强大的开源Web 功能测试工具。Jmeter和Selenium结合使用，就可以实现对网站页面的自动化性能测试。
　　这里有两种方式在Jmeter中调用Selenium测试用例。可以使用 Jmeter JUnit sampler 或者 BeanShell sampler，后一种方式包含了Selenium client 和 server，因此不需要单独启动Server。
　　方法一
　　准备工作:
　　将文件selenium-server-standalone-2..jar拷贝到JMeter类库安装目录%JMETER_HOME%/lib/下，手动启动Selenium server。
　　Jmeter JUnit sampler
　　将Selenium测试用例打包成.jar文件，并拷贝到%JMETER_HOME%/lib/junit/目录下，注意：测试用例应该继承TestCase or SeleniumTestCase类，从而允许JMeter获取到该测试用例，且测试方法名称应该以test开头。
　　在Jmeter中创建test group和JUnit sampler测试计划，并在JUnit sampler中选择测试用例的名称，选择测试方法并运行。当然还可以根据需求设置其他参数。
　　一个测试用例例子:
package com.example.tests;
import com.thoughtworks.selenium.;
import org.junit.Before;
import org.junit.Test;
import org.junit.After;
public class selenium extends SeleneseTestCase {
@Before
public void setUp() throws Exception {
. . .
}
@Test
public void testSelenium_test() throws Exception {
. . .
}
@After
public void tearDown() throws Exception {
selenium.stop();
}
}
　　方法二
　　准备工作:
　　将文件selenium-server-standalone-2..jar拷贝到JMeter类库安装目录%JMETER_HOME%/lib/下，不需要启动Selenium server.
　　Jmeter JUnit sampler
　　将Selenium测试用例打包成.jar文件，并拷贝到%JMETER_HOME%/lib/junit/目录下，注意：测试用例应该继承TestCase or SeleniumTestCase类，从而允许JMeter获取到该测试用例，且测试方法名称应该以test开头。
　　在Jmeter中创建test group和JUnit sampler测试计划，并在JUnit sampler中选择测试用例的名称，选择测试方法并运行。当然还可以根据需求设置其他参数。
　　一个测试用例例子:
import junit.framework.TestCase;
import org.openqa.selenium.;
import org.junit.Before;
import org.junit.Test;
import org.junit.After;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.firefox.FirefoxProfile;
public class selenium extends TestCase {
WebDriver driver;
@Before
public void setUp() {
FirefoxProfile profile = new FirefoxProfile();
. . .
driver = new FirefoxDriver(profile);
}
@Test
public void testSelenium_test() throws Exception {
. . .
}
@After
public void tearDown() {
driver.quit();
}
}

顺其自然EVO 2014-06-05 13:49 发表评论

JMeter工作基本原理

顺其自然EVO — Wed, 04 Jun 2014 02:58:00 GMT

　　JMeter可以作为Web服务器与浏览器之间的代理网关，以便捕获浏览器的请求和Web服务器的响应，这样就很容易地生成性能测试脚本，

　　有了性能测试脚本，JMeter就可以通过线程组来模拟真实用户对Web服务器的访问压力，这与LoadRunner的

　　工作原理基本一致。

　　原理图如下：

顺其自然EVO 2014-06-04 10:58 发表评论

Jmeter分布式部署文档

顺其自然EVO — Thu, 29 May 2014 03:41:00 GMT

　　很多时候，我们测试时，如果进行大数据量的并发测试时，单个电脑的ＣＰＵ和内存可能无法承受，这个时候，我们需要进行一个分布式的测试，比如10000个并发，使用三台电脑来进行并发，Jmeter提供了这种功能，你可以很轻松的实现Jmeter的这种分布式测试

　　1 首先确何所有的电脑上都安装Jmeter

　　2 在所有电脑上开起Jmeter，开启命令是jmeter-server.bat，而不是以前的jmeter.bat

　　注意：你所要运行的不要开启，那些用来负载的，才开启服务器模式，这个模式没有界面，只有控制台的

　　3 在你所想要操作的电脑上，以jmeter.bat命令来启动图形化的jmeter界面

　　编辑jmeter.properties

　　remote_hosts=127.0.0.1,192.168.0.102 #remote_hosts=localhost:1099,localhost:2010

　　通过远程启动，便可驱动远程开启的jmeter同时进行并发测试，这样便同时有几个Jmeter进行并发测试了，这样可以实现了分布式的开发.

顺其自然EVO 2014-05-29 11:41 发表评论

聚合报告显示测试结果

顺其自然EVO — Mon, 26 May 2014 02:30:00 GMT

　聚合报告显示测试结果

　　1.Label：每个 JMeter 的 element (例如 HTTP Request )都有一个 Name 属性，这里显示的就是 Name 属性的值

　　2.#Samples：表示你这次测试中一共发出了多少个请求，如果测试计划模拟10个用户，每个用户迭代10次，这里就会显示100

　　3.Average：平均响应时间 — 默认情况下是单个 Request 的平均响应时间，当使用了事务控制器时，也可以以事务为单位显示平均响应时间

　　4.Median：中位数，也就是 50 %用户的响应时间

　　5.90% Line： 90 %用户的响应时间

　　6.Min：最小响应时间

　　7.Max：最大响应时间

　　8.Error%：错误率，本次测试中出现错误的请求的数量 / 请求的总数

　　9.Throughput：吞吐量 —— 默认情况下表示每秒完成的请求数( Request per Second )

　　10.KB/Sec：每秒从服务器端接收到的数据量

顺其自然EVO 2014-05-26 10:30 发表评论

使用Jmeter录制web脚本

顺其自然EVO — Thu, 22 May 2014 02:12:00 GMT

　　1。web性能测试以及web http请求基本原理。
　　再介绍录制jmeter脚本之前，我们先谈一下web性能测试。web就是调用http/https接口, 其实没有是什么复杂度可言。只是我们必须清楚，对于一个网站说，一个页面并通常不是只有一个http请求。如果需要测试一个rich web page，必须了解到这一点（测试http接口不在此类，虽然也是http协议，但是以http接口对外服务）。
　　例如这样一个页面(下面是html代码）
　　如果向服务器请求上面的一个页面，则除了本身页面的请求本身，还有一个css和img的资源。这样打开这样一个页面，本需要有三个http请求。
　　1. http1 -> get the web page
　　2. the web page contain two resources
　　3. then request http2 and http3 to get the css file and image respecitively.
　　所以这样就是发起了3个http请求，才完整的打开了一个页面。浏览器实际是这么做的，但浏览器作了很多优化。（比如多线程下载资源，缓存图片，css等资源）。说道这里，不得不佩服loadrunner的强大。他可以尽量模拟浏览器的这些行为，来保证测试的结果准确性。但这些参数都可以动态调整的。
　　2。实际录制脚本
　　好，那么我们现在就来实际录制脚本吧，并且体验一下真正一个页面的实际http请求过程。这里我们只谈http，https不在本文所讲范围内。
　　录制脚本目前有2种方法，我们先介绍jmeter proxy方法。另一个是badboy录制的脚本转化为jmeter脚本，直接想了解badboy，请直接访问
　　http://www.badboysoftware.biz/docs/jmeter.htm
　　jmeterproxy 来了。
　　1）启动jmeter，这个不多说了。
　　2）选择测试计划，右键添加线程组（thread group)
　　3）选择这个线程组，右键添加config element -〉 http默认请求
　　4）在http默认请求单元，填入server name 为jakarta.apache.org. 这个是我们要录制的页面。其他地方不填
　　5）然后选择刚才那个县城组，右键加入一个录制控制器。位于Add>Logic Controllers -> Recording Controller
　　6）选择WorkBench，右键加入 Non-Test Elements -> Http proxy server
　　7）在http proxy server里，的patterns to include 里，写入.\.html 这个是正则表达式，意思是录制所有的html为后缀名的页面。那么如果你要录制后缀名为jsp或者do的，则写入.\.jsp 和 .*\.do 分别。
　　8）对于url怕tterns to exclude的地方，是写入不想被录制的一些资源文件url。比如图片等。　这些配置，视测试的具体场景而定。比如是否要测试静态图片等。
　　9）为了调试录制的情况，我们选择http proxy server ，添加一个察看结果树监听器。这个以前我们曾经用过。
10）回到http proxy server然后，选择开始启动。这样proxy server 就启动了。
　　11）这样我们打开一个浏览器，将浏览器的代理设置为jmeter proxy server 的ip和端口号。　因为proxy server 就在本地，所以就写localhost 和端口即可。
　　12）设置好代理后，用浏览器访问http://jakarta.apache.org/jmeter/index.html
　　13）随便点击一些连接，然后回到jmeter 的窗口，你查看结果树就看到了录制的http请求了。
　　14）这样的脚本，我们就可以直接用来运行了。

顺其自然EVO 2014-05-22 10:12 发表评论

Jmeter参数化

顺其自然EVO — Mon, 19 May 2014 02:15:00 GMT

参数化：简单的来理解一下，我们录制了一个脚本，这个脚本中有登录操作，需要输入用户名和密码，假如系统不允许相同的用户名和密码同时登录，或者想更好的模拟多个用户来登录系统。

　　这个时候就需要对用户名和密码进行参数化，使每个虚拟用户都使用不同的用户名和密码进行访问。

　　前提：

　　假如，我们录制好了一个脚本（可以用badboy工具录制），在jmeter中打开，找到有用户名和密码的页面。如下：

　　1.我们需要“参数化”的数据，这里我用记事本写了五个用户名和密码，保存为.dat格式的文件。

　　我将这个文件放在了我的（ D:\test.dat ）路径下。关于如何得到成百上千的用户名和密码，首先要在数据库中创建这些数据，将数据导出，整理保存，这里就不深究。

　　2.好，我们要编写函数来调用这个test.dat文件，怎么弄，

　　点击菜单栏“选项”---->函数助手对话框，看下图。

　3.把我们写好的函数复制到“登录”页面用户名和密码胡位置。

　　好了，现在我们的参数化设置完成，在脚本的时候，会调用我们D盘下面的test.dat文件，第一列是用户，第二列是密码。

　　注意用户名和密码是一一对应的，中间用户逗号（，）隔开。　3.把我们写好的函数复制到“登录”页面用户名和密码胡位置。

　　好了，现在我们的参数化设置完成，在脚本的时候，会调用我们D盘下面的test.dat文件，第一列是用户，第二列是密码。

　　注意用户名和密码是一一对应的，中间用户逗号（，）隔开。

顺其自然EVO 2014-05-19 10:15 发表评论

Jmeter安装 for windows

顺其自然EVO — Thu, 15 May 2014 03:52:00 GMT

总结：

　　一、Jmeter安装总结

　　1、配置Java环境变量时需要注意设置的路径需要和JDK安装的路径一样

　　2、配置Java环境变量时需要注意JDK的版本号

　　3、配置环境变量时多个变量以分号隔开，但是确保是英文输入法的分号

　　二、搭建测试环境总结

　　1、检测负载机是否可以被调用，检测负载机的ip是否能被ping通

　　2、当负载机的ip不能ping通时，有可能是防火墙拦截了，可以检测防火墙是否是启用状态，如果是暂时设置禁用防火墙

　　3、测试的数据调用文件应该放在负载机上，并且在控制中心设置正确的数据访问路径

　　Jmeter测试工具安装步骤：

　　1、安装Jmeter

　　下载Jmeter工具包并把工具包放到C盘下

　　http://jmeter.apache.org/download_jmeter.cgi

　　2、安装JDK

　　下载Java的JDK并安装，一般会安装在C:\Program Files\Java目录下

　　http://java.sun.com/javase/downloads/index.jsp

　　3、Java环境变量配置

　　桌面上右键选中计算机--->属性--->高级系统设置--->环境变量设置

　　在“系统变量”--->“新建”, 在变量名中输入：CLASSPATH，变量值中输入：C:\Program Files\Java\jdk1.6.0_10\lib\dt.JAR; C:\Program Files\Java\jdk1.6.0_10\lib\TOOLS.JAR; C:\Program Files\Java\jdk1.6.0_10\BIN;再按“新建”，在变量名中输入：JAVA_HOME，变量中输入：C:\Program Files\Java\jdk1.6.0_10；修改PATH变量，添加%JAVA_HOME%/bin；然后确定即可

　　4、Jmeter环境变量配置

　　桌面上右键选中计算机--->属性--->高级系统设置--->环境变量设置

　　在“系统变量”--->“新建”, 在变量名中输入：JMETER_HOME，变量值中输入：C:\jakarta-jmeter-2.3.4 ，再修改CLASSPATH变量，变量值中添加%JMETER_HOME%\lib\ext\ApacheJMeter_core.jar;% JMETER_HOME%\lib\jorphan.jar;%JMETER_HOME%\lib\logkit-1.2.jar; 然后确定即可

顺其自然EVO 2014-05-15 11:52 发表评论

Jmeter做web压力测试时设置持续时间注意点

顺其自然EVO — Tue, 13 May 2014 08:23:00 GMT

　　头一回使用jmeter做web的压力测试，遇到个很莫名其妙的问题，不管我的线程组怎么设置，它就是执行一次就结束了。

　　设置循环次数为300，不使用调度器－－〉执行一次就结束了，循环次数未生效

　　设置循环次数永远，设置高度器的开始和结束时间，不使用延迟和持续－－〉开始时间有效，执行一次就结束了，结束时间未生效

　　设置循环次数永远，设置延迟1秒，持续1200秒－－〉延迟1秒执行，执行一次就结束了，持续时间未生效

　　不管我怎么设置，都是执行一次就结束了，也没有错误发生，就是正常的结束

　　jmeter版本2.9和2.11都一个德行的

　　脚本是压测web脚本，利用badboy录制的，应该不会有问题，然后我就跟以前的脚本一个个比对，终于被我发现了！

　　在step里还有个设置，需要勾选上永远才行

顺其自然EVO 2014-05-13 16:23 发表评论

如何用Jmeter做压力测试

顺其自然EVO — Fri, 25 Apr 2014 02:06:00 GMT

Jmeter是一个性能测试工具，同loadrunner类似，他功能较多，我们常用的功能是用jmeter模拟多浏览器对网站做压力测试。

　　下载jmeter地址：http://jakarta.apache.org/site/downloads/downloads_jmeter.cgi

　　我们一般的网站，在进入业务功能前先需登录，然后才能访问业务功能。下面介绍如何用jmeter登录系统再对主业务做压力测试。

　　1. 运行jmeter

　　2. 左边树将出现测试计划、工作台两根节点。

　　3. 选择测试计划，按右键－》添加－》threads（users）线程组

　　线程组能设置以多少个线程并发做压力测试。

　　在”循环次数”设置不选择永远，循环次数设置1。

　　4. 现在先介绍如何设置登录http请求，选择线程组，右键――添加――》sampler－―》http 请求。

　　http请求即模仿浏览器的访问。

　　在“服务器名称或ip”设置127.0.0.1，端口号设置:8080，“方法”设置post，路径设置网站登录的地址，如“/exam/operatorAction”。

　　登录需传入用户、密码。在“同请求一起发送参数”列表中添加参数。参数值根据web应用设置。如login_user=0001;login_password=1;actFlag=login

　　5. 登录成功后，网站一般将跳入主页面。在jmap中可做判断，判断是否登录后按预想进入主页面（此步骤也可不设）。选择4中的“http请求“，右键――》添加――》断言――》响应断言。“Apply to”设置Main smaple only；“要测试的响应字段”设置“url样本”；“模式匹配规则”设置“包括”，“要测试的模式”增加页面跳转到的主页面，如：“studentMain.jsp”

　　6. 一般网站登录后，在tomcat中生成了session，之后访问其他页面将无需再次登录，前提是浏览器需支持cookie。在jmap中也同样，如要继续访问其他页面，还需做下面关键的设置。

　　选择“线程组”――》右键――》添加――》配置元件――》Http cookie管理器。加了此步骤后，http请求将具备cookie功能，即登录成功后访问其他页面将不会跳转到登录页面重新登录。

　　7. 对目标页面反复压力测试。

　　7.1 如何使被测页面反复访问达到测压效果。选“线程组”―》右键――》逻辑控制器――》循环控制器。循环次数中选择“永远”。

　　7.2 选择刚加的“循环控制器”，右键――》添加――》sampler－―》http 请求，按4步骤设置ip、端口，http请求方法为“get”，路径为被压力测试的url，如：“exam/business/studentExam.action.StudentExamAction?action=goIntoMockExam”。

　　按上面的设置后，已完成配置，可做压力测试。只需点菜单“运行”――》启动，即运行压力测试。

　　8. jmeter提供了许多压力结果查看工具。是压力测试时非常好的分析工具。下面几种查看工具可有选择的添加。

　　8.1 察看结果树。他记录每次请求发送数据、响应返回数据。选择“线程组”――》右键――》添加――》察看结果树。

　　8.2 用表格查看结果。可查看每次请求的响应时间等。选择“线程组”――》右键――》添加――》用表格查看结果。

　　8.3 Summary Report。可查看平均响应时间、最长响应时间等。

顺其自然EVO 2014-04-25 10:06 发表评论

Jmeter和LR上传文件和下载

顺其自然EVO — Fri, 11 Apr 2014 02:41:00 GMT

　背景：

　　在某个申请业务中，需要上传附件文件，然后才能提交该申请

　　遇到的问题：

　　1，在使用Jmeter或者LR进行录制时，无法录制到上传文件的请求，只能通过Fiddler能查看到该请求

　　2，因为录制不下来，只能手工构造，但网上相关的材料太少。

　　所以在这里整理备忘

　　Fiddler录制得到的请求的Header和Body如下面的两个截屏

　　body

　　截图如上，注意Header截图【Content-Type:multipart/form-data;boundary=----------cH2GI3Ef1gL6Ij5cH2gL6Ij5ei4gL6】和Body截图

　　每一个“-----------------------------”为分隔符，代表一个表单域；

　　最后一个“----------cH2GI3Ef1gL6Ij5cH2gL6Ij5ei4gL6--”（以“--”结尾）分隔符为表单域结束边界。

　　由此可以看到我得到的这个请求，POST data中共有四个表单域，最后一个即包含了name=”Filedate”（这个name的值可以自己定），filename=”ff.txt”，下图中红框为ff.txt实际上传的文件内容

　Server端的代码如下

　　一，Jmeter

　　需要注意

　　1，请求类型为Post

　　2，要勾选 Use multipart/form-data for POST，否则request中将不包含上传的文件

　　3， MIME类型为application/octet-stream

二，LoadRunner

lr_start_transaction("upload");

web_reg_save_param("attachmentId1",

"LB/IC=attachmentId\":\"",

web_submit_data("upload.text",

"Action=http://192.168.0.1:8000/fileUpload/upload.text",

"Method=POST",

"EncType=multipart/form-data",

"RecContentType=text/plain",

"Name=Filename","Value=Attachment.doc", ENDITEM,

"Name=attachmentType","Value=合同正本", ENDITEM,

"Name=Filedata","Value=Attachment.doc", "File=Yes", ENDITEM,

"Name=Upload","Value=Submit Query", ENDITEM,

LAST);

lr_end_transaction("upload",LR_AUTO);

　　LoadRunner的下载

lr_start_transaction("downloadApproval");

web_reg_save_param("FileName",

web_url("generateApproval.html",

"URL=http:// 192.168.0.1:8000/xx/generateApproval.html?id={PersionId}",

"Resource=1",

"RecContentType=application/x-msdownload",

"Referer=http:// 192.168.0.1:8000/xx/viewWorkflow.html?id={PersionId}",

"Snapshot=t60.inf",

LAST);

lr_message("!!filename is%s.xml",lr_eval_string("{FileName}"));

//获取二进制文件类型的文件大小

flen =web_get_int_property(HTTP_INFO_DOWNLOAD_SIZE);

lr_message("Size:%d",flen);

lr_end_transaction("downloadApproval",LR_AUTO);

顺其自然EVO 2014-04-11 10:41 发表评论

JMeter远程测试，每个实际测试人员都要学习的(3)

顺其自然EVO — Tue, 18 Mar 2014 02:32:00 GMT

同时创建一个规则（Qolicy）文件，添加[computer_name][computer_domain]行到/etc/hosts。

　　3．如何使用不同端口号

　　默认情况下，JMeter使用标准RMI端口号1099（这是可以改变的）。要想成功改变使用的端口号，需满足如下条件：

　　在远程服务器，启动Rmiregistry使用新端口号。

　　在远程服务器，启动JMeter并预先定义server_port属性。

　　在客户端，更新remote_hosts属性，在其中包含remote host:port设置。

　　从JMeter 2.1.1版本开始，jmeter-server脚本支持改变端口号。例如，假设测试人员希望使用端口号1664（可能因为1099端口已经被其他应用程序占用了）。

　　Windows系统（DOS窗口中）：

　　C:\JMETER> SET SERVER_PORT=1664

　　C:\JMETER> JMETER-SERVER [other options]

　　UNIX系统：

　　$ SERVER_PORT=1664 jmeter-server [other options]

　　[N.B. use upper case for the environment variable]

　　在这两种情况下，脚本都会在指定端口上启动Rmiregistry，接着以远程服务器模式启动JMeter，并已经定义了"server_port"属性。

　　选定的端口号将会被记录到远程服务器的jmeter.log文件中（Rmiregistry不会创建一个日志文件）。

　　4．使用采样批次

　　测试计划中的监听器会把它们的结果返回到JMeter客户端，而JMeter客户端默认情况下会将这些结果写入到指定文件中，采样结果会在产生后立即发回JMeter客户端。这样就会对网络和JMeter客户端产生很大的压力。用户可以通过设置一些属性，来改变默认操作。

　　模式（Mode）（采样结果发送模式）默认是Standard。

　　Standard：在采样结果产生后立即发送。

　　Hold：将采样结果保存在一个数组中，直到测试结束。这可能会占用远程服务器的大量内存。

　　Batch：当计数器或者时间超过阈值之后，发送保存的采样结果。

　　Statistical：当计数器或者时间超过阈值之后，以概要的形式发送采样结果；采样结果以线程组（Thread Group）名称和采样标签（Sample Label）进行概要统计。积累的数据域包括：elapsed time、latency、bytes、sample count、error count，其他数据域将会被丢弃。

　　Stripped：将成功采样的响应数据移除。

　　StrippedBatch：将成功采样的响应数据移除，并批次发送。

　　Custom implementation：将模式参数设置为测试人员的客户化采样发送器的类名。该类必须实现接口SampleSender，并且类的构造函数只有一个RemoteSampleListener型的参数。

　　如下属性会影响Batch和Statistical模式。

　　num_sample_threshold：一个批次中的采样数目（默认为100）。

　　time_threshold：等待的毫秒数（默认为60秒）。

顺其自然EVO 2014-03-18 10:32 发表评论

JMeter远程测试，每个实际测试人员都要学习的

顺其自然EVO — Fri, 14 Mar 2014 03:04:00 GMT

详解JMeter远程测试（1）

　　如果运行JMeter客户端的机器性能不能满足测试需要，那么测试人员可以通过单个JMeter GUI客户端来控制多个远程JMeter服务器，以便对服务器进行压力测试，模拟足够多的并发用户。通过远程运行JMeter，测试人员可以跨越多台低端计算机复制测试，这样就可以模拟一个比较大的服务器压力。一个JMeter GUI客户端实例，理论上可以控制任意多的远程JMeter实例，并通过它们收集测试数据，如图11-3所示。这样一来，就有了如下特性：

　　保存测试采样数据到本地机器。

　　通过单台机器管理多个JMeter执行引擎。

　　没有必要将测试计划复制到每一台机器，JMeter GUI客户端会将它发往每一台JMeter服务器。

　　每一台JMeter远程服务器都执行相同的测试计划。JMeter不会在执行机间做负载均衡，每一台服务器都会完整地运行测试计划。

　　在1.4GHz～3GHz的CPU、1GB内存的JMeter客户端上，可以处理线程100～300。但是Web Service例外。XML处理是CPU运算密集的，会迅速消耗掉所有的CPU。一般来说，以XML技术为核心的应用系统，其性能将是普通Web应用的10%～25%。另外，如果所有负载由一台机器产生，网卡和交换机端口都可能产生瓶颈，所以一个JMeter客户端线程数不应超过100。

　　采用JMeter远程模式并不会比独立运行相同数目的非GUI测试更耗费资源。但是，如果使用大量的JMeter远程服务器，可能会导致客户端过载，或者网络连接发生拥塞。

　　请注意，假如测试人员将JMeter执行引擎安装在应用服务器（测试目标）上，那么这显然会加重应用服务器的负担，测试结果也将变得不可信。作者推荐的方式是将JMeter远程服务器放在应用服务器（测试目标）所在的同一个网段内。这样做既可以减少JMeter收集测试结果对网络产生的冲击，又可以避免对应用服务器（测试目标）性能产生影响。

图11-3 JMeter远程测试原理图

　下面是启动JMeter远程测试的基本步骤：

　　步骤1：配置节点

　　确保所有节点（JMeter客户端和JMeter远程服务器）运行相同版本的JMeter。尽可能在所有操作系统上使用相同的Java版本。

　　如果测试用到了外部数据文件，那么请注意这些文件不会被JMeter客户端分发，因此测试人员需要确保每台执行机上都保存了这些数据文件（其所在目录也必须正确）。如果有必要，用户可以为每台执行机设置不同的属性变量，即在JMeter远程服务器上编辑user.properties或者system.properties文件。这些属性将会在JMeter远程服务器启动时被识别，并有可能被应用到测试计划之中，从而影响测试执行（例如，与其他远程服务器发生交互）。另外，不同的JMeter远程服务器可能会使用不同内容的数据文件（例如，每台服务器必须使用不同的ID，就以此来划分数据文件）。

　　步骤2：启动远程服务器

　　要启动JMeter远程节点，请在执行机上运行JMETER_HOME/bin/jmeter-server （UNIX）或者JMETER_HOME/bin/jmeter-server.bat（Windows）脚本。

　　请注意，每个远程节点上只能运行一个JMeter远程服务器脚本，除非采用不同的RMI端口。从JMeter 2.3.1开始，JMeter远程服务器会自己启动RMI注册；用户没有必要单独启动RMI注册。假设测试人员一定要单独启动RMI注册，可以在远程节点上定义JMeter属性server.rmi.create=false。

　　默认情况下，JMeter远程服务器的RMI使用动态端口号。这样就会为防火墙配置带来麻烦，因此JMeter 2.3.2及其以后的版本，会检查JMeter属性server.rmi.localport。如果该值非零，JMeter远程服务器就会用它来作为本地端口号。

　　步骤3：将JMeter远程服务器的IP地址添加到客户端属性文件中

　　编辑JMeter控制机的属性文件。在/bin/jmeter.properties文件中找到属性"remote_hosts"，使用JMeter远程服务器的IP地址作为其属性值。可以添加多个服务器的IP地址，以逗号作为分隔。

　　请注意测试人员还可以使用-R命令行选项来指明将会使用的远程服务器。这与使用-r 和-Jremote_hosts={服务器列表}的效果相同。例如jmeter -Rhost1,127.0.0.1,host2。

　　如果测试人员定义JMeter属性server.exitaftertest=true，那么远程服务器在运行完单个测试后就会退出。-Z标志也有同样的效果，参见后面的内容。

顺其自然EVO 2014-03-14 11:04 发表评论

jmeter之配置元件

顺其自然EVO — Fri, 28 Feb 2014 05:49:00 GMT

摘要: 利用Jmeter的http请求的时候，例如登陆操作，我们做普通用户名和密码作参数化，循环读取文本里的用户名和密码，可以添加CSV Data Set Config这个原件来控制。利用Jmeter的CSV Data Set Config，可以实现这个功能，具体如下：1.新建一个文本文件，里面保存要登录的用户名，密码，文件内容如下：baidu,... 阅读全文

顺其自然EVO 2014-02-28 13:49 发表评论

jmeter 目录介绍

顺其自然EVO — Mon, 24 Feb 2014 03:01:00 GMT

顺其自然EVO 2014-02-24 11:01 发表评论

jMeter 测试结果字段意义

顺其自然EVO — Thu, 13 Feb 2014 08:06:00 GMT

　JMeter 测试结果字段意义

　　Lable :定义 HTTP 请求名称

　　Samples :表示这次测试中一共发出了多少个请求

　　Average :平均响应时长---默认情况下是单个Request的平均响应时长，当使用Transcation Controller时，也可以以Transcation为单位显示平均响应时长

　　Median :中位数，也就是50%用户的响应时长

　　90%Line ：90%用户的响应时长

　　Min:访问页面的最小响应时长

　　Max:访问页面的最大响应时长

　　Error% :错误请求的数量/请求的总数

　　Throughput :默认情况下表示每秒完成的请求数（Request per Second）,当使用了Transaction Controller时，也可以表示类似LoadRunner的Transaction per Second 数

　　KB/Sec :每秒从服务器端接收到的数据量

顺其自然EVO 2014-02-13 16:06 发表评论

性能测试分享—JMeter篇

顺其自然EVO — Thu, 02 Jan 2014 01:24:00 GMT

　这周尝试了一把性能测试，之前都是测试网站的性能测试，java接口的性能测试还是头一次，学到了很多，特此分享一下。

　　主要用到了两个性能测试工具，一个是jmeter，一个是LoadRunner。

　　使用jmeter的测试方法：

　　1、下载jemeter的linux版本的，下载的文件里包含了两个jar包，一个是ApacheJMeter_core.jar,ApacheJMter_java.jar。分别把这两个jar放到eclipse的Java Build Path的libraries下面。

　　2、创建编写脚本的类，使他继承AbstractJavaSamplerClient。初步结构是

private SampleResult results;

public void setupTest(JavaSamplerContext arg0) {

results = new SampleResult();

}

public Arguments getDefaultParameters() {

Arguments params = new Arguments();

return params;

}

//测试执行的循环体，根据线程数和循环次数的不同可执行多次，类似于LoadRunner中的Action方法

public SampleResult runTest(JavaSamplerContext arg0) {

results.sampleStart();

results.sampleEnd();

results.setSuccessful(true);

return results;

}

//结束方法，实际运行时每个线程仅执行一次，在测试方法运行结束后执行，类似于LoadRunner中的end方法

public void teardownTest(JavaSamplerContext arg0) {

}

　将需要循环的业务流程放到runTest方法里。编写好的代码如下：

package app;

import http.HttpClient4;

import http.HttpParameter;

import http.HttpResp;

import http.JsonUtil;

import java.io.IOException;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Calendar;

import java.util.Date;

import java.util.Map;

import java.util.Random;

import org.apache.commons.httpclient.HttpClient;

import org.apache.commons.httpclient.HttpException;

import org.apache.commons.httpclient.methods.PostMethod;

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.yeepay.g3.utils.common.encrypt.AES;

import com.yibao.utils.des3.RSA_Encrypt;

public class TheardTest extends AbstractJavaSamplerClient{

private SampleResult results;

public void setupTest(JavaSamplerContext arg0) {

results = new SampleResult();

}

public Arguments getDefaultParameters() {

Arguments params = new Arguments();

return params;

}

public static String ramdonNum(int num){

Random rd = new Random();

StringBuilder sb = new StringBuilder("");

if (num <1){

return null;

}

else{

for(int i=1;i<=num;i++){

int sr=rd.nextInt(9);

sb.append(String.valueOf(sr));

}

return sb.toString();

}}

public static void testCreditPay() throws ParseException{

String PUBLIC_KEY=TheardTest.testConsult();

HttpClient client = new HttpClient();

PostMethod method = new PostMethod("http://xxxxxxxx/xxxxxx/api/bankcard/credit/pay");

String key=TheardTest.ramdonNum(6);

String encryptkey = "0123456789"+key;

String merchantAccount = "YB01000000078";

//民生

String cardNo ="XXXXXXXXX";

String validthru="xxx7";

String cvv2 = "6xx";

String phone = "13xxxxxx5431";

String orderId = "33hhkssseef3utyt2"+key;

System.out.println(orderId);

Integer transtime = (int)(System.currentTimeMillis()/1000);

Integer currency = 156;

String amount = "50";

String productcatalog = "1";

String productName = "123";

String productDesc = "小丸子";

String userIp = "123.45.45.45";

String identityId = "a";

Integer identityType = 6;

String other = "eeee";

String data = "{\"merchantaccount\":\"" + merchantAccount

+"\",\"cardno\":\"" + cardNo

+ "\",\"validthru\":\"" + validthru

+ "\",\"cvv2\":\"" + cvv2

+ "\",\"phone\":\"" + phone

+ "\",\"orderid\":\"" + orderId

+ "\",\"transtime\":" + transtime

+ ",\"currency\":" + currency

+ ",\"amount\":" + amount

+ ",\"productcatalog\":\"" + productcatalog

+ "\",\"productname\":\"" + productName

+ "\",\"productdesc\":\"" + productDesc

+ "\",\"userip\":\"" + userIp

+ "\",\"identityid\":\"" + identityId

+ "\",\"identitytype\":" + identityType

+ ",\"other\":\"" + other + "\"}";

data = AES.encryptToBase64(data, encryptkey);

try {

method.setParameter("merchantaccount", merchantAccount);

method.setParameter("data", data);

method.setParameter("encryptkey", RSA_Encrypt.encrypt(encryptkey, PUBLIC_KEY));

client.executeMethod(method);

System.out.println(method.getStatusLine());

String respStr = method.getResponseBodyAsString();

System.out.println(respStr);

String result = AES.decryptFromBase64(respStr, encryptkey);

System.out.println(result);

// 自动退款

Map mapjson=JsonUtil.parse(result);

Object obj = mapjson.get("yborderid");

String yborderid=obj.toString();

System.out.println("流水号："+yborderid);

TheardTest.refundTeseCase(yborderid,merchantAccount,amount);

method.releaseConnection();

} catch (HttpException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

/**

* 测试协商接口

* @author shangwei

* @return

* @throws ParseException

public static String testConsult() throws ParseException{

String url = "http://xxxxxxx/xxxxxx/consult";

HttpClient4 client =HttpClient4.createDefault();

String data = "";

Date d = new Date();

Calendar now = Calendar.getInstance();

now.setTime(d);

SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

String dateline=format.format(now.getTime());

System.out.println(dateline);

Date date = format.parse(dateline);

String dates=date.getTime()/1000+"";

System.out.println(dates);

try {

data = AES.encryptToBase64(dates, "12345678901234HH");

} catch (Exception e) {

e.printStackTrace();

}

HttpParameter parameter = new HttpParameter();

parameter.add("data", data);

parameter.add("merchantaccount", "YB01000000078");

HttpResp resp = new HttpResp();

try{

resp=client.doPost(url, parameter, "utf-8");

String respStr= resp.getText("utf-8");

System.out.println(respStr);

String aes=AES.decryptFromBase64(respStr, "12345678901234HH");

System.out.println(aes);

return aes;

}catch (HttpException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

client.shutdown();

return "出错啦";

}

public static void refundTeseCase(String yborderid,String merchantAccount,String amount) throws IOException{

String url ="http://xxxxxxxx/xxxxxxx/api/refund/direct";

HttpClient4 client =HttpClient4.createDefault();

HttpParameter parameter = new HttpParameter();

parameter.add("merchantaccount", merchantAccount);

parameter.add("merchantrefundid", "093032323");

parameter.add("transorderid", yborderid);

parameter.add("amount", amount);

HttpResp rep;

try {

rep = client.doPost(url, parameter,"utf-8");

System.out.println(rep.getStatusCode());

System.out.println(rep.getText("utf-8"));

}catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

//测试执行的循环体，根据线程数和循环次数的不同可执行多次，类似于LoadRunner中的Action方法

public SampleResult runTest(JavaSamplerContext arg0) {

results.sampleStart();

try {

testCreditPay();

} catch (ParseException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

results.sampleEnd();

results.setSuccessful(true);

return results;

}

//结束方法，实际运行时每个线程仅执行一次，在测试方法运行结束后执行，类似于LoadRunner中的end方法

public void teardownTest(JavaSamplerContext arg0) {

}

　　3、将写好的class类和该类引入到的类都打成jar包，放到jemter文件的lib/ext文件下。将用到的其他的jar包放到lib文件夹下面。

　　4、启动jemter后，创建先添加线程组，在添加sampler的java请求，如果之前步骤成功，在类名称下拉列表里会出现测试代码打好jar包的类。之后操作jemter进行测试就OK啦。

　　下面在分享LoadRunner进行性能测试及环境优化。

顺其自然EVO 2014-01-02 09:24 发表评论

JMeter代理录制脚本（3）

顺其自然EVO — Fri, 29 Nov 2013 02:58:00 GMT

使用JMeter代理录制脚本的过程如下：

　　1.启动JMeter，在测试计划中添加“线程组”。

　　2.在“线程组”中添加“HTTP请求默认值”，参数设定如下：

　　3.在“”中添加“HTTP代理服务器”，参数设定如下：

　　4.在IE浏览器中“工具”—“Internet选项”---“连接”---“局域网设置”中设定参数如下：

　5.点击两次“确定”后，在浏览器中输入http://jakarta.apache.org/ ，然后随便点击几个网页，再查看JMeter窗口，就会有录制好的网页，如图：

　　6.录制好了以后，就可以重新播放脚本了.

　　附注：在启动代理服务器的时候出现一个问题：

　　could not create proxy - see log fordetails

　　解决方法：设定JRE的path路径，关闭JMeter在重新启动就可以了。

JMeter主要组件介绍（2）

顺其自然EVO 2013-11-29 10:58 发表评论

JMeter的基本介绍和入门（1）

顺其自然EVO — Thu, 28 Nov 2013 03:30:00 GMT

1. 介绍

　　JMeter是Apache组织的开放源代码项目，能做功能测试和性能测试。它能够对HTTP和FTP服务器进行压力和性能测试，也可以对任何数据库进行同样的测试（通过JDBC），还能以多种形式展现测试结果。我们初学者往往一看到很多的理论都很不耐烦，一般都喜欢通过举例子才会激起兴趣，有想往下学习的欲望。

　　2. 测试环境搭建

　　在官网 http://jmeter.apache.org/ 下载JMeter，解压到本地，在里面的bin目录下，找到jmeter.bat批处理文件，然后双击就出现了JMeter的工作环境：

　　3. 测试实例

　　JMeter里面的元件很多，逻辑控制器，配置元件，定时器，Sampler，监听器等等，先给出一个实例，慢慢了解元件的使用方法。测试一个网站，我们至少需要：用户，发送请求，查看结果这三个过程。

　　3.1 添加线程组（用户）

　　在“测试计划”上右键，选择“添加”---“Thread Users”---“线程组”，如下图所示：

　　其中，对我们有影响的参数是线程数（设置发送请求的用户数目），Ramp-up period：每个请求发生的总时间间隔，单位是秒，循环次数（请求发生的重复次数）。如果我们需要JMeter模拟五个请求者（也就是五个线程），每个请求者连续请求两次，则如下图设置：

　　3.2 添加请求

　　我们要访问一个网页，比如是百度首页，则是http请求，则添加http请求，在线程组上右键---“添加”---“Sampler”---“HTTP请求”

　　http请求的属性值中“Web服务器名称或IP”填写www.baidu.com就可以了：如下图所示：

　3.3 添加监视器（查看结果）

　　监视器的种类很多，根据自己的需要添加，我们选择“查看结果树”。在线程组上右键---“添加”---“监视器”---“查看结果树”，如下图所示：

　　4. 运行

　　可以查看结果：

　　JMeter入门结束。

顺其自然EVO 2013-11-28 11:30 发表评论

使用JMeter的Java请求功能测试Hetty性能

顺其自然EVO — Mon, 25 Nov 2013 02:38:00 GMT

　1.JMeter介绍

　　JMeter是Apache组织的开放源代码项目，它是功能和性能测试的工具，100%的用java实现。JMeter可以用于测试静态或者动态资源的性能（文件、Servlets、Perl脚本、java对象、数据库和查询、ftp服务器或者其他的资源）。JMeter用于模拟在服务器、网络或者其他对象上附加高负载以测试他们提供服务的受压能力，或者分析他们提供的服务在不同负载条件下的总性能情况。

　　2.启动JMeter

　　进入JMeter的bin目录，然后执行：

　　sudo ./jmeter.sh

　　3.原始的测试方法

　　在没有使用JMeter前，我对hetty的性能测试，都是通过自己写多线程代码去完成的，相当苦逼，相当麻烦，不过也能锻炼自己的编码能力，我先贴出比较原始的测试方法，如下：

public class RpcHessianClient {

public static void main(String[] args) {

String url = "http://localhost:8081/apis/hello";

HessianProxyFactory factory = new HessianProxyFactory();

ExecutorService es = Executors.newFixedThreadPool(10);

int size = 1000000;

final CountDownLatch cdl = new CountDownLatch(size);

try {

long start = System.currentTimeMillis();

factory.setUser("client1");

factory.setPassword("client1");

factory.setOverloadEnabled(true);

final Hello basic = (Hello) factory.create(Hello.class,

url);

for (int i = 0; i < size; i++) {

es.submit(new Runnable() {

@Override

public void run() {

String u=basic.hello("guolei");

//System.out.println(u);

cdl.countDown();

}

});

}

cdl.await();

long time = System.currentTimeMillis() - start;

System.out.println("SayHello:");

System.out.println("耗时：" + (double) time / 1000 + " s");

System.out.println("平均:" + ((double) time) / size +" ms");

System.out.println("TPS:" + (double) size / ((double) time / 1000));

// System.out.println("Hello, " + s.getMail());

} catch (MalformedURLException e) {

e.printStackTrace();

} catch (InterruptedException e) {

e.printStackTrace();

}finally{

es.shutdown();

}

　4.使用JMeter来进行现代化测试

　　我们要使用JMeter来测试hetty，由于hetty是一款基于hessian和netty的RPC产品，我们必须使用JMeter的JAVA请求功能来进行测试，Java请求是指JMeter对Java Class进行性能测试。首先我们需要编写测试用例：

　　1）新建JAVA工程。

　　2）引入ApacheJMeter_java.jar 、ApacheJMeter_core.jar以及测试所需要的jar（jar包在JMeter目录的lib/ext目录中）。

　　3）继承AbstractJavaSamplerClient类开始编写主业务。如下：

public class HettyTest extends AbstractJavaSamplerClient {

private static String label = "hettyTest";

/**

* 执行runTest()方法前会调用此方法,可放一些初始化代码

public void setupTest(JavaSamplerContext arg0) {

}

/**

* JMeter测试用例入口

public SampleResult runTest(JavaSamplerContext arg0) {

SampleResult sr = new SampleResult();

sr.setSampleLabel(label);

try { // 这里调用我们要测试的java类，这里我调用的是一个Test类

Map map = getDefaultParameters().getArgumentsAsMap();

sr.sampleStart(); // 记录程序执行时间，以及执行结果

Test.execute(map.get("ip"),map.get("port"));

sr.sampleEnd();

sr.setSuccessful(true);

} catch (Throwable e) {

sr.setSamplerData(e.getMessage());

e.printStackTrace();

sr.setSuccessful(false); // 用于设置运行结果的成功或失败，如果是"false"则表示结果失败，否则则表示成功

}

return sr;

}

/**

* JMeter界面中可手工输入参数,代码里面通过此方法获取

public Arguments getDefaultParameters() {

Arguments args = new Arguments();

args.addArgument("ip", "localhost");

args.addArgument("port", "8081");

return args;

}

/**

* 执行runTest()方法后会调用此方法.

public void teardownTest(JavaSamplerContext arg0) {

}

　　Test类是我测试逻辑，如下：

public class Test {

public static void execute(String ip,String port) throws MalformedURLException {

String url = "http://"+ip+":"+port+"/apis/hello";

HessianProxyFactory factory = new HessianProxyFactory();

factory.setUser("client1");

factory.setPassword("client1");

factory.setOverloadEnabled(true);

final Hello basic = (Hello) factory.create(Hello.class, url);

//System.out.println("SayHello:" + basic.hello("guolei"));

}

　　代码中都有注释，按照注释实际操作去理解。 System.out等的输出会显示在启动JMeter时的命令窗口内，但过多的输出会影响性能的准确性。

　　4）将项目打为jar包，放到JMeter目录下的lib/ext下（将项目依赖的jar也放到此目录）。

　　5）重启JMeter。

　　5.JMeter使用

　　1）选中主界面左侧的“测试计划”，右键菜单->添加->Threads(Users)->线程组。

　　2）再选中刚才新增的"线程组"，右键菜单->添加->Sampler->Java请求。

　　3）再选中刚才新增的"Java请求"，右键菜单->添加->监视器->聚合报告。

　　4）Ctrl + R，开始运行， Ctrl + E，清除历史结果。

　　6.查看测试结果

　　聚合报告中基本已经包含我们所关心的几个数据了：

　　Samples -- 本次场景中一共完成了多少个Transaction

　　Average -- 平均响应时间

　　Median -- 统计意义上面的响应时间的中值

　　90% Line -- 所有transaction中90%的transaction的响应时间都小于xx

　　Min -- 最小响应时间

　　Max -- 最大响应时间

　　PS: 以上时间的单位均为ms

　　Error -- 出错率

　　Troughput -- 吞吐量，单位：transaction/sec

　　KB/sec -- 以流量做衡量的吞吐量

顺其自然EVO 2013-11-25 10:38 发表评论

JMeter Tutorial的安装和具体操作

顺其自然EVO — Fri, 22 Nov 2013 04:19:00 GMT

1、下载Jmeter

　　下载地址：http://jmeter.apache.org/download_jmeter.cgi

　　目前最新版为2.9，其余文件如源代码等也可从如下官网下载：

　　http://jmeter.apache.org/download_jmeter.cgi

　　2、安装Jmeter之前

　　安装Jmeter之前需要先配置Java环境，我们下载的是jmeter2.9，所以java版本最好是选用java6以后的版本。

　　安装JDk1.6的步骤如下：

　　点击下载的JDK文件-dk-6u18-windows-i586.exe，点击下一步直至安装完成，然后开始配置环境：

　　点击我的电脑----属性----高级----环境变量----在系统变量中----点击新建，

　　在变量名中输入：JAVA_HOME

　　变量值中输入：C:\Program Files (x86)\Java\jdk1.6.0_18

　　再次点击新建：

　　在变量名中输入：CLASSPATH，

　　变量值中输入：.;%JAVA_HOME%/lib/dt.jar;%JAVA_HOME%/lib/tools.jar;

　　然后再系统变量中找到Path，点击编辑，在变量值中加上：

　　%JAVA_HOME%/bin;%JAVA_HOME%/jre/bin;（如果前面没有“;”需要加上）

　　配置完成之后，点击确定保存，然后cmd打开命令窗口输入：java或者javac，出现大串字符串表示配置成功。

　　也可以输入：java -version 查看java版本来查看是否配置成功。

　　OK，JDK安装成功之后，就可以下一步安装Jmeter了。

　　3、安装Jmeter

　　解压apache-jmeter-2.9.zip文件至目录，我的是D:\Program Files目录。

　　点击我的电脑----属性----高级----环境变量----在系统变量中----点击新建，

　　变量名输入：JMETER_HOME

　　变量值输入：D:\Program Files\apache-jmeter-2.9

　　然后编辑CLASSPATH变量，加上%JMETER_HOME%\lib\ext\ApacheJMeter_core.jar;%JMETER_HOME%\lib\jorphan.jar;%JMETER_HOME%\lib\logkit-2.0.jar;然后确定即可

　　操作完上面的步骤，我们就可以点击Jmeter中bin目录下面的jmeter.bat文件即可打开Jmeter了。

　　注意：打开的时候会有两个窗口，Jmeter的命令窗口和Jmeter的图形操作界面，不可以关闭命令窗口。

　　二、录制Jmeter脚本

　　录制Jmeter脚本有两种方法，一种是设置代理；一种则是利用badboy软件，badboy软件支持导出jmx脚本。

　　这里我们介绍第二种方法，利用badboy录制脚本，然后导出Jmeter需要的jmx文件。

　　首先，在地址栏中输入要录制脚本的地址，然后点击绿色按钮即可开始录制（工具栏中的红色按钮也可以点击进行录制），点击红色圆形按钮旁边的正方形黑色按钮结束脚本录制（如果使用过loadrunner，那么步骤是一样的），在内嵌的浏览器上面操作你需要测试的动作即可，它会自己记录你的相关行为动作。

　　然后点击黑色按钮录制完成之后，我们可以导出jmx文件：

　　保存为“登录开发者.jmx”。

　　三、使用Jmeter开始测试

　　1、打开脚本

　　用Jmeter打开我们上面保存的文件。

　　打开之后如图所示：

　　2、修改脚本

　　a、线程组

　　在测试计划里面选择添加既可以看到线程组。

　　如上图：

　　名称：可以随意取，我们保持创建是自动分配的名称

　　注释：随意

　　在取样器错误后要执行的动作：我们选择继续，错误之后依然继续执行

　　线程数：一般我们用来表示多少个用户，即我们测试时的用户数量

　　Ramp-up Period(in Seconds)：表示每个用户启动的延迟时间，上述我设为1秒，表示系统将在1秒结束前启动我设置的1000个用户，如果设置为1000秒，那么系统将会在1000秒结束前启动这1000个用户，开始用户的延迟为1秒，如果我设置为0秒，则表示立即启动所有用户。

　　循环次数：如果你要限定循环次数为10次的话，可以取消永远的那个勾，然后在后面的文本框里面填写10；在这里我们勾上永远，表示如果不停止或者限定时间将会一直执行下去，是为了方便调度器的调用。

　　调度器的配置：我们勾选调度器时，将会出现这个面板

　　启动时间：表示我们脚本开始启动的时间，当你不想立即启动脚本测试，但是启动脚本的时间不会再电脑旁的时候，你可以设定一个启动的时间，然后再运行那里点击启动，系统将不会立即运行，而是会等到你填写的时间才开始运行。

　　结束时间：与启动时间对应，表示脚本结束运行的时间。

　　持续时间：表示脚本持续运行的时间，以秒为单位，比如如果你要让用户持续不断登录1个小时，你可以在文本框中填写3600。如果在1小时以内，结束时间已经到达，它将会覆盖结束时间，继续执行。

　　启动延迟：表示脚本延迟启动的时间，在点击启动后，如果启动时间已经到达，但是还没有到启动延迟的时间，那么，启动延迟将会覆盖启动时间，等到启动延迟的时间到达后，再运行系统。

　　注意：如果我们需要用到调度器来设定持续时间，如果线程数不够多到持续时间结束，我们就必须将循环次数勾选为永远，特别地，如果线程组里面有其他的循环，我们也需将该循环次数勾选为永远（如我上面录制的脚本中的Step1也是一个循环，需要将永远勾选），否则，按我如上配置，将永远去掉勾选，文本里填1，那么无论你将持续时间启动时间结束时间等设置多少，系统运行1000次后，将会停止不再运行。

　　b、关于HTTP请求

　　关于HTTP请求，我们录制的脚本里面就有，这里就介绍一些常用的属性。

　　如图所示：

　　点击HTTP请求，将会出现如下界面：

　　其中：

　　名称：可以随意取，我们可以根据录制脚本的路径来命名

　　注释：可以对该界面做一个简单介绍

　　服务器名称或IP：即我们的服务器或者IP的地址，我因为是在本机上的项目，故填写localhost，可以填写127.0.0.1。

　　端口号：我用的是tomcat，自己设置的端口号为8086（tomcat默认为8080）

　　后面的超时定义可以不用填写。

　　Implementation：这里我们录制时默认填写为JAVA

　　协议填写为：http

　　方法为：GET

　　Content encoding：编码可以不用填写

　　路径：即页面的路径；下面的重定向等选择可以根据需要勾选，这里我们保持录制不修改。

　　Parameters参数：即跟着路径一起发送的参数及文件

　　下面的代理服务器等可以忽略，按需要填写。

　　c、参数化

　　如下，我们为请求发送的参数来参数化。

　　上述的例子为登录的用例，登录有两个参数：EMAIL和DEVELOPER_PASSWORD，在实际测试中，当我们需要用到不同的用户来登录的时候，我们就可以用到参数化。

　　1)、我们新建一个文件，这里我新建的是一个txt文件，命名为c.txt，里面的内容为

　　web@qq.com,111111

　　col@qq.com,111111

　　mon@qq.com,111111

　　2)、在jmeter中的【选项】中选择【函数助手对话框】，将会弹出如下对话框：

　　其中：

　　CSV file to get values from | *alias：要读取的文件路径，为绝对路径

　　CSV文件列号| next| *alias：从第几列开始读取，注意第一列是0

　　如上图所示，我们读取的是c.txt里面的第一列用户名(如果要读取第二列的密码，只需将0改成1即可,往后类推)，点击【生成】按钮即可生成函数，我们使用时即拷贝生成的函数字符串：${__CSVRead(E:\c.txt,0)}。

　　其他函数后面介绍。

　　d、断言验证

　　在web测试中，有的时候，即使我们测试返回的response code为200，也不能保证该测试是正确的，这时候，我们可以用到响应断言，通过对比响应的内容来判断返回的页面是否是我们确定要返回的页面。

　　选择我们要判断的页面，点击添加断言----响应断言，将会出现如下图：

　　名称：随意，这里我们不做改动

　　注释：随意

　　Apply to：这里我们选择默认值

　　要测试的响应字段：这里我们选择响应的文本，即返回的页面信息

　　模式匹配规则：这里我们选择包括，即响应的文本是否包括我们验证的信息

　　要测试的模式：开发者名称，即我们需要验证，开发者名称是否在响应文本中存在，也可以添加更多的字段来验证。

　　其他还有文件大小和响应时间等的断言，后面介绍。

　　e、添加监听器

　　我们做性能测试的时候，经常需要各种数据来验证我们的测试结果，Jmeter里面也提供了相关的功能，这里主要说一下Aggregate Report聚合报告。

　　点击添加---监听器，选择：查看结果树，和聚合报告，如果需要看到断言信息也可以选择断言结果，将设置的一切保存之后，然后点击启动，系统将会运行，将结果在监听器中表现出来。

　　四、分析结果

　　1、查看结果树

　　如图所示：成功的为绿色，失败则显示为红色。如果测试的结果太多，你只需要看到错误的页面，则勾选【仅日志错误】

　　2、聚合报告(Aggregate Report)

　　其中：

　　Label：标签，即我们上面的请求名称

　　#Samples：本次场景中一共发出了多少个请求

　　Average：平均响应时间

　　Median：中位数，也就是50%的用户的响应时间

　　90%Line：表示90%的用户的响应时间，如果最小值和最大值相差很大的话，我们一般选择这个作为最终测试结果

　　Min：最小响应时间

　　Max：最大响应时间

　　Error%：出错率，本次测试中出现错误的请求的数量/请求的总数

　　Throughput：吞吐量

　　KB/sec：每秒从服务器端接受到的数据量

　　五、监控内存及CPU等

　　很多时候，我们测试性能都需要查看内存和CPU等信息来判断系统瓶颈，关于CPU和内存的监控，Jmeter并没有很好的支持，很多时候，我们都只能通过系统的资源监控器来观察，一闪而过不会记录下来，很不方便。幸好google开发了一款专门监控的Jmeter插件，弥补了Jmeter这方面的不足，下面就来介绍一些这款插件——JMeterPlugins，目前我用的是0.5.6版本。

　　1、JMeterPlugins的下载地址

　　地址：http://code.google.com/p/jmeter-plugins/downloads/list，选择需要的版本，下载

　　2、JMeterPlugins的配置使用

　　将下载的文件解压，得到如下目录：

　　将JMeterPlugins.jar包复制到Jmeter的lib目录下面的ext目录下面,重新启动Jmeter，我们点击添加就可以看到出现了很多的jp@gc-开头的文件.

　　这里监控内存我们使用的是：jp@gc - PerfMon Metrics Collectot

　　在使用之前，我们需要运行/serverAgent/startAgent.bat这个文件，我们需要将serverAgent目录及下面的文件复制到我们测试的服务器上，然后点击打开(我这里是本机，直接在本机上面打开这个应用系统即可)，它的默认端口为4444。

　　一切准备好后，点击启动，即可得到如下图：

　　你就可以得到系统运行时，你所需要的常用的性能值了。

　　六、监控内存及CPU等（jconsole）

　　最近逛论坛的时候，发现了一个比较好的监控内存CPU等的小工具，本着开源小工具多多益善的原则，记录一下。

　　打开这个小工具的步骤很简单，如果你已经配置好了Jmeter运行的环境，那么你也就不用去做其他的配置，直接点击：开始——》运行——》输入cmd——》然后在出现的命令行界面输入“jconsole”即可弹出一个【java监视和管理控制台】，

　　将会弹出如下界面：

　　这里我们选择本地进程，并点击一下sun.tools.jconsole.JConsole这一行，然后点击连接，就可以查看我们的内存和CPU的使用情况了。

　　当然，我们要得到服务器的内存使用等信息，也可以选择本地进程下面的远程进程，在文本框中输入我们需要测试的服务器的IP地址：端口，然后在下面输入用户名和密码，点击连接，看看会出现什么情况。

顺其自然EVO 2013-11-22 12:19 发表评论

使用Jmeter测试java requst

顺其自然EVO — Thu, 21 Nov 2013 04:50:00 GMT

PS：不会使用jmeter以及没有编程基础的不推荐看。

　　个人一直认为使用Loadrunner或者Jmeter来测试java 方法都是费力不讨好的事情。java本身就有多线程机制，直接写个测试类弄弄不就好了嘛。但是还是架不住很多人的需求，简单来讲一下如果使用Jmeter测试java request吧。

　　首先本人准备测试的jar包已经准备好了叫Hello.jar，源代码如下：

package com.test.webservice;

public class Hello

{

public String sayHello()

{

return "Hello";

}

public String sayHelloToPerson(String s)

{

if(s == null || s.equals(""))

s = "nobody";

return (new StringBuilder()).append("Hello ").append(s).toString();

}

public int sum(int a,int b)

{

return a+b;

}

　　要在Jmeter里面使用java request测试Hello.jar里面的方法，需要做一些工作。

　　一、在eclipse（别的也可以）里面新建一个工程，把{Jmeter_home}\lib目录下的所有jar

　　（根据情况其实可以只用导入以下几个：ApacheJmeter_core.jar、Apache_Jmeter_java.jar、jorphan.jar、logkit-2.0.jar、avalon-framwork-4.1.4.jar）和被测的jar（包括被测试的方法需要用到的所有第三方jar）都导入到classpath。

　二、编写测试类

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.test.webservice.Hello;

public class perftestbbb extends AbstractJavaSamplerClient {

private String a;

private String b;

/** Holds the result data (shown as Response Data in the Tree display). */

private String resultData;

//这个方法是用来自定义java方法入参的。

//params.addArgument("num1","");表示入参名字叫num1，默认值为空。

public Arguments getDefaultParameters() {

Arguments params = new Arguments();

params.addArgument("num1","");

params.addArgument("num2","");

return params;

}

public void setupTest(JavaSamplerContext arg0) {

}

public SampleResult runTest(JavaSamplerContext arg0) {

a = arg0.getParameter("num1");

b = arg0.getParameter("num2");

SampleResult sr = new SampleResult();

try {

sr.sampleStart();// jmeter 开始统计响应时间标记

Hello test = new Hello();

//通过下面的操作就可以将被测方法的响应输出到Jmeter的察看结果树中的响应数据里面了。

resultData = String.valueOf(test.sum(Integer.parseInt(a), Integer.parseInt(b)));

if (resultData != null && resultData.length() > 0) {

sr.setResponseData(resultData, null);

sr.setDataType(SampleResult.TEXT);

}

// System.out.println(resultData);

sr.setSuccessful(true);

} catch (Throwable e) {

sr.setSuccessful(false);

e.printStackTrace();

} finally {

sr.sampleEnd();// jmeter 结束统计响应时间标记

}

return sr;

}

public void teardownTest(JavaSamplerContext arg0) {

// System.out.println(end);

// System.out.println("The cost is"+(end-start)/1000);

}

//main只是为了调试用，最后打jar包的时候注释掉。

/* public static void main(String[] args) {

// TODO Auto-generated method stub

Arguments params = new Arguments();

params.addArgument("num1", "1");//设置参数，并赋予默认值1

params.addArgument("num2", "2");//设置参数，并赋予默认值2

JavaSamplerContext arg0 = new JavaSamplerContext(params);

perftestbbb test = new perftestbbb();

test.setupTest(arg0);

test.runTest(arg0);

test.teardownTest(arg0);

}*/

}

　　三、将测试类打成jar包放入{Jmeter_home}\lib\ext目录下，同时将被测试的jar包及被测试的方法需要用到的所有第三方jar都放入{Jmeter_home}\lib目录下。

　　四、重新打开Jmeter，添加sampler-java request，选择测试类。

　　其它的就参照常规做法即可。

　　以上仅供学习和参考用，欢迎交流，勿喷！

顺其自然EVO 2013-11-21 12:50 发表评论

Jmeter压力测试模拟并发

顺其自然EVO — Wed, 20 Nov 2013 03:15:00 GMT

　jmeter下载地址：http://jmeter.apache.org/download_jmeter.cgi

　　JMeterPlugins（jmeter插件）：http://jmeter-plugins.org/downloads/all/

　　下面直接贴使用步骤：

　　第二步：添加Sampler

　　第三步：配置HTTP请求

第四步：添加监听器

　　最后配置线程组：

　　好了，现在按一下 ctrl+R 开始运行，并发发送请求了。

顺其自然EVO 2013-11-20 11:15 发表评论

JMeter入门(4)：Java Request实例

顺其自然EVO — Tue, 19 Nov 2013 03:09:00 GMT

　目的：对Java程序进行测试；

　　一、核心步骤

　　1.创建一个Java工程；

　　2.将JMeter的lib目录下的jar文件添加进此工程的Build Path；

　　3.创建一个类并实现JavaSamplerClient接口或继承AbstractJavaSamplerClient，并重写：

public Arguments getDefaultParameters()：设置可用参数及的默认值；

public void setupTest(JavaSamplerContext arg0)：每个线程测试前执行一次，做一些初始化工作；

public SampleResult runTest(JavaSamplerContext arg0)：开始测试，从arg0参数可以获得参数值；

public void teardownTest(JavaSamplerContext arg0)：测试结束时调用；

4.Export为Runnable Jar File；

　　5.将此jar包放入JMETER_HOME\lib\ext目录；

　　6.以管理员身份打开JMeter；

　　7.创建线程组、Java Request、结果树，进行测试；

　　二、实例

　　利用JMeter对服务进行性能测试，服务为：将输入的两个参数通过IO存入文件；

　　1、编写Java代码

　　服务：

package test;

import java.io.File;

import java.io.PrintWriter;

public class OutputService {

public static void output(String filename,int a, int b) throws Exception {

PrintWriter out = new PrintWriter(new File(filename));

out.write(a+":"+b);

out.close();

}

　　测试类：

package test;

import org.apache.jmeter.config.Arguments;

import org.apache.jmeter.protocol.java.sampler.JavaSamplerClient;

import org.apache.jmeter.protocol.java.sampler.JavaSamplerContext;

import org.apache.jmeter.samplers.SampleResult;

public class PerformenceTest implements JavaSamplerClient {

private SampleResult results;

private String a;

private String b;

private String filename;

// 设置传入的参数，可以设置多个，已设置的参数会显示到Jmeter的参数列表中

public Arguments getDefaultParameters() {

Arguments params = new Arguments();

params.addArgument("filename", "0");//设置参数，并赋予默认值0

params.addArgument("a", "0");//设置参数，并赋予默认值0

params.addArgument("b", "0");//设置参数，并赋予默认值0

return params;

}

// 初始化方法，实际运行时每个线程仅执行一次，在测试方法运行前执行

public void setupTest(JavaSamplerContext arg0) {

results = new SampleResult();

}

// 测试执行的循环体，根据线程数和循环次数的不同可执行多次

@Override

public SampleResult runTest(JavaSamplerContext arg0) {

b = arg0.getParameter("b"); // 获取在Jmeter中设置的参数值

a = arg0.getParameter("a"); // 获取在Jmeter中设置的参数值

filename = arg0.getParameter("filename"); // 获取在Jmeter中设置的参数值

results.sampleStart();// jmeter 开始统计响应时间标记

try {

OutputService test = new OutputService();

test.output(filename,Integer.parseInt(a), Integer.parseInt(b));

results.setSuccessful(true);

// 被测对象调用

} catch (Throwable e) {

results.setSuccessful(false);

e.printStackTrace();

} finally {

results.sampleEnd();// jmeter 结束统计响应时间标记

}

return results;

}

// 结束方法，实际运行时每个线程仅执行一次，在测试方法运行结束后执行

public void teardownTest(JavaSamplerContext arg0) {

}

public static void main(String[] args) {

// TODO Auto-generated method stub

Arguments params = new Arguments();

params.addArgument("a", "0");//设置参数，并赋予默认值0

params.addArgument("b", "0");//设置参数，并赋予默认值0

JavaSamplerContext arg0 = new JavaSamplerContext(params);

PerformenceTest test = new PerformenceTest();

test.setupTest(arg0);

test.runTest(arg0);

test.teardownTest(arg0);

}

Export 为 Runnable Jar File；

2、设置JMeter

　　以管理员身份打开JMeter，并创建Java Request后,结构如下图所示：

　　在Java请求中发现了自己新建的测试类：

　　我们在JMeter中发现参数有三个：

　　我们在响应的数值中填入：

　　大家一定很奇怪，怎么会有一些看不懂的东西，这是JMeter提供的函数，我们可以在

　　因为我们要做的是性能测试，因此我们需要开多个线程并发测试，因此随机数很重要；

　　常用的函数为：

　　(1)_Random生成随机整数；

　　(2)_RandomString生成随机字符串；

　　在线程组中设置并发线程数为10000，保存后即可运行；

　　图形结果如下所示：

聚合报告：

　　表格查看结果：

　　结果成功，成功生成了接近10000个文件：

　　3.期间遇到的问题

　　3.1 Export为Jar File导致Java Request的类名称无法找到；

　　3.2 JMeter java.lang.OutOfMemoryError: PermGen space问题：

　　在JMeter.bat 中修改：

　　set HEAP=-Xms512m -Xmx1024m

　　set NEW=-XX:NewSize=128m -XX:MaxNewSize=128m

　　set SURVIVOR=-XX:SurvivorRatio=8 -XX:TargetSurvivorRatio=50%

　　set TENURING=-XX:MaxTenuringThreshold=2

　　set RMIGC=-Dsun.rmi.dgc.client.gcInterval=600000 -Dsun.rmi.dgc.server.gcInterval=600000

　　set PERM=-XX:PermSize=256m -XX:MaxPermSize=512m

　　3.3 JMeter需要以管理员身份打开，否则会出现：

JMeter入门(3)：录制JMeter脚本

顺其自然EVO 2013-11-19 11:09 发表评论

JMeter入门(3)：录制JMeter脚本

顺其自然EVO — Mon, 18 Nov 2013 05:50:00 GMT

　一般自己手动的设置JMeter会比较麻烦，如果一边操作页面，提交表单，一边能够自动生成JMeter的脚本，则非常方便；

　　BadBoy：录制JMeter脚本；

　　Donwload URL：http://www.badboy.com.au/download/add

　　BadBoy界面如下：

　　我们可以在地址输入栏中输入你要访问的页面，比如www.baidu.com,然后查询xiazdong后，点击：停止录制；

　　然后点击"File --> Export to JMeter"即可生成JMeter脚本；

　　打开后生成如下结构：

　　我们只需要运行即可模拟刚才查询"xiazdong"的过程，当然我们可以同时开启1000个线程模拟1000个用户在查询xiazdong；

　　图形结果效果如下：

JMeter入门(2)：一个简单实例

顺其自然EVO 2013-11-18 13:50 发表评论

badboy + jmeter并发性能测试

顺其自然EVO — Fri, 15 Nov 2013 03:14:00 GMT

今天下班时公司安排了一个同事来对项目做集群性能测试，怀着对性能测试的好奇心，下班后没有着急离开，而是等待

　　那位同事的到来，然后在旁边学习了下如何使用Badboy和jmeter做性能测试。

　　1. 软件介绍

　　1.1 Badboy

　　Badboy，第一眼看见这个单词，以为是坏孩子的意思，后来一想，它是专门用来给项目找茬来的，取名为Badboy

　　倒是平添了几分可爱，呵呵。

　　Badboy是用来录制操作过程的，它录制的结果是被jmeter做并发测试的素材使用。

　　Badboy首页：http://www.badboy.com.au/

　　1.2 Apache jmeter

　　Jmeter是Apache下的一个完全基于JAVA开发的测试工具，可以很方便的用来进行并发测试。

　　Jmeter首页：http://jakarta.apache.org/jmeter/

　　2. 使用过程

　　2.1 录制操作

　　（1）打开badboy进行登录的录制工作。（我们来看下163邮箱的登录并发性能如何，嘿嘿。）

　　（2）点击登录，然后结束录制，将录制的过程保存下来，保存成jmeter能够使用的格式，Script.jmx：

　2.2 测试并发

　　（1）运行Apache Jmeter，文件à打开，然后选择刚才保存的录制文件 Script.jmx

　　（2）设置模拟并发的线程数量

　　（3）添加感兴趣的监听类型

　　（4）点击运行à启动，开始执行并发登录163邮箱操作。

2.3 分析结果

顺其自然EVO 2013-11-15 11:14 发表评论

JMeter入门(2)：一个简单实例

顺其自然EVO — Fri, 15 Nov 2013 03:13:00 GMT

　场景描述：

　　自己建立一个服务器端，接受参数：name和age，并将这些数据保存到数据库中；

　　http://localhost:8080/Server/SaveServlet?name=xxx&age=xxx

　　我们通过JMeter对其进行压力测试；

　　目标：开1000个线程，每个线程循环1次，全部操作在3秒内完成；

　　结构如下：

　结果如下：

JMeter入门(1)：JMeter总体介绍及组件介绍

顺其自然EVO 2013-11-15 11:13 发表评论

JMeter入门(1)：JMeter总体介绍及组件介绍

顺其自然EVO — Thu, 14 Nov 2013 02:33:00 GMT

一、JMeter概述

　　JMeter就是一个测试工具，相比于LoadRunner等测试工具，此工具免费，且比较好用，但是前提当然是安装Java环境；

　　JMeter可以做

　　(1)压力测试及性能测试；

　　(2)数据库测试；

　　(3)Java程序的测试；

　　(4)HTTP及FTP测试；

　　(5)Web Service测试；

　　等等；

　　和JMeter一起使用的可能是JDK自带的测试工具JConsole，位于JDK\bin\JConsole，此工具主要观察堆、JVM、CPU的使用情况，界面如下：

　　二、JMeter安装

　　解压缩即可；

　　JMeter插件：http://code.google.com/p/jmeter-plugins/downloads/detail?name=JMeterPlugins-0.5.3.zip

　　下载后将jar文件放到JMETER_HOME\lib\ext目录；

　三、JMeter常用组件

　　测试计划：整个测试计划；

　　线程组：所有的任务都是基于线程组，开通多少个线程就代表有多少个并发用户；

　　Ramp-Up Period：在这么多时间内完成全部测试，比如开了2个线程，而Ramp-Up Period为3，则每个线程的间隔为1.5秒；

　　Sampler：所有的测试任务都是Sampler，即任何测试任务的类别都是Sampler，比如HTTP请求、JDBC请求、FTP请求；

　　断言：对Sampler的测试进行判断是否正确；

　　监听器：对Sampler的请求结果进行统计、显示；

　　常用的层次结构为：

　　常用的组件有：

　　HTTP请求：模拟HTTP请求；

　　查看结果树：对于每个请求，可以查看HTTP请求和HTTP响应；

　　图形结果：可以图形显示吞吐量、响应时间等；

　　聚合报告：总体的吞吐量、响应时间；

　　1、Label：定义的HTTP请求名称

　　2、Samples：表示这次测试中一共发出了多少个请求

　　3、Average：访问页面的平均响应时间

　　4、Min: 访问页面的最小响应时间

　　5、Max: 访问页面的最大响应时间

　　6、Error%：错误的请求的数量/请求的总数

　　7、Throughput：每秒完成的请求数

　　8、KB/Sec：每秒从服务器端接收到的数据量

顺其自然EVO 2013-11-14 10:33 发表评论

JUnit单元测试实践：测试工具类和方法

顺其自然EVO — Wed, 13 Nov 2013 02:25:00 GMT

　　工作中，为了提高Web开发的质量和效率，近期又为了保证自己的工具类等一系列可复用组件的质量，我煞费苦心地开始认真学习和撰写单元测试用例。

　　我现在已经厌倦了Debug程序，更讨厌Debug Web程序，太浪费时间了。

　　最近，线上的一个BM项目，出了个bug。浮点数相减，没有判断null，搞的我加班到9：30。

　　苦逼的码农啊。

　　下面，分享我的一个工具类和对应的单元测试用例。

　　有不对的地方，还望能告知我。大家共同进步。

/**

* 判断Collection(List和Set),Map等集合类型是否为空，是否含有空值。

* 判断String是否为空，参考ApacheCommonsLang-StringUtils。

* @author leiwen

public class EmptyUtils {

/**

* 判断Collection(List和Set) 是否为空

* @param collection

* List或Set类型的集合

* @return 如果collection是 null或size=0，返回true；否则，返回false。

public static boolean isEmpty(Collection collection) {

return collection == null || collection.size() == 0;

}

/**

* 判断map是否为空

* @param map

* 键值对数据类型

* @return 如果map是 null或size=0，返回true；否则，返回false。

public static boolean isEmpty(Map map) {

return map == null || map.size() == 0;

}

/**

* 判断一个数组是否为空。

* @param array

* 对象数组

* @return 如果数组为null或者数组元素个数为0，返回true；否则，返回false。

public static boolean isEmpty(Object[] array) {

return array == null || array.length == 0;

}

/**

* 判断Collection(List和Set) 不为空

* @param collection

* List或Set类型的集合

* @return 如果collection不等于null且size>0，返回true；否则，返回false。

public static boolean notEmpty(Collection collection) {

return !isEmpty(collection);

}

/**

* 判断map不为空

* @param map

* 键值对数据类型

* @return 如果map不为 null且size>0，返回true；否则，返回false。

public static boolean notEmpty(Map map) {

return !isEmpty(map);

}

/**

* 判断一个数组不为空。

* @param array

* 对象数组

* @return 如果数组为null或者数组元素个数为0，返回false；否则，返回true。

public static boolean notEmpty(Object[] array) {

return !isEmpty(array);

}

package cn.fansunion.webcommon.platform;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import junit.framework.TestCase;

import org.junit.Test;

import cn.fansunion.common.util.EmptyUtils;

/**

* @author leiwen

public class EmptyUtilsTest extends TestCase {

@Test

public static void testCollectionIsEmpty() {

List list = Arrays.asList(1, 2, 3);

boolean listWithPositiveSize = EmptyUtils.isEmpty(list);

assertFalse(listWithPositiveSize);

List emptyList = new ArrayList();

boolean listWithZeroSize = EmptyUtils.isEmpty(emptyList);

assertTrue(listWithZeroSize);

List nullList = null;

boolean nullEmpty = EmptyUtils.isEmpty(nullList);

assertTrue(nullEmpty);

Set set = new HashSet();

set.add(100);

boolean setWithPositiveSize = EmptyUtils.isEmpty(set);

assertFalse(setWithPositiveSize);

Set nullSet = null;

assertTrue(EmptyUtils.isEmpty(nullSet));

Set emptySet = new HashSet();

assertTrue(EmptyUtils.isEmpty(emptySet));

}

@Test

public static void testMapIsEmpty() {

Map map = new HashMap();

map.put("mapTest", "mapTestValue");

assertFalse(EmptyUtils.isEmpty(map));

Map nullEmpty = null;

assertTrue(EmptyUtils.isEmpty(nullEmpty));

Map emptyMap = new HashMap();

assertTrue(EmptyUtils.isEmpty(emptyMap));

}

@Test

public static void testObjectArrayIsEmpty() {

Integer[] array = { 1, 2, 3 };

assertFalse(EmptyUtils.isEmpty(array));

Integer[] nullArray = null;

assertTrue(EmptyUtils.isEmpty(nullArray));

Integer[] emptyArray = {};

assertTrue(EmptyUtils.isEmpty(emptyArray));

}

@Test

public static void testCollectionNotEmpty() {

List list = Arrays.asList(1, 2, 3);

boolean listWithPositiveSize = EmptyUtils.notEmpty(list);

assertTrue(listWithPositiveSize);

List emptyList = new ArrayList();

boolean listWithZeroSize = EmptyUtils.notEmpty(emptyList);

assertFalse(listWithZeroSize);

List nullList = null;

boolean nullEmpty = EmptyUtils.notEmpty(nullList);

assertFalse(nullEmpty);

Set set = new HashSet();

set.add(100);

boolean setWithPositiveSize = EmptyUtils.notEmpty(set);

assertTrue(setWithPositiveSize);

Set nullSet = null;

assertFalse(EmptyUtils.notEmpty(nullSet));

Set emptySet = new HashSet();

assertFalse(EmptyUtils.notEmpty(emptySet));

}

@Test

public static void testMapNotEmpty() {

Map map = new HashMap();

map.put("mapTest", "mapTestValue");

assertTrue(EmptyUtils.notEmpty(map));

Map nullEmpty = null;

assertFalse(EmptyUtils.notEmpty(nullEmpty));

Map emptyMap = new HashMap();

assertFalse(EmptyUtils.notEmpty(emptyMap));

}

@Test

public static void testObjectArrayNotEmpty() {

Integer[] array = { 1, 2, 3 };

assertTrue(EmptyUtils.notEmpty(array));

Integer[] nullArray = null;

assertFalse(EmptyUtils.notEmpty(nullArray));

Integer[] emptyArray = {};

assertFalse(EmptyUtils.notEmpty(emptyArray));

}

顺其自然EVO 2013-11-13 10:25 发表评论

多线程测试工具groboutils的使用

顺其自然EVO — Wed, 13 Nov 2013 02:19:00 GMT

　一直使用junit做为服务测试框架，感觉不错。最近有人反映在高并发的情况下，存在服务调不到。无奈再次打开单元测试模拟高并发的情况，却发现junit不支持并发测试

　　引入groboutils jar包，其实我主要使用MultiThreadedTestRunner类和TestRunnable类。

　　原有的junit框架不做改变，导入GroboTestingJUnit-1.2.1-core.jar包

　　代码如下

public class FaultServiceTest extends TestCase {

/**

* @param args

* @throws FaultException

* @throws ExpParamNotFoundException

* @throws ParseException

private IFaultService faultService;

private static final int NUM_THREAD = 100; // 测试线程总数

public FaultServiceTest() {

super();

IInitService initService = (IInitService) CustomBeanFactory

.getBean("initService");

initService.initSiteDatabase();

this.faultService = (IFaultService) CustomBeanFactory

.getBean("faultService");

}

public FaultServiceTest(String name) {

super(name);

IInitService initService = (IInitService) CustomBeanFactory

.getBean("initService");

initService.initSiteDatabase();

this.faultService = (IFaultService) CustomBeanFactory

.getBean("faultService");

}

// 高并发测试

public void testGetEquipEventAlertListByPage() throws Throwable {

EquipmentQueryBean equipmentQueryBean = new EquipmentQueryBean();

// 生成所有测试线程

TestRunnable[] test = new TestRunnable[NUM_THREAD];

long start = System.currentTimeMillis();

for (int i = 0; i < test.length; i++) {

test[i] = new FaultServiceThread(faultService, equipmentQueryBean);

}

// 生成测试线程运行器

MultiThreadedTestRunner mttr = new MultiThreadedTestRunner(test);

// 运行测试线程

mttr.runTestRunnables();

long used = System.currentTimeMillis() - start;

System.out.printf("%s 调用花费 %s milli-seconds.\n", NUM_THREAD, used);

}

public static Test suite() {

TestSuite test = new TestSuite("HealthService接口类测试");

test.addTest(new FaultServiceTest("testGetEquipEventAlertListByPage"));

return test;

}

* 测试线程类定义

private static class FaultServiceThread extends TestRunnable {

private IFaultService faultService;

private EquipmentQueryBean equipmentQueryBean;

public FaultServiceThread(IFaultService faultService,

EquipmentQueryBean equipmentQueryBean) {

super();

this.faultService = faultService;

this.equipmentQueryBean = equipmentQueryBean;

}

@Override

public void runTest() throws Throwable {

faultService.getEquipEventAlertListByPage(equipmentQueryBean);

}

｝

　运行代码，并发数开到100个后观察运行时间发现运行运行时间到了12秒了，看来问题出在DAO。需要进行sql代码优化了

　　导入的测试包有：

import net.sourceforge.groboutils.junit.v1.MultiThreadedTestRunner;

import net.sourceforge.groboutils.junit.v1.TestRunnable;

import junit.framework.Test;

import junit.framework.TestCase;

import junit.framework.TestSuite;

顺其自然EVO 2013-11-13 10:19 发表评论