Gatling 基于 Scala 开发的压测工具，我们可以通过录制自动生成脚本，也可以自己编写脚本，大家不用担心，首先脚本很简单常用的没几个，另外 gatling 封装的也很好我们不需要去专门学习 Scala 语法，当然如果会的话会更好。

脚本示例

import io.gatling.core.Predef._
import io.gatling.http.Predef._
import scala.concurrent.duration._
class BaiduSimulation extends Simulation {
  //设置请求的根路径
  val httpConf = http.baseURL("https://www.baidu.com")
  /*
    运行100秒 during 默认单位秒,如果要用微秒 during(100 millisecond)
   */
  val scn = scenario("BaiduSimulation").during(100){
    exec(http("baidu_home").get("/"))
  }
  //设置线程数
//  setUp(scn.inject(rampUsers(500) over(10 seconds)).protocols(httpConf))
  setUp(scn.inject(atOnceUsers(10)).protocols(httpConf))
}

脚本编写

Gatling 脚本的编写主要包含下面三个步骤

• http head 配置
• Scenario 执行细节
• setUp 组装

我们以百度为例，进行第一个 GET 请求测试脚本的编写，类必须继承 Simulation

1. 配置下 head，只是简单的请求下百度首页，所以只定义下请求的 base url，采用默认的 http 配置即可 //设置请求的根路径 val httpConf = http.baseURL("https://www.baidu.com")

2. 声明 Scenario，指定我们的请求动作

   val scn = scenario("BaiduSimulation").
   exec(http("baidu_home").get("/"))
   

   scenario 里的参数：scenario name
   exec() 里的参数就是我们的执行动作，http("本次请求的名称").get("本次 http get 请求的地址")

3. 设置并发数并组装

   //设置线程数
   setUp(scn.inject(atOnceUsers(10)).protocols(httpConf))
   

   atOnceUsers：立马启动的用户数，可以理解为并发数

这样我们一个简单的脚本就完成了，可以运行看下效果。

高级教程

Injection -- 注入

注入方法用来定义虚拟用户的操作

setUp(
  scn.inject(
    nothingFor(4 seconds), // 1
    atOnceUsers(10), // 2
    rampUsers(10) over(5 seconds), // 3
    constantUsersPerSec(20) during(15 seconds), // 4
    constantUsersPerSec(20) during(15 seconds) randomized, // 5
    rampUsersPerSec(10) to 20 during(10 minutes), // 6
    rampUsersPerSec(10) to 20 during(10 minutes) randomized, // 7
    splitUsers(1000) into(rampUsers(10) over(10 seconds)) separatedBy(10 seconds), // 8
    splitUsers(1000) into(rampUsers(10) over(10 seconds)) separatedBy atOnceUsers(30), // 9
    heavisideUsers(1000) over(20 seconds) // 10
  ).protocols(httpConf)
)

1. nothingFor(duration)：设置一段停止的时间
2. atOnceUsers(nbUsers)：立即注入一定数量的虚拟用户 setUp(scn.inject(atOnceUsers(50)).protocols(httpConf))
3. rampUsers(nbUsers) over(duration)：在指定时间内，设置一定数量逐步注入的虚拟用户 setUp(scn.inject(rampUsers(50) over(30 seconds)).protocols(httpConf))
4. constantUsersPerSec(rate) during(duration)：定义一个在每秒钟恒定的并发用户数，持续指定的时间 setUp(scn.inject(constantUsersPerSec(30) during(15 seconds)).protocols(httpConf))
5. constantUsersPerSec(rate) during(duration) randomized：定义一个在每秒钟围绕指定并发数随机增减的并发，持续指定时间 setUp(scn.inject(constantUsersPerSec(30) during(15 seconds) randomized).protocols(httpConf))
6. rampUsersPerSec(rate1) to (rate2) during(duration)：定义一个并发数区间，运行指定时间，并发增长的周期是一个规律的值 setUp(scn.inject(rampUsersPerSec(30) to (50) during(15 seconds)).protocols(httpConf))
7. rampUsersPerSec(rate1) to(rate2) during(duration) randomized：定义一个并发数区间，运行指定时间，并发增长的周期是一个随机的值 setUp(scn.inject(rampUsersPerSec(30) to (50) during(15 seconds) randomized).protocols(httpConf))
8. heavisideUsers(nbUsers) over(duration)：定义一个持续的并发，围绕和海维赛德函数平滑逼近的增长量，持续指定时间（译者解释下海维赛德函数，H(x) 当 x>0 时返回 1，x<0 时返回 0，x=0 时返回 0.5。实际操作时，并发数是一个成平滑抛物线形的曲线） setUp(scn.inject(heavisideUsers(50) over(15 seconds)).protocols(httpConf))
9. splitUsers(nbUsers) into(injectionStep) separatedBy(duration)：定义一个周期，执行 injectionStep 里面的注入，将 nbUsers 的请求平均分配 setUp(scn.inject(splitUsers(50) into(rampUsers(10) over(10 seconds)) separatedBy(10 seconds)).protocols(httpConf))
10. splitUsers(nbUsers) into(injectionStep1) separatedBy(injectionStep2)：使用 injectionStep2 的注入作为周期，分隔 injectionStep1 的注入，直到用户数达到 nbUsers setUp(scn.inject(splitUsers(100) into(rampUsers(10) over(10 seconds)) separatedBy atOnceUsers(30)).protocols(httpConf))

循环

val scn = scenario("BaiduSimulation").
    exec(http("baidu_home").get("/"))

上面的测试代码运行时只能跑一次，为了测试效果，我们需要让它持续运行一定次数或者一段时间，可以使用下面两个方式：

• repeat repeat(times，counterName) times:循环次数 counterName:计数器名称，可选参数，可以用来当当前循环下标值使用，从0开始 val scn = scenario("BaiduSimulation").repeat(100){ exec(http("baidu_home").get("/")) }
• during during(duration, counterName, exitASAP) duration:时长，默认单位秒，可以加单位milliseconds，表示毫秒 counterName:计数器名称，可选。很少使用 exitASAP：默认为true,简单的可以认为当这个为false的时候循环直接跳出,可在 循环中进行控制是否继续 /* 运行100秒 during 默认单位秒,如果要用微秒 during(100 millisecond) */ val scn = scenario("BaiduSimulation").during(100){ exec(http("baidu_home").get("/")) }

POST 请求

post 参数提交方式：

• JSON 方式

  import io.gatling.core.Predef._
  import io.gatling.core.scenario.Simulation
  import io.gatling.http.Predef._
  class JsonSimulation extends Simulation {
  val httpConf = http.baseURL("http://127.0.0.1:7001/tst")
  //注意这里,设置提交内容type
  val headers_json = Map("Content-Type" -> "application/json")
  val scn = scenario("json scenario")
  .exec(http("test_json")   //http 请求name
  .post("/order/get")     //post url
  .headers(headers_json)  //设置body数据格式
  //将json参数用StringBody包起,并作为参数传递给function body()
  .body(RawFileBody("request.txt"))
  setUp(scn.inject(atOnceUsers(10))).protocols(httpConf)
  }
  

• Form 方式

  import io.gatling.core.Predef._
  import io.gatling.http.Predef._
  class FormSimulation extends Simulation {
  val httpConf = http
  .baseURL("http://computer-database.gatling.io")
  //注意这里,设置提交内容type
  val contentType = Map("Content-Type" -> "application/x-www-form-urlencoded")
  //声明scenario
  val scn = scenario("form Scenario")
  .exec(http("form_test") //http 请求name
  .post("/computers") //post地址, 真正发起的地址会拼上上面的baseUrl http://computer-database.gatling.io/computers
  .headers(contentType)
  .formParam("name", "Beautiful Computer") //form 表单的property name = name, value=Beautiful Computer
  .formParam("introduced", "2012-05-30")
  .formParam("discontinued", "")
  .formParam("company", "37"))
  setUp(scn.inject(atOnceUsers(1)).protocols(httpConf))
  }
  

• RawFileBody

  import io.gatling.core.Predef._
  import io.gatling.core.scenario.Simulation
  import io.gatling.http.Predef._
  class JsonSimulation extends Simulation {
  val httpConf = http.baseURL("http://127.0.0.1:7001/tst")
  //注意这里,设置提交内容type
  val headers_json = Map("Content-Type" -> "application/json")
  val scn = scenario("json scenario")
  .exec(http("test_json")   //http 请求name
  .post("/order/get")     //post url
  .headers(headers_json)  //设置body数据格式
  //将json参数用StringBody包起,并作为参数传递给function body()
  .body(RawFileBody("request.txt"))
  setUp(scn.inject(atOnceUsers(10))).protocols(httpConf)
  }
  

  txt 的文件内容为 JSON 数据，存放目录/resources/bodies下

Feed 动态参数

Gatling 对参数的处理称为 Feeder[供料器]，支持主要有：

• 数组 val feeder = Array( Map("foo" -> "foo1", "bar" -> "bar1"), Map("foo" -> "foo2", "bar" -> "bar2"), Map("foo" -> "foo3", "bar" -> "bar3"))
• CSV 文件 val csvFeeder = csv("foo.csv")//文件路径在 %Gatling_Home%/user-files/data/
• JSON 文件 val jsonFileFeeder = jsonFile("foo.json") //json的形式： [ { "id":19434, "foo":1 }, { "id":19435, "foo":2 } ]
• JDBC 数据 jdbcFeeder("databaseUrl", "username", "password", "SELECT * FROM users")

• Redis

  可参看官方文档http://gatling.io/docs/2.1.7/session/feeder.html#feeder
  

  使用示例：

  import io.gatling.core.Predef._
  import io.gatling.core.scenario.Simulation
  import io.gatling.http.Predef._
  import scala.concurrent.duration._
  /**
  * region请求接口测试
  */
  class DynamicTest extends Simulation {
  val httpConf = http.baseURL("http://127.0.0.1:7001/test")
  //地区 feeder
  val regionFeeder = csv("region.csv").random
  //数组形式
  val mapTypeFeeder = Array(
      Map("type" -> ""),
      Map("type" -> "id_to_name"),
      Map("type" -> "name_to_id")).random
  //设置请求地址
  val regionRequest =
      exec(http("region_map").get("/region/map/get"))
      //加载mapType feeder
      .feed(mapTypeFeeder)
      //执行请求, feeder里key=type, 在下面可以直接使用${type}
      .exec(http("province_map").get("/region/provinces?mType=${type}"))
      //加载地区 feeder
      .feed(regionFeeder)
      //region.csv里title含有provinceId和cityId,所以请求中直接引用${cityId}/${provinceId}
      .exec(http("county_map").get("/region/countties/map?mType=${type}&cityId=${cityId}&provinceId=${provinceId}"))
  //声明scenario name=dynamic_test
  val scn = scenario("dynamic_test")
          .exec(during(180){ regionRequest
          })
  //在2秒内平滑启动150个线程(具体多少秒启动多少线程大家自己评估哈,我这里瞎写的)
  setUp(scn.inject(rampUsers(150) over (2 seconds)).protocols(httpConf))
  }
  

  注意：通过下面的代码只会第一次调用生成一个随机数，后面调用不变

  exec(http("Random id browse")
          .get("/articles/" + scala.util.Random.nextInt(100))
          .check(status.is(200))
  

  Gatling 的官方文档解释是，由于 DSL 会预编译，在整个执行过程中是静态的。因此 Random 在运行过程中就已经静态化了，不会再执行。应改为 Feeder 实现，Feeder 是 gatling 用于实现注入动态参数或变量的，改用 Feeder 实现:

  val randomIdFeeder = 
      Iterator.continually(Map("id" -> 
          (scala.util.Random.nextInt(100))))
  
  feed(randomIdFeeder)
      .exec(http("Random id browse")
          .get("/articles/${id}"))
          .check(status.is(200))
  

  feed()在每次执行时都会从Iterator[Map[String, T]]对象中取出一个值，这样才能实现动态参数的需求。