概念：
Session is a virtual user’s state.
格式：
Map[String, Any]
存入数据
- 通过 Feeders
- 从响应中提取数据并保存（如 http check 中的 saveAs）
- 通过 Session API 手动注入
示例：todo
feed(feeder)
取得数据
- 通过 Expression Language 取得
- 通过 Session API 手动取得
示例：todo
"${attributeName}"
Session API
设置数据：
// set(key: String, value: Any): Session 单个插入
val scn = scenario("scn").during(30 seconds) {
// 正确的用法
exec(session => {
session.set("a", "1")
.set("b", "2")
.set("c", "3")
.set("d", "4")
.set("e", "5")
})
// 错误的用法
exec(session => {
session.set("a", "1")
session.set("b", "2")
session.set("c", "3")
session.set("d", "4")
session.set("e", "5") // 上面的都会被丢弃掉
}),
}
// setAll(newAttributes: (String, Any)*): Session 接收可变参数
val scn = scenario("scn").during(30 seconds) {
exec(session => {
session.setAll(("a", "1"), ("b", "2"), ("c", "3"), ("d", "4"), ("e", "5"))
})
}
// setAll(newAttributes: Iterable[(String, Any)]): Session 接收一个可迭代对象
val scn = scenario("scn").during(30 seconds) {
exec(session => {
session.setAll(Array(("a", "1"), ("b", "2"), ("c", "3"), ("d", "4"), ("e", "5")))
})
}
// reset 重置
// reset all attributes but loop counters, timestamps and Gatling internals (baseUrl, caches, etc)
val scn = scenario("scn").during(30 seconds) {
exec(session => {
session..reset
})
}
使用数据：
val scn = scenario("scn").during(30 seconds) {
exec(session => {
session.setAll(("a", "1"), ("b", "2"), ("c", "3"), ("d", "4"), ("e", "5"))
}).exec(session => { // 注意：设置的Session数据需要在同一个链式调用下使用
println(session)
session
})
// 这里就取不到数据，是不同的Session
exec(session => {
println(session)
session
})
}
session.set("foo", "FOO")
// 注意：session("foo")并不是foo的值，而是一个wrapper（包装）
val attribute: SessionAttribute = session("foo")
val scn = scenario("scn").during(30 seconds) {
exec(session => {
session.set("a", 1)
}).exec(session => {
// IDE里面这样写会报错，其实是没错的，不要理它
val a1: Int = session("a").as[Int] // 也可能出现：NoSuchElementException || NumberFormatException || ClassCastException
val a2: Option[Int] = session("a").asOption[Int] // 也可能出现：NumberFormatException || ClassCastException
val a3: Validation[Int] = session("a").validate[Int]
println(a1)
a2 match {
case Some(value) => {
println(value)
}
case None => {
println("None")
}
}
a3 match {
case Success(value) => {
println(value)
}
case Failure(errorMessage) => {
println(errorMessage)
}
}
session
})
}
Expression Language
request("page").get("/foo?${bar}")
"${foo.size()}" // returns the size of `foo` if `foo` points to a Scala or Java collection attribute
"${foo.random()}" // returns a random element of `foo` if `foo` points to an indexed collection
"${foo.exists()}" // returns true if the session contains a `foo` attribute, false otherwise
"${foo.isUndefined()}" // returns true if the session doesn't contains a `foo` attribute, false otherwise
"${foo(5)}" // returns the 5th element of `foo` if `foo` points to an indexed collection
"${foo(n)}" // returns the n-th element of `foo` if `n` points to an Int and `foo` to an indexed collection or a Tuple
"${foo.bar}" // returns the value associated with key `bar` if `foo` points to a map
"${foo._2}" // returns the second element if `foo` points to a Tuple object (identical to idiomatic Scala Tuple syntax, 1 based index)
"${foo.jsonStringify()}" // properly formats into a JSON value (wrap Strings with double quotes, deal with null)
"${foo(0)(0)}" // List[List[T]]
"${foo.list.random()}" // List[List[T]]
// 转义前
"$${foo} $$${foo}"
// 转义后
"${foo} $FOO"
Validation（验证）
Validation[T] has a type parameter T that is the type of the value in case of a success.
- Success[T](value: T) that wraps a value in case of a success
- Failure(message: String) that wraps a String error message
// 创建实例的方法
val foo: Validation[String] = Success("foo")
val bar: Validation[String] = Failure("errorMessage")
// 或者
val foo: Validation[String] = "foo".success
val bar: Validation[String] = "errorMessage".failure
// Validation支持match匹配
def display(v: Validation[String]) = v match {
case Success(string) => println("success: " + string)
case Failure(error) => println("failure: " + error)
}
// map与flatMap
// map用于连接一个不会失败的操作，因此返回一个原始值
val foo = Success(1)
val bar = foo.map(value => value + 2)
// flatMap用于连接可能失败的操作，因此返回一个Validation
val foo = Success("foo")
val bar = foo.flatMap(value => Success("bar"))
val baz = foo.flatMap(value => Failure("error"))
// 在以上两种情况下，如果原始Validation失败，则不会调用链式函数