JMeter can simulate users hitting web servers over HTTP or HTTPS, testing websites or web apps built with
any tech stack—Java, NodeJS, PHP, ASP.NET, etc. It measures response times, throughput, and stability
under load.
e.g. To test a public website like https://www.example.com
we can add an HTTP Request Sampler in JMeter, set protocol to https,
domain to www.example.com, and method to GET. Add a thread group with 50 users and a summary report
listener. We then get to see how the site handles 50 simultaneous visitors e.g., average response time
might be 200 ms, with a throughput of 10 reqs/ sec. This could be used for an e-commerce site
(PHP-based) to test checkout performance during a sale.
JMeter tests web services — SOAP (XML-based) or REST (often JSON-based) by sending requests to APIs and
validating responses which is suitable for microservices or backend systems.
e.g. To test a REST API like https://jsonplaceholder.typicode.com/posts/1
we add a HTTP request sampler, set method to GET, path to /posts/1, and add an assertion to check for "userId": 1 in the JSON response. We run with say 20 threads and
confirm the API returns the right data under load e.g., 20 requests in 1 second with no errors.
This could be used on a payment gateway (SOAP-based) to ensure transaction APIs don't timeout.
JMeter tests File Transfer Protocol (FTP) servers by simulating file uploads/downloads, checking speed
and reliability.
e.g. To test an FTP server like ftp.dlptest.com
we add an FTP request sampler, set server to ftp.dlptest.com,
populate the username/ password, set file to get as testfile.txt.
Lets run with say 10 users. We then get to measure the download time e.g., 10 users able to fetch a
1MB file in ~2 seconds each. This could be used with a cloud storage provider to verify their FTP upload
performance.
JMeter tests database performance by sending SQL queries via JDBC (Java Database Connectivity), which is
useful for checking query speed or connection pooling under load.
e.g. To test a local MySQL database we add a JDBC connection configuration by setting the
database URL to jdbc:mysql://localhost:3306/mydb, driver to com.mysql.jdbc.Driver, and user credentials. Add
a JDBC request sampler with SELECT * FROM users LIMIT 10 and then
run with 25 threads. We are then able to track the response time e.g., 25 ms average for 25 concurrent
queries. This could be used on an ERP system to test database scalability during peak usage.
JMeter tests Lightweight Directory Access Protocol (LDAP) servers used for directory services like
Active Directory by simulating user lookups or authentication requests.
e.g. To test a public LDAP server (ldap.forumsys.com), we
add an LDAP request sampler, set server to ldap.forumsys.com, port
to 389, base DN to dc=example,dc=com, and search filter to (uid=einstein). Lets run with say 5 users and verify the lookup speed
e.g., 5 ms per authentication request. This could be used on a corporate IT system to test employee
login performance.
10 abilities of JMeter to load and performance test.
Message-Oriented Middleware (MOM) via JMSJMeter tests messaging systems (e.g., RabbitMQ, ActiveMQ) using Java Message Service (JMS), sending and
receiving messages to check queue performance.
e.g. To test a local ActiveMQ instance we add a JMS publisher sampler and configure JNDI
properties (e.g., java.naming.factory.initial to
ActiveMQ's class), queue to TEST.QUEUE, and message to "Hello". We can run with say 10 threads and measure the message
delivery e.g., 100 messages sent in 1 second. This could be used on a banking app to test transaction
queuing during high demand.
JMeter tests email servers by sending emails (SMTP) or retrieving them (POP3/ IMAP), checking latency or
reliability.
e.g. To test say Gmail's SMTP we add a mail sender sampler (SMTP) and set server to smtp.gmail.com, port to 587,
enable TLS, and use any Gmail credentials. We sent a test email to oneselves with say 5 threads and
track send time e.g., 5 emails sent in ~300 ms each. This can be used on an email marketing platform
testing bulk email delivery.
JMeter runs OS commands or scripts (e.g., bash, PowerShell) to test system-level performance or integrate
with non-standard apps.
e.g.To test a local script we add an OS process sampler and set command to dir (Windows) or ls (Unix), and
run with say 10 threads which would execute the commands concurrently e.g., 10 dir outputs in < 1 second. This can be used by a DevOps team testing a
deployment script's speed.
JMeter tests raw TCP connections, by sending data to servers that don't use higher-level
protocols like HTTP, which can be useful for custom apps.
e.g. To test a simple TCP server (e.g., a local echo server) we can add a TCP sampler
and set server to localhost, port to
12345 (assuming a test server), and
text to send as "Ping" and run with say 15 threads and
checks the response which could be, 15 "Pong" replies in ~50 ms total. This can be used on
a chat app to test socket performance.
JMeter tests Java-based applications directly by invoking their methods,
ideal for in-house software with exposed Java classes.
e.g. To test a custom Java class we can add a Java request sampler and point it to a
compiled class (e.g., a HelloWorld class with a sayHello() method returning "Hi").
Lets run with say 10 threads and measure execution
e.g., 10 calls return "Hi" in 20
ms total. This can be used by a Java dev team to test a library's performance
pre-deployment.