Tomcat性能测试脚本开发：JMeter Groovy脚本实战-优快云博客

Tomcat性能测试脚本开发：JMeter Groovy脚本实战

【免费下载链接】tomcat Tomcat是一个开源的Web服务器，主要用于部署Java Web应用程序。它的特点是易用性高、稳定性好、兼容性广等。适用于Java Web应用程序部署场景。项目地址: https://gitcode.com/gh_mirrors/tom/tomcat

引言：Tomcat性能测试的挑战与解决方案

在高并发场景下，Tomcat服务器的性能表现直接影响用户体验。传统的压力测试工具往往难以模拟复杂的业务逻辑和真实的用户行为，导致测试结果与实际运行情况存在偏差。JMeter作为一款功能强大的开源性能测试工具，结合Groovy脚本语言，可以灵活地构建复杂的测试场景，精准评估Tomcat服务器的性能瓶颈。本文将详细介绍如何使用JMeter和Groovy开发高效的Tomcat性能测试脚本，帮助开发人员和测试工程师全面掌握性能测试的关键技术和最佳实践。

一、JMeter与Groovy基础

1.1 JMeter简介

JMeter（Apache JMeter）是一款由Apache软件基金会开发的开源性能测试工具，最初用于Web应用测试，后来扩展到其他测试领域。它可以模拟多种协议的请求，如HTTP、HTTPS、FTP、JDBC等，并提供丰富的测试报告和分析功能。

1.2 Groovy简介

Groovy是一种基于JVM（Java虚拟机）的敏捷开发语言，它结合了Python、Ruby和Smalltalk的许多强大特性，同时保留了Java的语法和兼容性。在JMeter中，Groovy脚本可以用于编写自定义的逻辑控制器、前置处理器、后置处理器等，实现复杂的测试场景。

1.3 JMeter与Groovy的结合优势

灵活性高：Groovy脚本可以轻松实现复杂的业务逻辑，如条件判断、循环、数据处理等。
性能优异：Groovy脚本在JVM上运行，执行效率高，适合高并发的性能测试场景。
Java兼容性：Groovy可以直接调用Java类和方法，充分利用Java生态系统的丰富资源。
易于维护：Groovy语法简洁明了，代码可读性强，便于脚本的维护和扩展。

二、Tomcat性能测试环境搭建

2.1 环境准备

软件名称	版本要求	用途
JDK	1.8及以上	运行JMeter和Tomcat
Tomcat	8.5或9.0	被测试的Web服务器
JMeter	5.0及以上	性能测试工具
Groovy	2.5及以上	脚本语言

2.2 Tomcat安装与配置

下载Tomcat安装包：从官方网站下载Tomcat 8.5或9.0版本的二进制分发版。
解压安装包：将下载的安装包解压到指定目录，如/opt/tomcat。
配置环境变量：设置CATALINA_HOME环境变量，指向Tomcat的安装目录。
修改配置文件：根据测试需求，调整conf/server.xml中的连接器配置，如端口号、线程池大小等。

<!-- conf/server.xml中的Connector配置示例 -->
<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443"
           maxThreads="200"
           minSpareThreads="25"
           maxSpareThreads="75"
           acceptCount="100"/>

2.3 JMeter安装与配置

下载JMeter安装包：从Apache JMeter官方网站下载最新版本的二进制分发版。
解压安装包：将安装包解压到指定目录，如/opt/jmeter。
配置环境变量：设置JMETER_HOME环境变量，指向JMeter的安装目录。
安装Groovy插件：启动JMeter，通过"Options" -> "Plugins Manager"安装"Groovy"插件，以便支持Groovy脚本。

三、JMeter测试计划设计

3.1 测试计划结构

一个完整的JMeter测试计划通常包含以下组件：

mermaid

线程组：模拟并发用户，设置线程数、循环次数、 ramp-up时间等。
配置元件：提供测试所需的配置信息，如HTTP请求默认值、Cookie管理器等。
前置处理器：在发送请求前执行的操作，如参数化、数据准备等。
取样器：发送测试请求，如HTTP请求、JDBC请求等。
后置处理器：在接收响应后执行的操作，如提取响应数据、计算响应时间等。
断言：验证响应结果是否符合预期。
监听器：收集和展示测试结果，如查看结果树、聚合报告、图形结果等。

3.2 线程组配置

线程组是JMeter测试计划的核心组件，用于模拟并发用户。以下是一个典型的线程组配置示例：

线程数：100（模拟100个并发用户）
Ramp-Up时间：60秒（在60秒内逐渐启动所有线程）
循环次数：10（每个线程循环发送10次请求）
持续时间：300秒（测试总持续时间为300秒）

四、Groovy脚本在JMeter中的应用

4.1 JMeter中的Groovy脚本组件

JMeter提供了多个支持Groovy脚本的组件，主要包括：

JSR223前置处理器：在发送请求前执行Groovy脚本。
JSR223后置处理器：在接收响应后执行Groovy脚本。
JSR223断言：使用Groovy脚本进行响应结果验证。
JSR223定时器：通过Groovy脚本控制请求发送的时间间隔。
JSR223取样器：完全通过Groovy脚本发送自定义请求。

4.2 Groovy脚本基础语法

4.2.1 变量定义与使用

// 定义字符串变量
def username = "testuser"
// 定义整数变量
def userId = 12345
// 定义数组
def products = ["product1", "product2", "product3"]
// 定义Map
def userInfo = [name: "张三", age: 25, email: "zhangsan@example.com"]

// 使用变量
log.info("用户名：${username}")
log.info("用户ID：${userId}")
log.info("产品列表：${products.join(', ')}")
log.info("用户邮箱：${userInfo.email}")

4.2.2 条件判断与循环

// 条件判断
def score = 85
if (score >= 90) {
    log.info("优秀")
} else if (score >= 80) {
    log.info("良好")
} else if (score >= 60) {
    log.info("及格")
} else {
    log.info("不及格")
}

// for循环
for (int i = 0; i < 5; i++) {
    log.info("循环次数：${i}")
}

// 增强for循环
products.each { product ->
    log.info("产品名称：${product}")
}

// while循环
def count = 0
while (count < 3) {
    log.info("计数：${count}")
    count++
}

4.2.3 函数定义与调用

// 定义无参数函数
def getCurrentTime() {
    return new Date().toString()
}

// 定义带参数函数
def calculateSum(int a, int b) {
    return a + b
}

// 调用函数
log.info("当前时间：${getCurrentTime()}")
def sum = calculateSum(10, 20)
log.info("求和结果：${sum}")

4.3 JMeter上下文与变量操作

在Groovy脚本中，可以通过vars对象操作JMeter变量，通过props对象操作JMeter属性。

// 设置JMeter变量
vars.put("username", "testuser")
vars.put("userId", "12345")

// 获取JMeter变量
def username = vars.get("username")
def userId = vars.get("userId")
log.info("用户名：${username}，用户ID：${userId}")

// 设置JMeter属性
props.put("test.env", "production")

// 获取JMeter属性
def testEnv = props.get("test.env")
log.info("测试环境：${testEnv}")

// 使用JMeter内置函数
def randomNum = org.apache.jmeter.functions.RandomString.getString(8)
vars.put("randomStr", randomNum)
log.info("随机字符串：${randomNum}")

五、Tomcat性能测试脚本实战

5.1 测试场景设计

本文以一个典型的电子商务网站为例，设计以下测试场景：

首页访问测试：模拟用户访问网站首页，测试Tomcat对静态资源的处理能力。
用户登录测试：模拟用户登录过程，测试Tomcat对动态请求的处理能力。
商品列表查询测试：模拟用户查询商品列表，测试数据库交互性能。
购物车操作测试：模拟用户添加商品到购物车、修改购物车商品数量等操作，测试会话管理和业务逻辑处理性能。
订单提交测试：模拟用户提交订单，测试事务处理和并发控制性能。

5.2 首页访问测试脚本

5.2.1 HTTP请求配置

服务器名称/IP：localhost
端口号：8080
协议：HTTP
方法：GET
路径：/

5.2.2 前置处理器：设置请求头

使用JSR223前置处理器设置User-Agent请求头，模拟不同浏览器的访问。

// 定义User-Agent列表
def userAgents = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.1 Safari/605.1.15",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0"
]

// 随机选择一个User-Agent
def randomIndex = new Random().nextInt(userAgents.size())
def userAgent = userAgents[randomIndex]

// 设置请求头
sampler.getHeaderManager().add(new org.apache.jmeter.protocol.http.control.Header("User-Agent", userAgent))
log.info("设置User-Agent：${userAgent}")

5.2.3 后置处理器：提取响应时间

使用JSR223后置处理器提取响应时间，并保存到JMeter变量中。

// 获取响应时间（毫秒）
def responseTime = prev.getTime()
vars.put("responseTime", responseTime.toString())

// 判断响应时间是否超过阈值
def threshold = 500 // 阈值为500毫秒
if (responseTime > threshold) {
    log.warn("响应时间过长：${responseTime}毫秒")
    vars.put("responseStatus", "slow")
} else {
    vars.put("responseStatus", "normal")
}

5.2.4 断言：验证响应内容

使用JSR223断言验证响应中是否包含预期的关键字。

// 获取响应文本
def responseText = prev.getResponseDataAsString()

// 验证响应中是否包含"欢迎来到XXX商城"
if (!responseText.contains("欢迎来到XXX商城")) {
    AssertionResult.setFailure(true)
    AssertionResult.setFailureMessage("响应内容不包含预期关键字")
}

// 验证响应状态码是否为200
def statusCode = prev.getResponseCode()
if (statusCode != "200") {
    AssertionResult.setFailure(true)
    AssertionResult.setFailureMessage("响应状态码错误，预期200，实际${statusCode}")
}

5.3 用户登录测试脚本

5.3.1 HTTP请求配置

服务器名称/IP：localhost
端口号：8080
协议：HTTP
方法：POST
路径：/login
参数：username=${username}&password=${password}

5.3.2 前置处理器：生成随机用户凭证

使用JSR223前置处理器从用户列表中随机选择一个用户进行登录。

// 定义用户列表
def users = [
    [username: "user1", password: "pass1"],
    [username: "user2", password: "pass2"],
    [username: "user3", password: "pass3"],
    [username: "user4", password: "pass4"],
    [username: "user5", password: "pass5"]
]

// 随机选择一个用户
def randomIndex = new Random().nextInt(users.size())
def selectedUser = users[randomIndex]

// 设置用户名和密码变量
vars.put("username", selectedUser.username)
vars.put("password", selectedUser.password)
log.info("选择用户：${selectedUser.username}")

5.3.3 后置处理器：提取登录令牌

使用JSR223后置处理器从响应中提取登录令牌（如JSESSIONID）。

// 获取响应头中的Set-Cookie
def cookies = prev.getResponseHeaders().getHeader("Set-Cookie")

// 提取JSESSIONID
def jsessionid = ""
if (cookies != null) {
    def matcher = (cookies =~ /JSESSIONID=([^;]+)/)
    if (matcher.find()) {
        jsessionid = matcher.group(1)
        vars.put("JSESSIONID", jsessionid)
        log.info("提取到JSESSIONID：${jsessionid}")
    } else {
        log.error("未找到JSESSIONID")
        vars.put("loginStatus", "failed")
    }
} else {
    log.error("响应头中没有Set-Cookie")
    vars.put("loginStatus", "failed")
}

// 验证登录是否成功
def responseText = prev.getResponseDataAsString()
if (responseText.contains("登录成功")) {
    vars.put("loginStatus", "success")
} else {
    vars.put("loginStatus", "failed")
    log.error("登录失败，响应内容：${responseText}")
}

5.4 商品列表查询测试脚本

5.4.1 HTTP请求配置

服务器名称/IP：localhost
端口号：8080
协议：HTTP
方法：GET
路径：/products
参数：category=${category}&page=${page}&size=${size}

5.4.2 前置处理器：随机生成查询参数

// 定义商品分类
def categories = ["electronics", "clothing", "books", "home", "sports"]

// 随机选择分类
def randomCategory = categories[new Random().nextInt(categories.size())]
vars.put("category", randomCategory)

// 随机生成页码（1-10）
def randomPage = new Random().nextInt(10) + 1
vars.put("page", randomPage.toString())

// 设置每页大小
vars.put("size", "20")

log.info("查询参数：分类=${randomCategory}，页码=${randomPage}，每页大小=20")

5.4.3 后置处理器：解析JSON响应

使用Groovy的JsonSlurper解析JSON格式的响应数据。

import groovy.json.JsonSlurper

// 获取响应文本
def responseText = prev.getResponseDataAsString()

try {
    // 解析JSON
    def jsonSlurper = new JsonSlurper()
    def responseData = jsonSlurper.parseText(responseText)

    // 提取总记录数和总页数
    def totalItems = responseData.totalItems
    def totalPages = responseData.totalPages
    vars.put("totalItems", totalItems.toString())
    vars.put("totalPages", totalPages.toString())

    // 验证当前页数据数量
    def currentItems = responseData.items.size()
    if (currentItems <= 0) {
        log.warn("当前页没有数据")
    } else {
        log.info("当前页数据数量：${currentItems}，总记录数：${totalItems}")
    }

    // 保存第一个商品ID
    if (currentItems > 0) {
        vars.put("firstProductId", responseData.items[0].id)
    }
} catch (Exception e) {
    log.error("解析JSON响应失败：${e.getMessage()}")
    vars.put("jsonParseStatus", "error")
}

5.5 购物车操作测试脚本

5.5.1 添加商品到购物车

HTTP请求配置：

方法：POST
路径：/cart/add
参数：productId=${productId}&quantity=${quantity}

前置处理器：

// 从商品列表查询结果中获取商品ID
def productId = vars.get("firstProductId")
if (productId == null || productId.isEmpty()) {
    // 如果没有商品ID，则随机生成一个
    productId = new Random().nextInt(1000) + 100
    log.warn("使用随机商品ID：${productId}")
}
vars.put("productId", productId.toString())

// 随机生成购买数量（1-5）
def quantity = new Random().nextInt(5) + 1
vars.put("quantity", quantity.toString())

log.info("添加商品到购物车：商品ID=${productId}，数量=${quantity}")

5.5.2 修改购物车商品数量

HTTP请求配置：

方法：POST
路径：/cart/update
参数：cartItemId=${cartItemId}&quantity=${newQuantity}

前置处理器：

// 假设从之前的响应中获取了购物车项ID
def cartItemId = vars.get("cartItemId")
if (cartItemId == null || cartItemId.isEmpty()) {
    log.error("购物车项ID不存在，无法更新数量")
    // 设置一个标志，用于跳过当前请求
    vars.put("skipRequest", "true")
} else {
    vars.put("skipRequest", "false")
    // 随机生成新的数量（1-10）
    def newQuantity = new Random().nextInt(10) + 1
    vars.put("newQuantity", newQuantity.toString())
    log.info("更新购物车商品数量：购物车项ID=${cartItemId}，新数量=${newQuantity}")
}

JSR223条件控制器：

// 如果skipRequest为true，则跳过当前请求
return vars.get("skipRequest") != "true"

六、测试结果分析与报告生成

6.1 JMeter监听器配置

为了全面收集测试数据，需要配置以下JMeter监听器：

聚合报告：展示请求的平均响应时间、吞吐量、错误率等关键指标。
查看结果树：详细显示每个请求的请求和响应数据，便于问题排查。
图形结果：以图表形式展示响应时间随时间的变化趋势。
Summary Report：汇总请求的响应时间、吞吐量等统计信息。
响应时间分布图：展示响应时间的分布情况，帮助识别性能瓶颈。
JSR223 Listener：使用Groovy脚本自定义收集测试数据。

6.2 自定义测试报告生成

使用JMeter的JSR223监听器和Groovy脚本，可以将测试数据写入CSV文件，以便后续分析。

import java.io.FileWriter
import java.io.BufferedWriter

// 测试数据CSV文件路径
def csvFilePath = "${__property(user.dir)}/test_results.csv"

// 测试数据
def testCase = vars.get("testCase") ?: "unknown"
def timestamp = new Date().format("yyyy-MM-dd HH:mm:ss")
def responseTime = vars.get("responseTime") ?: "0"
def responseStatus = vars.get("responseStatus") ?: "unknown"
def loginStatus = vars.get("loginStatus") ?: "unknown"
def totalItems = vars.get("totalItems") ?: "0"

// 写入CSV文件
try {
    def fileExists = new File(csvFilePath).exists()
    def writer = new BufferedWriter(new FileWriter(csvFilePath, true))
    
    // 如果文件不存在，写入表头
    if (!fileExists) {
        writer.write("timestamp,testCase,responseTime,responseStatus,loginStatus,totalItems\n")
    }
    
    // 写入测试数据
    writer.write("${timestamp},${testCase},${responseTime},${responseStatus},${loginStatus},${totalItems}\n")
    writer.close()
} catch (Exception e) {
    log.error("写入测试结果到CSV文件失败：${e.getMessage()}")
}

6.3 关键性能指标分析

Tomcat性能测试的关键指标包括：

响应时间：平均响应时间、90%响应时间、95%响应时间、最大响应时间。
吞吐量：每秒处理的请求数（RPS）。
错误率：请求失败的百分比。
并发用户数：同时发送请求的用户数量。
CPU利用率：Tomcat服务器的CPU使用率。
内存使用率：Tomcat服务器的内存使用情况。
数据库连接数：Tomcat与数据库的连接数量。

通过分析这些指标，可以识别Tomcat的性能瓶颈，如：

如果响应时间过长而CPU利用率不高，可能是数据库查询效率低下。
如果吞吐量达到瓶颈且CPU利用率接近100%，可能是Tomcat线程池配置不足。
如果错误率随并发用户数增加而上升，可能是资源竞争或线程安全问题。

6.4 Tomcat性能优化建议

根据测试结果，可以采取以下优化措施：

调整线程池配置：根据CPU核心数和内存大小，优化server.xml中的线程池参数。

<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443"
           maxThreads="500"        <!-- 增加最大线程数 -->
           minSpareThreads="50"    <!-- 增加最小空闲线程数 -->
           maxSpareThreads="200"   <!-- 调整最大空闲线程数 -->
           acceptCount="200"       <!-- 调整请求队列大小 -->
           enableLookups="false"   <!-- 禁用DNS查询 -->
           compression="on"        <!-- 启用压缩 -->
           compressableMimeType="text/html,text/xml,text/css,application/javascript"/>

优化JVM参数：调整Tomcat的JVM内存配置，提高内存使用效率。

# 在catalina.sh中设置JVM参数
JAVA_OPTS="-Xms2g -Xmx4g -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -XX:+HeapDumpOnOutOfMemoryError"

启用Tomcat APR库：使用APR（Apache Portable Runtime）库提高I/O性能。
配置静态资源缓存：通过web.xml配置静态资源的缓存策略。

<filter>
    <filter-name>ExpiresFilter</filter-name>
    <filter-class>org.apache.catalina.filters.ExpiresFilter</filter-class>
    <init-param>
        <param-name>ExpiresByType text/css</param-name>
        <param-value>access plus 1 day</param-value>
    </init-param>
    <init-param>
        <param-name>ExpiresByType application/javascript</param-name>
        <param-value>access plus 1 day</param-value>
    </init-param>
    <init-param>
        <param-name>ExpiresByType image/jpeg</param-name>
        <param-value>access plus 7 days</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>ExpiresFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

数据库连接池优化：调整数据库连接池的大小和超时时间，避免连接泄漏。

七、高级技术与最佳实践

7.1 分布式性能测试

当单台JMeter服务器无法模拟足够的并发用户时，可以采用分布式测试架构：

配置JMeter主从节点：
- 主节点（Controller）：负责分发测试计划和收集测试结果。
- 从节点（Agent）：负责执行测试计划，模拟并发用户。

启动从节点代理：

./jmeter-server -Dserver_port=1099 -Dserver.rmi.localport=1099

配置主节点：在JMeter的jmeter.properties中设置从节点地址：
```
remote_hosts=192.168.1.100:1099,192.168.1.101:1099
```
执行分布式测试：通过JMeter GUI或命令行启动分布式测试：
```
./jmeter -n -t test_plan.jmx -r -l test_results.jtl
```

7.2 性能测试最佳实践

逐步增加并发用户：从低并发开始，逐步增加用户数量，观察系统性能变化趋势。
持续运行测试：进行长时间运行的测试（如24小时），观察系统的稳定性和内存泄漏情况。
隔离测试环境：确保测试环境与生产环境一致，且不受其他应用的干扰。
保存测试计划：保存完整的测试计划，便于重复测试和版本控制。
参数化与数据驱动：使用CSV数据文件或数据库获取测试数据，避免测试数据重复。
避免过度测试：合理设置测试持续时间和并发用户数，避免对服务器造成不必要的负载。
定期执行性能测试：在系统升级或优化后，重新执行性能测试，验证优化效果。

八、总结与展望

本文详细介绍了使用JMeter和Groovy开发Tomcat性能测试脚本的全过程，包括环境搭建、脚本开发、测试执行和结果分析。通过灵活运用Groovy脚本，可以模拟复杂的业务场景，精准评估Tomcat服务器的性能表现。同时，本文提供的最佳实践和优化建议，可以帮助开发人员和测试工程师提升性能测试的效率和准确性。

随着云计算和微服务架构的普及，未来的性能测试将面临更多的挑战和机遇。JMeter和Groovy的结合将在云原生应用测试、服务网格性能测试等领域发挥更大的作用。建议持续关注JMeter和Groovy的最新特性，不断提升性能测试的技术水平，为构建高性能的Tomcat应用提供有力保障。

附录：常用JMeter Groovy脚本片段

A.1 随机数据生成

// 生成随机字符串
def randomString = org.apache.commons.text.RandomStringGenerator.builder()
    .withinRange('a' as char, 'z' as char)
    .build()
    .generate(10)
vars.put("randomString", randomString)

// 生成随机邮箱
def domains = ["example.com", "test.com", "demo.com"]
def randomDomain = domains[new Random().nextInt(domains.size())]
def randomEmail = "${randomString}@${randomDomain}"
vars.put("randomEmail", randomEmail)

// 生成随机日期
def startDate = new Date(2020, 0, 1) // 2020-01-01
def endDate = new Date() // 当前日期
def randomDate = new Date(startDate.getTime() + new Random().nextInt((int)(endDate.getTime() - startDate.getTime())))
vars.put("randomDate", randomDate.format("yyyy-MM-dd"))

A.2 JSON数据处理

import groovy.json.JsonSlurper
import groovy.json.JsonBuilder

// 解析JSON
def jsonSlurper = new JsonSlurper()
def jsonData = jsonSlurper.parseText(vars.get("responseData"))

// 修改JSON数据
jsonData.user.name = "newName"
jsonData.user.age = 30
jsonData.enabled = true

// 生成JSON字符串
def jsonBuilder = new JsonBuilder(jsonData)
def updatedJson = jsonBuilder.toPrettyString()
vars.put("updatedJson", updatedJson)

A.3 文件操作

// 读取文件内容
def filePath = "${__property(user.dir)}/data/testdata.txt"
def fileContent = new File(filePath).text
vars.put("fileContent", fileContent)

// 写入文件
def outputPath = "${__property(user.dir)}/output/result.txt"
new File(outputPath).parentFile.mkdirs() // 创建父目录
new File(outputPath).text = "测试结果：${vars.get("responseTime")}毫秒"

// 追加文件内容
def appendContent = "新的测试结果：${new Date().toString()}\n"
new File(outputPath).append(appendContent)

A.4 时间戳与日期处理

// 获取当前时间戳（毫秒）
def timestamp = System.currentTimeMillis()
vars.put("timestamp", timestamp.toString())

// 获取当前日期时间
def currentDateTime = new Date().format("yyyy-MM-dd HH:mm:ss")
vars.put("currentDateTime", currentDateTime)

// 计算时间差
def startTime = vars.get("startTime") as Long
def endTime = System.currentTimeMillis()
def duration = (endTime - startTime) / 1000 // 秒
vars.put("duration", duration.toString())

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考