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

脚本示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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配置即可

    1
    2
    //设置请求的根路径
    val httpConf = http.baseURL("https://www.baidu.com")

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

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

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

  3. 设置并发数并组装

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

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

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

高级教程

Injection – 注入

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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)：立即注入一定数量的虚拟用户

    1
    setUp(scn.inject(atOnceUsers(50)).protocols(httpConf))

  3. rampUsers(nbUsers) over(duration)：在指定时间内，设置一定数量逐步注入的虚拟用户

    1
    setUp(scn.inject(rampUsers(50) over(30 seconds)).protocols(httpConf))

  4. constantUsersPerSec(rate) during(duration)：定义一个在每秒钟恒定的并发用户数，持续指定的时间

    1
    setUp(scn.inject(constantUsersPerSec(30) during(15 seconds)).protocols(httpConf))

  5. constantUsersPerSec(rate) during(duration) randomized：定义一个在每秒钟围绕指定并发数随机增减的并发，持续指定时间

    1
    setUp(scn.inject(constantUsersPerSec(30) during(15 seconds) randomized).protocols(httpConf))

  6. rampUsersPerSec(rate1) to (rate2) during(duration)：定义一个并发数区间，运行指定时间，并发增长的周期是一个规律的值

    1
    setUp(scn.inject(rampUsersPerSec(30) to (50) during(15 seconds)).protocols(httpConf))

  7. rampUsersPerSec(rate1) to(rate2) during(duration) randomized：定义一个并发数区间，运行指定时间，并发增长的周期是一个随机的值

    1
    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。实际操作时，并发数是一个成平滑抛物线形的曲线）

    1
    setUp(scn.inject(heavisideUsers(50) over(15 seconds)).protocols(httpConf))

  9. splitUsers(nbUsers) into(injectionStep) separatedBy(duration)：定义一个周期，执行injectionStep里面的注入，将nbUsers的请求平均分配

    1
    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

    1
    setUp(scn.inject(splitUsers(100) into(rampUsers(10) over(10 seconds)) separatedBy atOnceUsers(30)).protocols(httpConf))
循环
1
2
val scn = scenario("BaiduSimulation").
    exec(http("baidu_home").get("/"))

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

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

post参数提交方式：

  • JSON方式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    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(StringBody("{\"orderNo\":201519828113}")))
    setUp(scn.inject(atOnceUsers(10))).protocols(httpConf)
    }

  • Form方式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    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[供料器]，支持主要有：

  • 数组

    1
    2
    3
    4
    val feeder = Array(
    Map("foo" -> "foo1", "bar" -> "bar1"),
    Map("foo" -> "foo2", "bar" -> "bar2"),
    Map("foo" -> "foo3", "bar" -> "bar3"))

  • CSV文件

    1
    val csvFeeder = csv("foo.csv")//文件路径在 %Gatling_Home%/user-files/data/

  • JSON文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    val jsonFileFeeder = jsonFile("foo.json")
    //json的形式：
    [
    {
        "id":19434,
        "foo":1
    },
    {
        "id":19435,
        "foo":2
    }
    ]

  • JDBC数据

    1
    jdbcFeeder("databaseUrl", "username", "password", "SELECT * FROM users")

  • Redis

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

    使用示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    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))
    }

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

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

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

    1
    2
    3
    4
    5
    6
    7
    8
    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]]对象中取出一个值，这样才能实现动态参数的需求。

欢迎扫码关注公众号，更好的交流

欢迎扫码关注公众号，更好的交流