如何在JMeter中自动生成批量API请求的唯一随机值？

Absolutely! You can ditch the manual RunSwift + JSONLint workflow entirely—JMeter has built-in tools and scripting capabilities to automatically generate unique, random values for your bulk API request bodies. Here's a step-by-step guide to set this up:

1. Choose Your Unique Value Generators #

JMeter comes with built-in functions to create unique identifiers, and you can combine them with scripting for full control:

• External Key: Use the ${__UUID()} function to generate universally unique identifiers (UUIDs)—these are guaranteed to be unique across systems, so perfect for external keys.
• Unique Email: Combine a random string with a domain. Options include:
  • Random prefix + fixed domain: ${__RandomString(10,abcdefghijklmnopqrstuvwxyz0123456789)}@your-test-domain.com
  • Counter-based (100% unique): test-user-${__counter(TRUE,)}@your-test-domain.com (the TRUE resets the counter per thread group)
• Unique Phone Number: Use a fixed country code + random/sequential digits:
  • Random number: +1${__RandomNumber(2000000000,9999999999)} (avoids leading zeros for valid numbers)
  • Counter-based: +1555${__counter(TRUE,)} (great for predictable, unique sequences)

2. Dynamically Build Your Bulk Request Body #

Instead of writing static JSON, use a JSR223 PreProcessor to generate your bulk array automatically:

1. Add a JSR223 PreProcessor as a child of your HTTP Request.
2. Select groovy as the language (it's faster and more flexible than other options).
3. Paste this script (tweak values to match your API schema and desired batch size):

// Define how many entries you want in the bulk request
def batchSize = 15

// Initialize an empty list to hold our request entries
def bulkEntries = []

for (int i = 0; i < batchSize; i++) {
    // Generate unique values for each field
    def externalKey = UUID.randomUUID().toString()
    def email = "user-${UUID.randomUUID().toString().take(8)}@test-domain.com"
    def phone = "+1${new Random().nextInt(899999999) + 100000000}" // Generates 9-digit number after +1

    // Create the entry object matching your API's structure
    def entry = [
        "external_key": externalKey,
        "email": email,
        "phone": phone
        // Add other required fields here
    ]

    bulkEntries.add(entry)
}

// Convert the list to a pretty-printed JSON string and store it in a variable
def jsonBuilder = new groovy.json.JsonBuilder(bulkEntries)
vars.put("bulkRequestBody", jsonBuilder.toPrettyString())

4. In your HTTP Request's Body Data field, just reference the variable: ${bulkRequestBody}

3. Verify Uniqueness (Optional but Recommended) #

To ensure all values are unique, add a JSR223 PostProcessor to check the generated request body:

def requestBody = vars.get("bulkRequestBody")
def entries = new groovy.json.JsonSlurper().parseText(requestBody)

// Check for duplicate external keys
def externalKeys = entries.collect { it.external_key }
assert externalKeys.unique().size() == externalKeys.size() : "Duplicate external keys found!"

// Check for duplicate emails
def emails = entries.collect { it.email }
assert emails.unique().size() == emails.size() : "Duplicate emails found!"

// Check for duplicate phone numbers
def phones = entries.collect { it.phone }
assert phones.unique().size() == phones.size() : "Duplicate phone numbers found!"

This will throw an error if any duplicates slip through, helping you catch issues early.

Bonus Tips #

• Use User Defined Variables to store reusable values like batchSize, emailDomain, or phoneCountryCode—makes it easy to adjust settings without editing scripts.
• If your API requires specific formatting (e.g., phone numbers with hyphens), modify the Groovy script to format the string before adding it to the entry.

This setup eliminates all manual steps: no more generating code in RunSwift, no more fixing JSON formatting in external tools. Just run your JMeter test, and it will generate a valid, unique bulk request every time.

内容的提问来源于stack exchange，提问作者mani9697