jMeter - Kurzanleitung

Bevor wir auf die Details von JMeter eingehen, lassen Sie uns zunächst einige Jargons verstehen, die mit dem Testen einer Anwendung verbunden sind.

• Performance Test- Dieser Test legt die bestmögliche Leistungserwartung unter einer bestimmten Infrastrukturkonfiguration fest. Außerdem wird zu Beginn des Testprozesses hervorgehoben, ob Änderungen vorgenommen werden müssen, bevor die Anwendung in Produktion geht.

• Load Test - Dieser Test wird im Wesentlichen zum Testen des Systems unter der Höchstlast verwendet, unter der es betrieben werden soll.

• Stress Test - Dieser Test ist ein Versuch, das System durch Überlastung seiner Ressourcen zu beschädigen.

Was ist JMeter?

JMeter ist eine Software, die Lasttests, leistungsorientierte Geschäfts- (Funktions-) Tests, Regressionstests usw. mit verschiedenen Protokollen oder Technologien durchführen kann.

Stefano Mazzocchider Apache Software Foundation war der ursprüngliche Entwickler von JMeter. Er schrieb es hauptsächlich, um die Leistung von Apache JServ (jetzt als Apache Tomcat-Projekt bezeichnet) zu testen. Apache hat JMeter später neu gestaltet, um die GUI zu verbessern und Funktionstestfunktionen hinzuzufügen.

JMeter ist eine Java-Desktopanwendung mit einer grafischen Oberfläche, die die grafische Swing-API verwendet. Es kann daher in jeder Umgebung / Workstation ausgeführt werden, die eine virtuelle Java-Maschine akzeptiert, z. B. Windows, Linux, Mac usw.

Die von JMeter unterstützten Protokolle sind -

• Web - HTTP, HTTPS-Sites 'Web 1.0' Web 2.0 (Ajax, Flex und Flex-Ws-Amf)

• Webdienste - SOAP / XML-RPC

• Datenbank über JDBC-Treiber

• Verzeichnis - LDAP

• Messaging-orientierter Dienst über JMS

• Service - POP3, IMAP, SMTP

• FTP-Dienst

JMeter-Funktionen

Im Folgenden sind einige der Funktionen von JMeter aufgeführt:

• Als Open-Source-Software ist sie frei verfügbar.

• Es hat eine einfache und intuitive GUI.

• JMeter kann Last- und Leistungstests für viele verschiedene Servertypen durchführen - Web-HTTP, HTTPS, SOAP, Datenbank über JDBC, LDAP, JMS, Mail-POP3 usw.

• Es ist ein plattformunabhängiges Tool. Unter Linux / Unix kann JMeter durch Klicken auf das JMeter-Shell-Skript aufgerufen werden. Unter Windows kann es durch Starten der Datei jmeter.bat aufgerufen werden.

• Es bietet volle Unterstützung für Swing und leichte Komponenten (vorkompilierte JAR verwendet die Pakete javax.swing. *).

• JMeter speichert seine Testpläne im XML-Format. Dies bedeutet, dass Sie mit einem Texteditor einen Testplan erstellen können.

• Das vollständige Multithreading-Framework ermöglicht die gleichzeitige Abtastung durch viele Threads und die gleichzeitige Abtastung verschiedener Funktionen durch separate Thread-Gruppen.

• Es ist sehr erweiterbar.

• Es kann auch verwendet werden, um automatisierte und funktionale Tests der Anwendungen durchzuführen.

Wie funktioniert JMeter?

JMeter simuliert eine Gruppe von Benutzern, die Anforderungen an einen Zielserver senden, und gibt Statistiken zurück, die die Leistung / Funktionalität des Zielservers / der Zielanwendung über Tabellen, Grafiken usw. anzeigen.

Schauen Sie sich die folgende Abbildung an, die zeigt, wie JMeter funktioniert -

JMeter ist ein Framework für Java. Die allererste Anforderung besteht darin, JDK auf Ihrem Computer zu installieren.

System Anforderungen

JDK	1.6 oder höher.
Erinnerung	Keine Mindestanforderung.
Festplattenplatz	Keine Mindestanforderung.
Betriebssystem	Keine Mindestanforderung.

Schritt 1: Überprüfen Sie die Java-Installation

Überprüfen Sie zunächst, ob Java auf Ihrem System installiert ist. Öffnen Sie Ihre Konsole und führen Sie einen der folgenden Schritte ausjava Befehle basierend auf dem Betriebssystem, an dem Sie arbeiten.

Betriebssystem	Aufgabe	Befehl
Windows	Öffnen Sie die Befehlskonsole	c: \> Java-Version
Linux	Öffnen Sie das Befehlsterminal	$ java -version
Mac	Terminal öffnen	Maschine: ~ Joseph $ Java-Version

Wenn Sie Java in Ihrem System installiert haben, erhalten Sie eine entsprechende Ausgabe basierend auf dem Betriebssystem, an dem Sie arbeiten.

Betriebssystem	Ausgabe
Windows	Java-Version "1.7.0_25" Java (TM) SE-Laufzeitumgebung (Build 1.7.0_25-b15) Java HotSpot (TM) 64-Bit-Server-VM (Build 23.25-b01, gemischter Modus)
Linux	Java-Version "1.7.0_25" Java (TM) SE-Laufzeitumgebung (Build 1.7.0_25-b15) Java HotSpot (TM) 64-Bit-Server-VM (Build 23.25-b01, gemischter Modus)
Mac	Java-Version "1.7.0_25" Java (TM) SE-Laufzeitumgebung (Build 1.7.0_25-b15) Java HotSpot (TM) 64-Bit-Server-VM (Build 23.25-b01, gemischter Modus)

Wenn Sie Java nicht installiert haben, installieren Sie das Java Software Development Kit (SDK) unter www.oracle.com/technetwork/java/javase/downloads/index.html . Wir gehen davon aus, dass Java 1.7.0_25 die installierte Version für dieses Tutorial ist.

Schritt 2: Stellen Sie die Java-Umgebung ein

Stellen Sie die JAVA_HOMEUmgebungsvariable, die auf den Speicherort des Basisverzeichnisses verweist, in dem Java auf Ihrem Computer installiert ist. Zum Beispiel -

Betriebssystem	Ausgabe
Windows	Setzen Sie die Umgebungsvariable JAVA_HOME auf C: \ Programme \ Java \ jdk1.7.0_25
Linux	export JAVA_HOME = / usr / local / java-current
Mac	export JAVA_HOME = / Library / Java / Home

Hängen Sie den Java-Compiler-Speicherort an den Systempfad an.

Betriebssystem	Ausgabe
Windows	Fügen Sie die Zeichenfolge hinzu. C: \ Programme \ Java \ jdk1.7.0_25 \ bin bis zum Ende der Systemvariablen Path.
Linux	export PATH = $ PATH: $ JAVA_HOME / bin /
Mac	nicht benötigt

Überprüfen Sie die Java-Installation mit java -version Befehl wie oben erklärt.

Schritt 3: Laden Sie JMeter herunter

Laden Sie die neueste Version von JMeter von herunter https://jmeter.apache.org/download_jmeter.cgi. Für dieses Tutorial haben wir apache-jmeter-2.9 heruntergeladen und in den Ordner C: \> JMeter kopiert.

Die Verzeichnisstruktur sollte wie folgt aussehen -

• apache-jmeter-2.9
• apache-jmeter-2.9\bin
• apache-jmeter-2.9\docs
• apache-jmeter-2.9\extras
• apache-jmeter-2.9\lib\
• apache-jmeter-2.9\lib\ext
• apache-jmeter-2.9\lib\junit
• apache-jmeter-2.9\printable_docs

Sie können das übergeordnete Verzeichnis (dh apache-jmeter-2.9) umbenennen, wenn Sie möchten, aber keinen der Namen des Unterverzeichnisses ändern.

Schritt 4: Führen Sie JMeter aus

Wechseln Sie nach dem Herunterladen von JMeter in das Verzeichnis bin . In diesem Fall ist es/home/manisha/apache-jmeter-2.9/bin. Klicken Sie nun auf Folgendes:

Betriebssystem	Ausgabe
Windows	jmeter.bat
Linux	jmeter.sh
Mac	jmeter.sh

Nach einer kurzen Pause sollte die JMeter-Benutzeroberfläche angezeigt werden, bei der es sich um eine Swing-Anwendung handelt, wie im folgenden Screenshot dargestellt:

Dies ist die Hauptseite und die Standardseite des Tools.

Was ist ein Testplan?

Ein Testplan kann als Container zum Ausführen von Tests angesehen werden. Es definiert, was zu testen ist und wie es zu tun ist. Ein vollständiger Testplan besteht aus einem oder mehreren Elementen wie Thread-Gruppen, Logik-Controllern, Sample-generierenden Controllern, Listenern, Timern, Assertions und Konfigurationselementen. Ein Testplan muss mindestens eine Thread-Gruppe haben.

Testplan schreiben

Befolgen Sie die unten angegebenen Schritte, um einen Testplan zu erstellen -

Schritt 1: Starten Sie das JMeter-Fenster

Öffnen Sie das JMeter-Fenster, indem Sie auf klicken /home/manisha/apache-jmeter-2.9/bin/jmeter.sh. Das JMeter-Fenster wird wie folgt angezeigt:

Dies ist ein einfaches und leeres JMeter-Fenster, dem keine zusätzlichen Elemente hinzugefügt wurden. Es enthält zwei Knoten -

• Test Plan node - Hier wird der eigentliche Testplan aufbewahrt.

• Workbench node- Es bietet lediglich einen Platz zum vorübergehenden Speichern von Testelementen, die nicht verwendet werden, zum Kopieren / Einfügen. Wenn Sie Ihren Testplan speichern, werden Workbench-Elemente nicht damit gespeichert.

Schritt 2: Elemente hinzufügen / entfernen

Elemente (die im nächsten Kapitel Testplanelemente erläutert werden ) können einem Testplan hinzugefügt werden, indem Sie mit der rechten Maustaste auf den Knoten Testplan klicken und ein neues Element aus der Liste "Hinzufügen" auswählen.

Alternativ können Sie ein Element aus einer Datei laden und hinzufügen, indem Sie die Option "Zusammenführen" oder "Öffnen" auswählen.

Fügen wir beispielsweise ein Testgruppenelement zu einem Testplan hinzu, wie unten gezeigt -

Um ein Element zu entfernen, stellen Sie sicher, dass das Element ausgewählt ist, klicken Sie mit der rechten Maustaste auf das Element und wählen Sie die Option "Entfernen".

Schritt 3: Laden und Speichern der Elemente

So laden Sie ein Element aus einer Datei:

• Klicken Sie mit der rechten Maustaste auf das vorhandene Baumelement, zu dem Sie das geladene Element hinzufügen möchten.
• Wählen Sie Zusammenführen.
• Wählen Sie die Datei aus, in der Sie die Elemente gespeichert haben.
• JMeter führt die Elemente in den Baum ein.

Standardmäßig speichert JMeter das Element nicht, Sie müssen es explizit speichern.

Baumelemente speichern -

• Klicken Sie mit der rechten Maustaste auf das Element.
• Wählen Sie die Option Auswahl speichern unter ...

JMeter speichert das ausgewählte Element sowie alle untergeordneten Elemente darunter. Standardmäßig speichert JMeter die Elemente nicht. Sie müssen sie wie oben erwähnt explizit speichern.

Schritt 4: Konfigurieren der Baumelemente

Jedes Element im Testplan kann mithilfe der Steuerelemente im rechten Rahmen von JMeter konfiguriert werden. Mit diesen Steuerelementen können Sie das Verhalten dieses bestimmten Testelements konfigurieren. Beispielsweise kann die Thread-Gruppe für eine Anzahl von Benutzern, Hochlaufperioden usw. konfiguriert werden, wie unten gezeigt -

Schritt 5: Speichern des Testplans

Sie können einen vollständigen Testplan mit beiden speichern Save oder "Save Test Plan As ..." aus dem Menü Datei.

Schritt 6: Führen Sie den Testplan aus

Sie können den Testplan ausführen, indem Sie auf klicken Start(Strg + r) von der RunMenüpunkt. Wenn JMeter zu laufen beginnt, wird am rechten Ende des Abschnitts direkt unter der Menüleiste ein kleines grünes Kästchen angezeigt.

Die Zahlen links neben dem grünen Feld geben die Anzahl der aktiven Threads / die Gesamtzahl der Threads an. Diese gelten nur für einen lokal ausgeführten Test. Sie enthalten keine Threads, die auf Remote-Systemen im Client-Server-Modus gestartet wurden.

Schritt 7: Stoppen Sie den Testplan

Sie können Ihren Test auf zwei Arten stoppen:

• Verwenden von Stop(Strg + '.'). Wenn möglich, werden die Threads sofort gestoppt.

• Verwenden von Shutdown(Strg + ','). Es fordert die Threads auf, am Ende einer aktuellen Arbeit anzuhalten.

Ein JMeter-Testplan besteht aus den unten diskutierten Testelementen. Ein Testplan besteht aus mindestens einer Thread-Gruppe. Innerhalb jeder Thread-Gruppe können wir eine Kombination aus einem oder mehreren anderen Elementen platzieren - Sampler, Logic Controller, Konfigurationselement, Listener und Timer. Vor jedem Sampler können ein oder mehrere Vorprozessorelemente stehen, gefolgt von einem Postprozessorelement und / oder einem Assertion-Element. Lassen Sie uns jedes dieser Elemente im Detail sehen -

Thread-Gruppe

Thread-Gruppenelemente sind die Anfangspunkte Ihres Testplans. Wie der Name schon sagt, steuern die Thread-Gruppenelemente die Anzahl der Threads, die JMeter während des Tests verwendet. Wir können auch Folgendes über die Thread-Gruppe steuern -

• Festlegen der Anzahl der Threads

• Hochlaufzeit einstellen

• Festlegen der Anzahl der Testiterationen

Die Systemsteuerung für Thread-Gruppen sieht folgendermaßen aus:

Das Thread-Gruppenfenster enthält die folgenden Komponenten:

• Action to be taken after a Sampler error - Falls während der Testausführung ein Fehler auftritt, können Sie den Test entweder zulassen -

  • Continue zum nächsten Element im Test

  • Stop Thread um den aktuellen Thread zu stoppen.

  • Stop Test vollständig, falls Sie den Fehler überprüfen möchten, bevor er weiter ausgeführt wird.

• Number of Threads - Simuliert die Anzahl der Benutzer oder Verbindungen zu Ihrer Serveranwendung.

• Ramp-Up Period Legt fest, wie lange JMeter benötigt, um alle Threads zum Laufen zu bringen.

• Loop Count - Legt fest, wie oft der Test ausgeführt werden soll.

• Scheduler checkbox - Nach der Auswahl wird der Abschnitt Scheduler-Konfiguration unten in der Systemsteuerung angezeigt.

• Scheduler Configuration - Sie können die Start- und Endzeit für die Ausführung des Tests konfigurieren.

Controller

JMeter verfügt über zwei Arten von Controllern: Sampler und Logikcontroller .

Sampler

Mit Samplern kann JMeter bestimmte Arten von Anforderungen an einen Server senden. Sie simulieren eine Benutzeranforderung für eine Seite vom Zielserver. Sie können beispielsweise einen HTTP-Anforderungs-Sampler hinzufügen, wenn Sie einen POST, GET oder DELETE für einen HTTP-Dienst ausführen müssen.

Einige nützliche Sampler sind -

• HTTP-Anfrage
• FTP-Anfrage
• JDBC-Anfrage
• Java-Anfrage
• SOAP / XML-Anfrage
• RPC-Anfragen

Der folgende Screenshot zeigt ein HTTP Request Sampler Control Panel -

Logik-Controller

Mit Logik-Controllern können Sie die Reihenfolge der Verarbeitung von Samplern in einem Thread steuern. Logikcontroller können die Reihenfolge einer Anforderung ändern, die von einem ihrer untergeordneten Elemente kommt. Einige Beispiele sind: ForEach Controller, While-Controller, Loop-Controller, IF-Controller, Laufzeit-Controller, Interleave-Controller, Durchsatz-Controller und Run Once-Controller.

Der folgende Screenshot zeigt eine Loop Controller-Systemsteuerung -

Die folgende Liste enthält alle von JMeter bereitgestellten Logikcontroller -

• Einfache Steuerung
• Loop-Controller
• Einmaliger Controller
• Interleave Controller
• Zufälliger Controller
• Controller für zufällige Reihenfolge
• Durchsatzregler
• Laufzeit-Controller
• Wenn Controller
• Während Controller
• Controller wechseln
• Für jeden Controller
• Modulsteuerung
• Controller einschließen
• Transaktionscontroller
• Aufnahmesteuerung

Fragmente testen

Ein Testfragment ist ein spezieller Elementtyp, der auf derselben Ebene wie das Threadgruppenelement platziert ist. Es unterscheidet sich von einer Thread-Gruppe dadurch, dass es nur ausgeführt wird, wenn es von einem Modul-Controller oder einem Include_Controller referenziert wird. Dieses Element dient ausschließlich zur Wiederverwendung von Code in Testplänen.

Zuhörer

Mit Listenern können Sie die Ergebnisse von Samplern in Form von Tabellen, Grafiken, Bäumen oder einfachem Text in einigen Protokolldateien anzeigen. Sie bieten visuellen Zugriff auf die von JMeter gesammelten Daten zu den Testfällen, wenn eine Sampler-Komponente von JMeter ausgeführt wird.

Listener können an einer beliebigen Stelle im Test hinzugefügt werden, auch direkt unter dem Testplan. Sie sammeln nur Daten von Elementen auf oder unter ihrer Ebene. Die folgende Liste enthält alle Listener, die JMeter bereitstellt:

• Beispielergebnis Konfiguration speichern
• Vollständige Ergebnisse grafisch darstellen
• Diagrammergebnisse
• Spline Visualizer
• Behauptung Ergebnisse
• Ergebnisbaum anzeigen
• Gesamtbericht
• Ergebnisse in Tabelle anzeigen
• Einfacher Datenschreiber
• Ergebnisse überwachen
• Verteilungsdiagramm (Alpha)
• Aggregatdiagramm
• Mailer Visualizer
• BeanShell Listener
• Kurzbericht

Timer

Standardmäßig sendet ein JMeter-Thread Anforderungen, ohne zwischen den einzelnen Samplern zu pausieren. Dies ist möglicherweise nicht das, was Sie wollen. Sie können ein Timer-Element hinzufügen, mit dem Sie eine Wartezeit zwischen den einzelnen Anforderungen definieren können.

Die folgende Liste zeigt alle von JMeter bereitgestellten Timer -

• Konstanter Timer
• Gaußscher Zufalls-Timer
• Uniform Random Timer
• Timer für konstanten Durchsatz
• Timer synchronisieren
• JSR223 Zeit
• BeanShell-Zeit
• BSF-Zeit
• Poisson Zufällige Zeit

Der folgende Screenshot zeigt ein Constant Timer Control Panel -

Behauptungen

Mithilfe von Zusicherungen können Sie einen Validierungstest für die Antwort Ihrer Anfrage mit einem Sampler einschließen. Mithilfe von Zusicherungen können Sie nachweisen, dass Ihre Anwendung die richtigen Daten zurückgibt. JMeter hebt hervor, wenn eine Zusicherung fehlschlägt.

Die folgende Liste enthält alle Aussagen, die JMeter macht -

• Beanshell Behauptung
• BSF-Behauptung
• Vergleichen Sie die Behauptung
• JSR223-Behauptung
• Antwort Behauptung
• Dauer Behauptung
• Größenbehauptung
• XML-Zusicherung
• BeanShell-Behauptung
• MD5Hex-Behauptung
• HTML-Bestätigung
• XPath-Behauptung
• XML-Schema-Zusicherung

Der folgende Screenshot zeigt ein Response Assertion Control Panel -

Konfigurationselemente

Mit Konfigurationselementen können Sie Standardeinstellungen und Variablen erstellen, die von Samplern verwendet werden. Sie werden verwendet, um Anforderungen von Samplern hinzuzufügen oder zu ändern.

Sie werden zu Beginn des Bereichs ausgeführt, zu dem sie gehören, vor Samplern, die sich im selben Bereich befinden. Daher wird auf ein Konfigurationselement nur innerhalb des Zweigs zugegriffen, in dem es platziert ist.

Die folgende Liste enthält alle von JMeter bereitgestellten Konfigurationselemente:

• Counter
• CSV-Datensatzkonfiguration
• Standardeinstellungen für FTP-Anforderungen
• HTTP Authorization Manager
• HTTP-Cache-Manager
• HTTP-Cookie-Manager
• HTTP-Proxyserver
• Standardeinstellungen für HTTP-Anforderungen
• HTTP-Header-Manager
• Standardeinstellungen für Java-Anforderungen
• Keystore-Konfiguration
• JDBC-Verbindungskonfiguration
• Login-Konfigurationselement
• LDAP-Anforderungsstandards
• LDAP Extended Request Defaults
• TCP Sampler Config
• Benutzerdefinierte Variablen
• Einfaches Konfigurationselement
• Zufällige Variable

Pre-Prozessor-Elemente

Ein Vorprozessorelement wird unmittelbar vor der Ausführung eines Samplers ausgeführt. Sie werden häufig verwendet, um die Einstellungen einer Beispielanforderung unmittelbar vor ihrer Ausführung zu ändern oder um Variablen zu aktualisieren, die nicht aus dem Antworttext extrahiert wurden.

Die folgende Liste enthält alle von JMeter bereitgestellten Vorprozessorelemente:

• HTML Link Parser
• Modifikator zum erneuten Schreiben der HTTP-URL
• HTTP User Parameter Modifier
• Benutzerparameter
• JDBC-Präprozessor
• JSR223 PreProcessor
• RegEx-Benutzerparameter
• BeanShell PreProcessor
• BSF-Vorprozessor

Postprozessor-Elemente

Ein Postprozessor wird ausgeführt, nachdem ein Sampler seine Ausführung beendet hat. Dieses Element wird am häufigsten verwendet, um die Antwortdaten zu verarbeiten, um beispielsweise einen bestimmten Wert für die spätere Verwendung abzurufen.

Die folgende Liste enthält alle von JMeter bereitgestellten Postprozessorelemente:

• Extraktor für reguläre Ausdrücke
• XPath Extractor
• Ergebnisstatus-Aktionshandler
• JSR223 PostProcessor
• JDBC-Postprozessor
• BSF PostProcessor
• CSS / JQuery Extractor
• BeanShell PostProcessor
• Debuggen Sie PostProcessor

Ausführungsreihenfolge der Testelemente

Es folgt die Ausführungsreihenfolge der Testplanelemente -

• Konfigurationselemente
• Pre-Processors
• Timers
• Sampler
• Postprozessoren (es sei denn, SampleResult ist null)
• Behauptungen (es sei denn, SampleResult ist null)
• Listener (es sei denn, SampleResult ist null)

Lassen Sie uns einen einfachen Testplan erstellen, der eine Webseite testet. Wir schreiben einen Testplan in Apache JMeter, damit wir die Leistung der unter der URL www.tutorialspoint.com angezeigten Webseite testen können .

Starten Sie JMeter

Öffnen Sie das JMeter-Fenster, indem Sie auf klicken /home/manisha/apache-jmeter-2.9/bin/jmeter.sh. Das JMeter-Fenster wird wie folgt angezeigt:

Benennen Sie den Testplan um

Ändern Sie den Namen des Testplanknotens im Textfeld Name in Beispieltest . Sie müssen den Fokus auf den Workbench-Knoten und zurück zum Testplan-Knoten ändern, um zu sehen, wie der Name wiedergegeben wird.

Thread-Gruppe hinzufügen

Jetzt fügen wir unser erstes Element in das Fenster ein. Wir fügen eine Thread-Gruppe hinzu, die ein Platzhalter für alle anderen Elemente wie Sampler, Controller und Listener ist. Wir benötigen einen, damit wir die Anzahl der zu simulierenden Benutzer konfigurieren können.

In JMeter werden alle Knotenelemente über das Kontextmenü hinzugefügt.

• Klicken Sie mit der rechten Maustaste auf das Element, zu dem Sie einen untergeordneten Elementknoten hinzufügen möchten.

• Wählen Sie die entsprechende Option zum Hinzufügen aus.

• Klicken Sie mit der rechten Maustaste auf den Beispieltest (unseren Testplan) → Hinzufügen → Threads (Benutzer) → Thread-Gruppe. Daher wird die Thread-Gruppe unter dem Knoten Testplan (Beispieltest) hinzugefügt.

• Benennen Sie die Thread-Gruppe als Benutzer . Für uns bedeutet dieses Element, dass Benutzer die TutorialsPoint-Startseite besuchen.

Sampler hinzufügen

Wir müssen einen Sampler in unsere Thread-Gruppe (Benutzer) aufnehmen. Wie bereits für das Hinzufügen einer Thread-Gruppe beschrieben, öffnen wir dieses Mal das Kontextmenü des Knotens "Thread-Gruppe (Benutzer)", indem Sie mit der rechten Maustaste klicken, und fügen den HTTP-Anforderungs-Sampler hinzu, indem Sie "Hinzufügen" → "Sampler → HTTP-Anforderungsoption" wählen.

Es wird ein leerer HTTP-Anforderungs-Sampler unter dem Knoten Thread-Gruppe (Benutzer) hinzugefügt. Lassen Sie uns dieses Knotenelement konfigurieren -

• Name- Wir werden den Namen ändern, um die Aktion widerzuspiegeln, die wir erreichen möchten. Wir werden es so nennenVisit TutorialsPoint Home Page

• Server Name or IP- Hier müssen wir den Webservernamen eingeben. In unserem Fall ist eswww.tutorialspoint.com. (http: // Teil ist nicht geschrieben, dies ist nur der Name des Servers oder seine IP)

• Protocol - Wir werden dieses Feld leer lassen, was bedeutet, dass wir HTTP als Protokoll wollen.

• Path- Wir geben den Pfad als / (Schrägstrich) ein. Das heißt, wir wollen die Stammseite des Servers.

Listener hinzufügen

Wir werden jetzt einen Listener hinzufügen. Fügen Sie unter dem Knoten Thread Group (User) den Listenbaum View Results Tree hinzu. Dadurch wird sichergestellt, dass die Ergebnisse des Samplers in diesem Listener-Knotenelement angezeigt werden können.

So fügen Sie einen Listener hinzu:

• Öffnen Sie das Kontextmenü

• Klicken Sie mit der rechten Maustaste auf die Thread-Gruppe (Benutzer).

• Wählen Sie die Option Hinzufügen → Listener → Ergebnisbaum anzeigen

Führen Sie den Testplan aus

Lassen Sie uns nun mit allen Einstellungen den Testplan ausführen. Bei der Konfiguration der Thread-Gruppe (Benutzer) behalten wir alle Standardwerte bei. Dies bedeutet, dass JMeter den Sampler nur einmal ausführt. Es ähnelt einem einzelnen Benutzer nur einmal.

Dies ähnelt einem Benutzer, der eine Webseite über einen Browser mit JMeter-Sampler besucht. Um den Testplan auszuführen, wählen Sie im Menü die Option Ausführen und anschließend die Option Start.

Apache JMeter fordert uns auf, den Testplan in einer Festplattendatei zu speichern, bevor der Test tatsächlich gestartet wird. Dies ist wichtig, wenn Sie den Testplan mehrmals ausführen möchten. Sie können es auch ohne Speichern ausführen.

Zeigen Sie die Ausgabe an

Wir haben die Einstellung der Thread-Gruppe als Einzel-Thread (nur ein Benutzer) und Schleife für 1 Mal (nur einmalige Ausführung) beibehalten, daher erhalten wir das Ergebnis einer einzelnen Transaktion im View Result Tree Listener.

Details des obigen Ergebnisses sind -

• Grüne Farbe gegen den Namen Visit TutorialsPoint Home Page zeigt Erfolg an.

• JMeter hat alle vom Webserver gesendeten Header und Antworten gespeichert und ist bereit, uns das Ergebnis auf vielfältige Weise anzuzeigen.

• Die erste Registerkarte ist Sampler Results. Es zeigt JMeter-Daten sowie vom Webserver zurückgegebene Daten.

• Die zweite Registerkarte ist Anfrage, auf der alle Daten angezeigt werden, die als Teil der Anfrage an den Webserver gesendet wurden.

Die letzte Registerkarte enthält Antwortdaten. Auf dieser Registerkarte zeigt der Listener die vom Server empfangenen Daten im Textformat an.

Dies ist nur ein einfacher Testplan, der nur eine Anforderung ausführt. Die wahre Stärke von JMeter besteht jedoch darin, dieselbe Anfrage zu senden, als ob viele Benutzer sie senden würden. Um die Webserver mit mehreren Benutzern zu testen, müssen Sie die Einstellungen für die Thread-Gruppe (Benutzer) ändern.

In diesem Kapitel erfahren Sie, wie Sie einen einfachen Testplan zum Testen des Datenbankservers erstellen. Für unsere Testzwecke verwenden wir den MYSQL-Datenbankserver. Sie können jede andere Datenbank zum Testen verwenden. Informationen zur Installation und Tabellenerstellung in MYSQL finden Sie im MYSQL-Tutorial .

Führen Sie nach der Installation von MYSQL die folgenden Schritte aus, um die Datenbank einzurichten.

• Erstellen Sie eine Datenbank mit dem Namen "Tutorial".

• Erstellen Sie eine Tabelle tutorials_tbl .

• Fügen Sie Datensätze wie unten gezeigt in tutorials_tbl ein -

mysql> use TUTORIALS;
Database changed
mysql> INSERT INTO tutorials_tbl 
   ->(tutorial_title, tutorial_author, submission_date)
   ->VALUES
   ->("Learn PHP", "John Poul", NOW());
  
Query OK, 1 row affected (0.01 sec)
mysql> INSERT INTO tutorials_tbl
   ->(tutorial_title, tutorial_author, submission_date)
   ->VALUES
   ->("Learn MySQL", "Abdul S", NOW());
 
Query OK, 1 row affected (0.01 sec)
mysql> INSERT INTO tutorials_tbl
   ->(tutorial_title, tutorial_author, submission_date)
   ->VALUES
   ->("JAVA Tutorial", "Sanjay", '2007-05-06');

Query OK, 1 row affected (0.01 sec)
mysql>

• Kopieren Sie den entsprechenden JDBC-Treiber nach /home/manisha/apache-jmeter-2.9/lib.

Erstellen Sie einen JMeter-Testplan

Beginnen wir mit dem JMeter /home/manisha/apache-jmeter-2.9/bin/jmeter.sh.

Benutzer hinzufügen

Um eine Thread-Gruppe zu erstellen,

• Klicken Sie mit der rechten Maustaste auf Testplan.

• Wählen Sie Hinzufügen → Threads (Benutzer) → Thread-Gruppe.

• Daher wird die Thread-Gruppe unter dem Testplan-Knoten hinzugefügt.

• Benennen Sie diese Thread-Gruppe in JDBC-Benutzer um .

Wir werden die Standardeigenschaften der Thread-Gruppe nicht ändern.

JDBC-Anforderungen hinzufügen

Nachdem wir unsere Benutzer definiert haben, ist es Zeit, die Aufgaben zu definieren, die sie ausführen werden. Geben Sie in diesem Abschnitt die auszuführenden JDBC-Anforderungen an.

• Klicken Sie mit der rechten Maustaste auf das Element JDBC-Benutzer.

• Wählen Add → Config Element → JDBC Connection Configuration.

• Richten Sie die folgenden Felder ein (wir verwenden die MySQL-Datenbank namens Tutorial) -

  • Variablenname an Pool gebunden. Dies muss die Konfiguration eindeutig identifizieren. Es wird vom JDBC-Sampler verwendet, um die zu verwendende Konfiguration zu identifizieren. Wir haben es als Test benannt .

  • Datenbank-URL - jdbc: mysql: // localhost: 3306 / tutorial.

  • JDBC-Treiberklasse: com.mysql.jdbc.Driver.

  • Benutzername: root.

  • Passwort: Passwort für root.

Die anderen Felder auf dem Bildschirm bleiben wie unten gezeigt als Standardeinstellungen erhalten -

Fügen Sie nun eine JDBC-Anforderung hinzu, die sich auf den oben definierten JDBC-Konfigurationspool bezieht. Wählen Sie das JDBC-Benutzerelement aus.

• Klicken Sie mit der rechten Maustaste, um das Menü Hinzufügen aufzurufen

• Wählen Add → Sampler → JDBC Request.

• Wählen Sie dieses neue Element aus, um die Systemsteuerung anzuzeigen.

• Bearbeiten Sie die Eigenschaften wie unten gezeigt -

  • Variablenname an Pool gebunden. Dies muss die Konfiguration eindeutig identifizieren. Es wird vom JDBC-Sampler verwendet, um die zu verwendende Konfiguration zu identifizieren. Nannte es als Test .

  • Name - Lernen.

  • Geben Sie den Poolnamen ein - Test (wie im Konfigurationselement).

  • Abfragetyp - Select-Anweisung.

  • Geben Sie das Feld SQL Query String ein.

Listener erstellen

Fügen Sie nun das Listener-Element hinzu. Dieses Element ist dafür verantwortlich, alle Ergebnisse Ihrer JDBC-Anforderungen in einer Datei zu speichern und ein visuelles Modell der Daten darzustellen.

• Wählen Sie das Element JDBC-Benutzer aus

• Hinzufügen eines View Results Tree-Listeners (Add → Listener → View Results Tree).

Testplan speichern und ausführen

Speichern Sie nun den obigen Testplan als db_test.jmx . Führen Sie diesen Testplan mit ausRun → Start Möglichkeit.

Überprüfen Sie die Ausgabe

Im letzten Bild sehen Sie, dass zwei Datensätze ausgewählt sind.

In diesem Kapitel erfahren Sie, wie Sie eine FTP-Site mit JMeter testen. Lassen Sie uns einen Testplan erstellen, um die FTP-Site zu testen.

Testplan umbenennen

• Öffnen Sie das JMeter-Fenster, indem Sie auf /home/manisha/apache-jmeter-2.9/bin/jmeter.sh klicken

• Klicken Sie auf den Knoten Testplan.

• Benennen Sie diesen Testplanknoten in TestFTPSite um.

Thread-Gruppe hinzufügen

Fügen Sie eine Thread-Gruppe hinzu, die Platzhalter für alle anderen Elemente wie Sampler, Controller und Listener ist.

• Klicken Sie mit der rechten Maustaste auf TestFTPSite (unser Testplan).

• Wählen Sie Hinzufügen → Threads (Benutzer) → Thread-Gruppe. Die Thread-Gruppe wird unter dem Knoten Testplan (TestFTPSite) hinzugefügt.

• Ändern Sie die Standardeigenschaften der Thread-Gruppe wie folgt für unsere Tests:

  • Name - FTP-Benutzer

  • Number of Threads (Users) - 4

  • Ramp-Up Period - Belassen Sie den Standardwert von 0 Sekunden.

  • Loop Count - 1

Sampler hinzufügen - FTP-Anfrage

Nachdem wir unsere Benutzer definiert haben, ist es Zeit, die Aufgaben zu definieren, die sie ausführen werden. Fügen Sie FTP-Anforderungselemente hinzu. Wir fügen zwei FTP-Anforderungselemente hinzu, eines, das eine Datei abruft, und das andere, das eine Datei auf der FTP-Site ablegt.

• Wählen Sie das FTP-Benutzerelement aus.

• Klicken Sie mit der rechten Maustaste, um das Menü Hinzufügen aufzurufen

• Wählen Sie Hinzufügen → Sampler → FTP-Anfrage.

• Wählen Sie das FTP-Anforderungselement in der Baumstruktur aus.

• Bearbeiten Sie die folgenden Eigenschaften wie unten gezeigt -

Die folgenden Details werden in dieses Element eingegeben -

• Name - FTP-Anfrage abrufen

• Server Name or IP - 184.168.74.29

• Remote File - /home/manisha/sample_ftp.txt

• Local File - sample_ftp.txt

• Wählen Sie get (RETR)

• Username - Manisha

• Password - manisha123

Fügen Sie nun wie oben eine weitere FTP-Anfrage hinzu und bearbeiten Sie die Eigenschaften wie im folgenden Screenshot gezeigt -

Die folgenden Details werden in dieses Element eingegeben -

• Name - FTP Request Put

• Server Name or IP - 184.168.74.29

• Remote File - /home/manisha/examplefile.txt

• Local File - /home/manisha/work/examplefile.txt

• Wählen Sie put (STOR)

• Username - Manisha

• Password - manisha123

Listener hinzufügen

Das letzte Element, das Sie Ihrem Testplan hinzufügen müssen, ist ein Listener. Dieses Element ist dafür verantwortlich, alle Ergebnisse Ihrer FTP-Anforderungen in einer Datei zu speichern und ein visuelles Modell der Daten darzustellen.

• Wählen Sie das FTP-Benutzerelement aus.

• Fügen Sie einen Listener zum Anzeigen des Ergebnisbaums hinzu, indem Sie Hinzufügen> Listener> Ergebnisbaum anzeigen auswählen.

Führen Sie den Testplan aus

Speichern Sie nun den obigen Testplan als ftpsite_test.jmx . Führen Sie diesen Testplan mit ausRun → Start Möglichkeit.

Zeigen Sie die Ausgabe an

Die folgende Ausgabe ist im Listener zu sehen.

Sie können sehen, dass für jede FTP-Anforderung vier Anforderungen gestellt werden und der Test erfolgreich ist. Die abgerufene Datei für die GET-Anforderung wird im Ordner / bin gespeichert. In unserem Fall ist es/home/manisha/apache-jmeter-2.9/bin/. Bei einer PUT-Anforderung wird die Datei im Pfad hochgeladen/home/manisha/.

In diesem Kapitel erfahren Sie, wie Sie einen Testplan zum Testen eines WebService erstellen. Zu unserem Testzweck haben wir ein einfaches Webservice-Projekt erstellt und es lokal auf dem Tomcat-Server bereitgestellt.

Webservice-Projekt erstellen

Um ein Webservice-Projekt zu erstellen, haben wir die Eclipse-IDE verwendet. Schreiben Sie zuerst die Service-EndpunktschnittstelleHelloWorld unter dem Paket com.tutorialspoint.ws. Der Inhalt von HelloWorld.java lautet wie folgt:

package com.tutorialspoint.ws;

import javax.jws.WebMethod;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;
import javax.jws.soap.SOAPBinding.Style;

//Service Endpoint Interface
@WebService
@SOAPBinding(style = Style.RPC)

public interface HelloWorld {
   @WebMethod String getHelloWorldMessage(String string);
}

Dieser Dienst hat eine Methode getHelloWorldMessage das nimmt einen String-Parameter.

Erstellen Sie als Nächstes die Implementierungsklasse HelloWorldImpl.java unter dem Paket com.tutorialspoint.ws.

package com.tutorialspoint.ws;

import javax.jws.WebService;

@WebService(endpointInterface="com.tutorialspoint.ws.HelloWorld")
public class HelloWorldImpl  implements HelloWorld  {
   @Override
   public String getHelloWorldMessage(String myName) {
      return("Hello "+myName+" to JAX WS world");
   }
}

Lassen Sie uns diesen Webdienst jetzt lokal veröffentlichen, indem Sie den Endpoint-Herausgeber erstellen und den Dienst auf dem Server verfügbar machen.

Die Veröffentlichungsmethode akzeptiert zwei Parameter:

• Endpunkt-URL-Zeichenfolge.

• Implementierungsobjekt, in diesem Fall die HelloWorld-Implementierungsklasse, die als Webdienst an dem Endpunkt verfügbar gemacht wird, der durch die im obigen Parameter angegebene URL identifiziert wird.

Der Inhalt von HelloWorldPublisher.java lautet wie folgt:

package com.tutorialspoint.endpoint;

import javax.xml.ws.Endpoint;
import com.tutorialspoint.ws.HelloWorldImpl;

public class HelloWorldPublisher {
   public static void main(String[] args) {
      Endpoint.publish("http://localhost:9000/ws/hello", new HelloWorldImpl());
   }
}

Ändern Sie den Inhalt von web.xml wie unten gezeigt -

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, 
   Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/j2ee/dtds/web-app_2_3.dtd">

<web-app>
   <listener>
      <listener-class>
         com.sun.xml.ws.transport.http.servlet.WSServletContextListener
      </listener-class>
   </listener>
	
   <servlet>
      <servlet-name>hello</servlet-name>
      <servlet-class>com.sun.xml.ws.transport.http.servlet.WSServlet</servlet-class>
      <load-on-startup>1</load-on-startup>
   </servlet>
	
   <servlet-mapping>
      <servlet-name>hello</servlet-name>
      <url-pattern>/hello</url-pattern>
   </servlet-mapping>
	
   <session-config>
      <session-timeout>120</session-timeout>
   </session-config>
	
</web-app>

Um diese Anwendung als Webservice bereitzustellen, benötigen wir eine andere Konfigurationsdatei sun-jaxws.xml. Der Inhalt dieser Datei lautet wie folgt:

<?xml version = "1.0" encoding = "UTF-8"?>
<endpoints
   xmlns = "http://java.sun.com/xml/ns/jax-ws/ri/runtime"
   version = "2.0">
   
   <endpoint name = "HelloWorld" 
      implementation = "com.tutorialspoint.ws.HelloWorldImpl" 
      url-pattern = "/hello"/>
</endpoints>

Nachdem alle Dateien fertig sind, sieht die Verzeichnisstruktur wie im folgenden Screenshot dargestellt aus:

• Erstellen Sie nun eine WAR-Datei dieser Anwendung.

• Wählen Sie das Projekt → Rechtsklick → Exportieren → WAR-Datei.

• Speichern Sie dies als hello.war Datei unter der webapps Ordner des Tomcat-Servers.

• Starten Sie nun den Tomcat-Server.

• Sobald der Server gestartet ist, sollten Sie über die URL http: // localhost: 8080 / hello / hello auf den Webservice zugreifen können

Erstellen Sie einen JMeter-Testplan

Lassen Sie uns nun einen Testplan erstellen, um den oben genannten Webservice zu testen.

Benennen Sie den Testplan um

• Öffnen Sie das JMeter-Fenster, indem Sie auf /home/manisha/apache-jmeter2.9/bin/jmeter.sh klicken.

• Klicken Sie auf den Knoten Testplan.

• Benennen Sie diesen Testplanknoten in WebserviceTest um.

Thread-Gruppe hinzufügen

Fügen Sie eine Thread-Gruppe hinzu, die Platzhalter für alle anderen Elemente wie Sampler, Controller und Listener ist.

• Klicken Sie mit der rechten Maustaste auf WebserviceTest (unser Testplan) → Hinzufügen → Threads (Benutzer) → Thread-Gruppe. Die Thread-Gruppe wird unter dem Knoten Testplan (WebserviceTest) hinzugefügt.

• Als Nächstes ändern wir die Standardeigenschaften der Thread-Gruppe entsprechend unseren Tests. Folgende Eigenschaften werden geändert -

  • Name - Webservice-Benutzer

  • Number of Threads (Users) - 2

  • Ramp-Up Period - Belassen Sie den Standardwert von 0 Sekunden.

  • Loop Count - 2

Sampler hinzufügen - SOAP / XML-RPC-Anforderung

Nachdem wir die Benutzer definiert haben, ist es Zeit, die Aufgaben zu definieren, die sie ausführen werden.

Wir werden das SOAP / XML-RPC-Anforderungselement hinzufügen -

• Klicken Sie mit der rechten Maustaste, um das Menü Hinzufügen aufzurufen.

• Wählen Sie Hinzufügen → Sampler → SOAP / XML-RPC-Anforderung.

• Wählen Sie das SOAP / XML-RPC-Anforderungselement in der Baumstruktur aus

• Bearbeiten Sie die folgenden Eigenschaften wie im Bild unten -

• Die folgenden Details werden in dieses Element eingegeben -

  • Name − SOAP/XML-RPC Request

  • URL - http: // localhost: 8080 / hallo / hallo? Wsdl

  • Soap/XML-RPC Data - Geben Sie den folgenden Inhalt ein

<soapenv:Envelope xmlns:soapenv = "http://schemas.xmlsoap.org/soap/envelope/" 
   xmlns:web = "http://ws.tutorialspoint.com/">
   <soapenv:Header/>
	
   <soapenv:Body>
      <web:getHelloWorldMessage>
         <arg0>Manisha</arg0>
      </web:getHelloWorldMessage>
   </soapenv:Body>
   
</soapenv:Envelope>

Listener hinzufügen

Das letzte Element, das Sie Ihrem Testplan hinzufügen müssen, ist ein Listener. Dieses Element ist dafür verantwortlich, alle Ergebnisse Ihrer HTTP-Anforderungen in einer Datei zu speichern und ein visuelles Modell der Daten darzustellen.

• Wählen Sie das Webservice-Benutzerelement aus.

• Fügen Sie einen Listener zum Anzeigen des Ergebnisbaums hinzu, indem Sie Hinzufügen → Listener → Ergebnisbaum anzeigen auswählen.

Führen Sie den Testplan aus

Speichern Sie nun den obigen Testplan als test_webservice.jmx . Führen Sie diesen Testplan mit der Option Ausführen → Start aus.

Zeigen Sie die Ausgabe an

Die folgende Ausgabe ist im Listener zu sehen.

Im letzten Bild sehen Sie die Antwortnachricht "Hallo Manisha an JAX WS world".

In diesem Kapitel erfahren Sie, wie Sie einen einfachen Testplan zum Testen des Java Messaging Service (JMS) erstellen. JMS unterstützt zwei Arten von Nachrichten:

• Point-to-Point messaging- Queue Messaging wird im Allgemeinen für Transaktionen verwendet, bei denen der Absender eine Antwort erwartet. Messaging-Systeme unterscheiden sich erheblich von normalen HTTP-Anforderungen. In HTTP sendet ein einzelner Benutzer eine Anfrage und erhält eine Antwort.

• Topic messaging- Themennachrichten werden allgemein als Pub- / Subnachrichten bezeichnet. Topic Messaging wird im Allgemeinen in Fällen verwendet, in denen eine Nachricht von einem Produzenten veröffentlicht und von mehreren Abonnenten konsumiert wird.

Lassen Sie uns für jedes dieser Beispiele ein Testbeispiel sehen. Die Voraussetzungen zum Testen von JMS sind:

• Im Beispiel verwenden wir Apache ActiveMQ. Es gibt verschiedene JMS-Server wie IBM WebSphere MQ (ehemals MQSeries), Tibco usw. Laden Sie sie von den Binärdateien der Apache ActiveMQ-Website herunter.

• Entpacken Sie das Archiv, wechseln Sie in das dekomprimierte Verzeichnis und führen Sie den folgenden Befehl über die Befehlskonsole aus, um den ActiveMQ-Server zu starten:

.\bin\activemq  start

Sie können überprüfen, ob der ActiveMQ-Server gestartet wurde, indem Sie die Administrationsoberfläche unter der folgenden Adresse aufrufen http://localhost:8161/admin/. Wenn Sie zur Authentifizierung aufgefordert werden, geben Sie die Benutzer-ID und das Kennwort als Administrator ein . Der Bildschirm ist ähnlich wie unten gezeigt -

• Kopieren Sie nun das activemq-all-xxxjar (XXX je nach Version) aus dem entpackten ActiveMQ-Verzeichnis in /home/manisha/apache-jmeter-2.9/lib.

Lassen Sie uns mit dem obigen Setup den Testplan für - erstellen.

• JMS-Punkt-zu-Punkt-Testplan

• JMS-Thementestplan

In diesem Kapitel wird erläutert, wie Sie mit JMeter einen Testplan zur Überwachung von Webservern erstellen. Die Verwendung von Monitortests ist wie folgt:

• Monitore sind nützlich für Stresstests und Systemmanagement.

• Bei Stresstests bietet der Monitor zusätzliche Informationen zur Serverleistung.

• Monitore erleichtern das Erkennen der Beziehung zwischen Serverleistung und Antwortzeit auf der Clientseite.

• Als Systemadministrationstool bietet der Monitor eine einfache Möglichkeit, mehrere Server von einer Konsole aus zu überwachen.

Für die Überwachung benötigen wir Tomcat 5 oder höher. Zu unserem Testzweck überwachen wir den Tomcat 7.0.42-Server. Sie können jeden Servlet-Container testen, der Java Management Extension (JMX) unterstützt. Lassen Sie uns einen Testfall schreiben, um den Tomcat-Server zu überwachen. Lassen Sie uns zuerst unseren Tomcat-Server einrichten.

Richten Sie den Tomcat-Server ein

Wir beginnen mit dem Öffnen des Tomcat-Servicestatus. Bearbeiten Sie dazu die Konfigurationsdatei für Benutzer.<TOMCAT_HOME>/conf/tomcat-users.xml. Diese Datei enthält einen Tomcat-Benutzerabschnitt (kommentiert) wie gezeigt -

<tomcat-users>

<!--
   <role rolename = "tomcat"/>
   <role rolename = "role1"/>
   <user username = "tomcat" password = "tomcat" roles = "tomcat"/>
   <user username = "both" password = "tomcat" roles = "tomcat,role1"/>
   <user username = "role1" password = "tomcat" roles = "role1"/>
-->

</tomcat-users>

Wir müssen diesen Abschnitt ändern, um die Administratorrollen, Manager, Manager-GUI hinzuzufügen und dem Benutzer "Administrator" zuzuweisen. Die überarbeitete Datei lautet wie folgt:

<tomcat-users>

   <role rolename = "manager-gui"/>
   <role rolename = "manager-script"/>
   <role rolename = "manager-jmx"/>
   <role rolename = "manager-status"/>
   <user username = "admin" password = "admin" roles = "manager-gui,manager-script,manager-jmx,manager-status"/>

</tomcat-users>

Starten Sie nun den Tomcat-Server <TOMCAT_HOME> /bin/startup.sh für Linux und <TOMCAT_HOME> /bin/startup.bat für Windows. Überprüfen Sie nach dem Start, ob die Tomcat-Überwachung funktioniert, indem Sie den folgenden Link in Ihren Browser eingeben:

http://localhost:8080/manager/status?XML=true

Im Browser wird ein Authentifizierungsfenster angezeigt. Geben Sie das Tomcat-Login und das zugehörige Passwort ein (in unserem Fall ist es admin). Anschließend zeigt der Browser den Ausführungsstatus von Tomcat wie folgt an:

Aus dem obigen Screenshot können wir einige Dinge ersehen -

• Beachten Sie in der URL, dass XML = true (beachten Sie die Groß- und Kleinschreibung beachten) eine saubere Anzeige des für die JMeter-Funktion erforderlichen Überwachungs-Tomcat ermöglicht.

• Beachten Sie auch, dass standardmäßig zwei Anschlüsse vorhanden sind. Der im Allgemeinen verwendete AJP-Connector ist mit dem Apache HTTPD-Frontmodul mod_jk und dem HTTP-Connector gekoppelt, der üblicherweise für den direkten Zugriff auf Tomcat über Port 8080 verwendet wird.

Schreiben Sie den JMeter-Testplan

Lassen Sie uns den Tomcat-Server überwachen, indem wir einen Testplan schreiben -

Testplan umbenennen

• Öffnen Sie das JMeter-Fenster, indem Sie auf /home/manisha/apache-jmeter2.9/bin/jmeter.sh klicken.

• Klicken Sie auf den Knoten Testplan.

• Fügen Sie eine Thread-Gruppe hinzu, wie im nächsten Schritt erläutert.

Thread-Gruppe hinzufügen

• Klicken Sie mit der rechten Maustaste auf Test Plan → Add → Threads(Users) → Thread Group. Die Thread-Gruppe wird unter dem Knoten Testplan hinzugefügt.

• Ändern Sie die Anzahl der Schleifen auf für immer (oder auf eine große Anzahl), damit genügend Samples generiert werden.

HTTP Authorization Manager

• Fügen Sie dem Thread-Gruppenelement HTTP Authorization Manager hinzu, indem Sie Hinzufügen → Konfigurationselement → HTTP Authorization Manager auswählen. Dieses Element verwaltet die vom Browser angeforderte Authentifizierung, um den Tomcat-Serverstatus anzuzeigen.

• Wählen Sie den HTTP Authorization Manager aus.

• Bearbeiten Sie die folgenden Details -

  • Username - admin (abhängig von der Konfiguration in der Datei tomcat-users.xml)

  • Password - admin (abhängig von der Konfiguration in der Datei tomcatusers.xml)

  • Die anderen Felder bleiben leer.

Sampler-HTTP-Anfrage hinzufügen

Nachdem wir unsere Benutzer definiert haben, ist es Zeit, die Aufgaben zu definieren, die sie ausführen werden. Wir fügen ein HTTP-Anforderungselement hinzu.

• Klicken Sie mit der rechten Maustaste, um das Menü Hinzufügen aufzurufen.

• Wählen Sie Hinzufügen → Sampler → HTTP-Anfrage.

• Wählen Sie dann das HTTP-Anforderungselement in der Baumstruktur aus.

• Bearbeiten Sie die folgenden Eigenschaften wie im Bild unten -

• Die folgenden Details werden in dieses Element eingegeben -

  • Name - Serverstatus

  • Server Name or IP - localhost

  • Port - 8080

  • Path - / manager / status

  • Parameters- Fügen Sie einen Anforderungsparameter mit dem Namen "XML" in Großbuchstaben hinzu. Geben Sie den Wert "true" in Kleinbuchstaben ein.

  • Optional Tasks - Aktivieren Sie "Als Monitor verwenden" unten im Sampler.

Fügen Sie einen konstanten Timer hinzu

Um den Status des Servers regelmäßig anzufordern, fügen Sie einen konstanten Timer hinzu, der ein Zeitintervall zwischen den einzelnen Anforderungen zulässt. Fügen Sie dieser Thread-Gruppe einen Timer hinzu, indem Sie Hinzufügen → Timer → Konstanter Timer auswählen.

Geben Sie 5000 Millisekunden in das Feld Thread-Verzögerung ein . Im Allgemeinen kann die Verwendung von Intervallen von weniger als 5 Sekunden Ihren Server belasten. Finden Sie heraus, welches Intervall akzeptabel ist, bevor Sie den Monitor in Ihrer Produktionsumgebung bereitstellen.

Listener hinzufügen

Das letzte Element, das Sie Ihrem Testplan hinzufügen müssen, ist ein Listener. Wir fügen zwei Arten von Zuhörern hinzu. Eine, die Ergebnisse in einer Datei speichert, und eine, die die grafische Ansicht der Ergebnisse zeigt.

• Wählen Sie das Threadgruppenelement aus.

• Hinzufügen eines Simple Data Writer-Listeners Hinzufügen → Listener → Simple Data Writer.

• Geben Sie ein Verzeichnis und einen Dateinamen der Ausgabedatei an (in unserem Fall ist es /home/manisha/work/sample.csv).

• Fügen Sie einen weiteren Listener hinzu, indem Sie das Testplanelement Hinzufügen → Listener → Ergebnisse überwachen auswählen.

Führen Sie den Testplan aus

Speichern Sie nun den obigen Testplan als monitor_test.jmx . Führen Sie diesen Testplan mit der Option Ausführen → Start aus.

Zeigen Sie die Ausgabe an

Die Ergebnisse werden in der Datei /home/manisha/work/sample.csv gespeichert. Sie können auch ein grafisches Ergebnis im Monitor-Ergebnis-Listener sehen (siehe Abbildung unten).

Beachten Sie, dass das Diagramm auf beiden Seiten des Diagramms Beschriftungen enthält. Links ist Prozent und rechts ist tot / gesund. Wenn die Speicherleitung schnell auf und ab geht, kann dies auf eine Speicherüberlastung hinweisen. In solchen Situationen empfiehlt es sich, die Anwendung mit Borland OptimizeIt oder JProbe zu profilieren. Was Sie sehen möchten, ist ein reguläres Muster für Laden, Speicher und Threads. Jedes unberechenbare Verhalten weist normalerweise auf eine schlechte Leistung oder einen Fehler hin.

Listener bieten Zugriff auf die Informationen, die JMeter über die Testfälle sammelt, während JMeter ausgeführt wird. Die von den Zuhörern gesammelten Ergebnisse oder Informationen können in Form von - angezeigt werden

• tree
• tables
• graphs
• Logdatei

Alle Listener schreiben die gleichen Rohdaten in die Ausgabedatei, wenn eine angegeben wird.

Standardkonfiguration

Die zu speichernden Standardelemente können auf eine der folgenden zwei Arten definiert werden:

• In dem jmeter.properties(oder user.properties) Datei. Diese Datei befindet sich in der/bin Ordner von JMeter. Um das Standardformat zu ändern, suchen Sie die folgende Zeile in jmeter.properties -

jmeter.save.saveservice.output_format=

• Verwenden Sie das Konfigurations-Popup wie im folgenden Screenshot gezeigt -

JMeter erstellt Ergebnisse eines Testlaufs als JMeter Text Logs (JTL). Diese werden normalerweise als JTL-Dateien bezeichnet, da dies die Standarderweiterung ist. Es kann jedoch jede Erweiterung verwendet werden.

Wenn mehrere Tests mit demselben Ausgabedateinamen ausgeführt werden, hängt JMeter automatisch neue Daten am Ende der Datei an.

Der Listener kann Ergebnisse in einer Datei, jedoch nicht in der Benutzeroberfläche aufzeichnen. Es soll ein effizientes Mittel zum Aufzeichnen von Daten bieten, indem der GUI-Overhead eliminiert wird.

Beim Einlaufen -

• GUI mode - Verwenden Sie den Listener Simple Data Writer

• non-GUI mode - Mit dem Flag -l kann eine Datendatei erstellt werden.

Hörer können viel Speicher verwenden, wenn es viele Samples gibt. Verwenden Sie das Simple Data Write mit CSV-Format, um den Speicherbedarf zu minimieren.

CSV-Protokollformat

Das CSV-Protokollformat hängt davon ab, welche Datenelemente in der Konfiguration ausgewählt sind. In der Datei werden nur die angegebenen Datenelemente aufgezeichnet. Die Reihenfolge des Auftretens von Spalten ist festgelegt und lautet wie folgt:

Feld	Beschreibung	Wertebeispiel
Zeitstempel	in Millisekunden seit dem 1.1.1970	1354223881017
verstrichen	in Millisekunden	1858
Etikette	Sampler-Label	HTTP-Anfrage
Antwortcode	zB 200, 404	200
responseMessage	zB OK	in Ordnung
threadName		Gewindegruppe 1-1
Datentyp	zB Text	Text
Erfolg	richtig oder falsch	wahr
failMessage	wenn überhaupt
Bytes	Anzahl der Bytes in der Stichprobe	34908
grpThreads	Anzahl der aktiven Threads in dieser Thread-Gruppe	1
Alle Themen	Gesamtzahl der aktiven Threads in allen Gruppen	1
URL		http://tutorialspoint.com
Dateiname	wenn Antwort in Datei speichern verwendet wurde
Latenz	Zeit bis zur ersten Antwort	132
Codierung		utf-8
SampleCount	Anzahl der Proben (1, sofern nicht mehrere Proben aggregiert sind)	1
ErrorCount	Anzahl der Fehler (0 oder 1, sofern nicht mehrere Stichproben zusammengefasst sind)	0
Hostname	wo die Probe erzeugt wurde	LaptopManisha
Wartezeit	Anzahl der Millisekunden Leerlaufzeit (normalerweise 0)
Variablen	falls angegeben

Antwortdaten speichern

Die Antwortdaten können bei Bedarf in der XML-Protokolldatei gespeichert werden. Es ist jedoch nicht möglich, große Dateien und Bilder zu speichern. Verwenden Sie in solchen Fällen den Postprozessor Save_Responses_to_a_file. Dadurch wird für jedes Beispiel eine neue Datei generiert und der Dateiname mit dem Beispiel gespeichert. Der Dateiname kann dann in die Beispielprotokollausgabe aufgenommen werden. Die Daten werden bei Bedarf aus der Datei abgerufen, wenn die Beispielprotokolldatei erneut geladen wird.

Laden (Lesen) von Antwortdaten

Um eine vorhandene Ergebnisdatei anzuzeigen, können Sie über die Schaltfläche "Durchsuchen ..." eine Datei auswählen. Erstellen Sie bei Bedarf einfach einen Dummy-Testplan mit dem entsprechenden Listener.

Speichern der Listener-GUI-Daten

JMeter kann jeden Listener als PNG-Datei speichern. Um dies zu tun,

• Wählen Sie den Listener im linken Bereich aus, indem Sie Bearbeiten → Als Bild speichern auswählen. Ein Dateidialog wird angezeigt.

• Geben Sie den gewünschten Namen ein.

• Speichern Sie den Listener.

JMeter-Funktionen und Benutzervariablen

JMeter-Funktionen sind spezielle Werte, mit denen Felder eines Samplers oder eines anderen Elements in einem Testbaum ausgefüllt werden können.

• Ein Funktionsaufruf sieht so aus -

${__functionName(var1,var2,var3)}

• _functionName entspricht dem Namen einer Funktion. Zum Beispiel${__threadNum}.

• Wenn ein Funktionsparameter ein Komma enthält, stellen Sie sicher, dass Sie dies mit "\" maskieren, wie unten gezeigt -

${__time(EEE\, d MMM yyyy)}

• Variablen werden als - bezeichnet

${VARIABLE}

Liste der Funktionen

Die folgende Tabelle listet eine Gruppe von Funktionen auf, die lose in Typen gruppiert sind -

Funktionstyp	Name	Kommentar
Information	threadNum	Thread-Nummer abrufen.
Information	samplerName	Holen Sie sich den Namen des Samplers (Label).
Information	machineIP	Rufen Sie die IP-Adresse des lokalen Computers ab.
Information	Maschinenname	Rufen Sie den lokalen Computernamen ab.
Information	Zeit	Gibt die aktuelle Zeit in verschiedenen Formaten zurück.
Information	Log	Protokollieren (oder anzeigen) Sie eine Nachricht (und geben Sie den Wert zurück).
Information	logn	Protokollieren (oder Anzeigen) einer Nachricht (leerer Rückgabewert).
Eingang	StringFromFile	Lesen Sie eine Zeile aus einer Datei.
Eingang	FileToString	Lesen Sie eine ganze Datei.
Eingang	CSVRead	Aus CSV-getrennter Datei lesen.
Eingang	XPath	Verwenden Sie einen XPath-Ausdruck, um aus einer Datei zu lesen.
Berechnung	Zähler	Generieren Sie eine inkrementelle Nummer.
Berechnung	intSum	Fügen Sie int-Nummern hinzu.
Berechnung	longSum	Fügen Sie lange Zahlen hinzu.
Berechnung	Zufällig	Generieren Sie eine Zufallszahl.
Berechnung	RandomString	Generieren Sie eine zufällige Zeichenfolge.
Berechnung	UUID	Generieren Sie eine zufällige UUID vom Typ 4.
Skripting	BeanShell	Führen Sie ein BeanShell-Skript aus.
Skripting	JavaScript	Verarbeiten Sie JavaScript (Mozilla Rhino).
Skripting	jexl, jexl2	Bewerten Sie einen Commons Jexl-Ausdruck.
Eigenschaften	Eigentum	Lesen Sie eine Eigenschaft.
Eigenschaften	P.	Lesen Sie eine Eigenschaft (Kurzmethode).
Eigenschaften	setProperty	Legen Sie eine JMeter-Eigenschaft fest.
Variablen	Teilt	Teilen Sie eine Zeichenfolge in Variablen auf.
Variablen	V.	Bewerten Sie einen Variablennamen.
Variablen	eval	Bewerten Sie einen variablen Ausdruck.
Variablen	evalVar	Bewerten Sie einen in einer Variablen gespeicherten Ausdruck.
String	regexFunction	Analysieren Sie die vorherige Antwort mit einem regulären Ausdruck.
String	EscapeOroRegexpChars	Zitieren Sie Metazeichen, die vom regulären ORO-Ausdruck verwendet werden.
String	verkohlen	Generieren Sie Unicode-Zeichenwerte aus einer Liste von Zahlen.
String	entkommen	Prozesszeichenfolgen, die Java-Escapezeichen enthalten (z. B. \ n & \ t).
String	unescapeHtml	HTML-codierte Zeichenfolgen dekodieren.
String	EscapeHtml	Codieren Sie Zeichenfolgen mithilfe der HTML-Codierung.
String	TestPlanName	Gibt den Namen des aktuellen Testplans zurück.

• Es gibt zwei Arten von Funktionen -

  • Benutzerdefinierte statische Werte (oder Variablen)

  • Eingebaute Funktionen

• Mit benutzerdefinierten statischen Werten kann der Benutzer Variablen definieren, die durch ihren statischen Wert ersetzt werden sollen, wenn ein Testbaum kompiliert und zur Ausführung übermittelt wird.

• Die Variablen können nicht verschachtelt werden. dh${Var${N}} funktioniert nicht.

• Hierzu kann die Funktion __V (Variable) (Versionen nach 2.2) verwendet werden - $ {__ V (Var $ {N})}.

• Diese Art des Austauschs ist ohne Funktionen möglich, jedoch weniger bequem und weniger intuitiv.

Verwendung von Funktionen und Variablen

Funktionen und Variablen können in jedes Feld einer beliebigen Testkomponente geschrieben werden.

Die folgenden Funktionen sollten in einem Testplan gut funktionieren -

• intSum
• longSum
• machineName
• BeanShell
• javaScript
• jexl
• random
• time
• Eigenschaftsfunktionen
• Protokollfunktionen

Funktionen, die im Testplan verwendet werden, unterliegen einigen Einschränkungen. JMeter-Thread-Variablen wurden bei der Verarbeitung der Funktionen nicht vollständig eingerichtet, sodass Variablennamen, die als Parameter übergeben wurden, nicht eingerichtet werden und Variablenreferenzen nicht funktionieren. Daher funktionieren split () und regex () sowie die Variablenauswertungsfunktionen nicht. Die Funktion threadNum () funktioniert nicht und ist auf Testplanebene nicht sinnvoll.

Variablen und Funktionen referenzieren

• Das Referenzieren einer Variablen in einem Testelement erfolgt durch Klammern des Variablennamens mit '$ {' und '}'.

• Funktionen werden auf die gleiche Weise referenziert, aber üblicherweise beginnen die Namen von Funktionen mit "__", um Konflikte mit Benutzerwertnamen zu vermeiden.

• Einige Funktionen verwenden Argumente, um sie zu konfigurieren, und diese stehen in Klammern, durch Kommas getrennt. Wenn die Funktion keine Argumente akzeptiert, können die Klammern weggelassen werden. Zum Beispiel -

${__BeanShell(vars.put("name"\,"value"))}

• Alternativ können Sie Ihr Skript als Variable definieren, z. B. im Testplan -

SCRIPT     vars.put("name","value")

• Das Skript kann dann wie folgt referenziert werden:

${__BeanShell(${SCRIPT})}

Der Funktionshilfedialog

Der Funktionshilfedialog ist bei JMeter erhältlich Options Tab.

• Mit dem Funktionshelfer können Sie eine Funktion aus dem Pulldown auswählen und Werte für ihre Argumente zuweisen. Die linke Spalte in der Tabelle enthält eine kurze Beschreibung des Arguments. In der rechten Spalte schreiben Sie den Wert für dieses Argument. Unterschiedliche Funktionen haben unterschiedliche Argumente.

• Sobald Sie dies getan haben, klicken Sie auf die Schaltfläche "Generieren", und die entsprechende Zeichenfolge wird generiert, die Sie kopieren und in den Testplan einfügen können, wo immer Sie möchten.

Vordefinierte Variablen

Einige Variablen werden intern von JMeter definiert. Sie sind -

• COOKIE_cookiename - enthält den Cookie-Wert.

• JMeterThread.last_sample_ok - ob das letzte Beispiel OK war oder nicht - wahr / falsch. Hinweis - Dies wird aktualisiert, nachdem PostProcessors und Assertions ausgeführt wurden.

• START-Variablen.

Vordefinierte Eigenschaften

Einige integrierte Eigenschaften werden von JMeter definiert. Diese sind unten aufgeführt. Der Einfachheit halber werden die START-Eigenschaften auch in gleichnamige Variablen kopiert.

• START.MS - JMeter-Startzeit in Millisekunden.

• START.YMD - JMeter-Startzeit als JJJJMMTT.

• START.HMS - JMeter Startzeit als HHmmss.

• TESTSTART.MS - Teststartzeit in Millisekunden.

Beachten Sie, dass die START-Variablen / -Eigenschaften die JMeter-Startzeit und nicht die Teststartzeit darstellen. Sie sind hauptsächlich zur Verwendung in Dateinamen usw. vorgesehen.

Reguläre Ausdrücke werden verwendet, um Text basierend auf Mustern zu suchen und zu bearbeiten. JMeter interpretiert Formen regulärer Ausdrücke oder Muster, die in einem JMeter-Testplan verwendet werden, unter Einbeziehung der Mustervergleichssoftware Apache Jakarta ORO .

Durch die Verwendung regulärer Ausdrücke können wir sicherlich viel Zeit sparen und mehr Flexibilität erzielen, wenn wir einen Testplan erstellen oder verbessern. Reguläre Ausdrücke bieten eine einfache Methode, um Informationen von Seiten abzurufen, wenn es unmöglich oder sehr schwierig ist, ein Ergebnis vorherzusagen.

Ein Standardverwendungsbeispiel für die Verwendung von Ausdrücken besteht darin, eine Sitzungs-ID aus der Serverantwort abzurufen. Wenn der Server einen eindeutigen Sitzungsschlüssel zurückgibt, können wir ihn leicht mithilfe von Ausdrücken in unserem Ladeskript abrufen.

Um reguläre Ausdrücke in Ihrem Testplan zu verwenden, müssen Sie den Regular Expression Extractor von JMeter verwenden. Sie können reguläre Ausdrücke in jede Komponente eines Testplans einfügen.

Es lohnt sich, den Unterschied zwischen zu betonen contains und matches, wie für das Testelement Response Assertion verwendet -

• containsbedeutet, dass der reguläre Ausdruck mindestens einem Teil des Ziels entspricht, sodass "Alphabet" "ph.b." enthält. weil der reguläre Ausdruck mit der Teilzeichenfolge 'phabe' übereinstimmt.

• matchesbedeutet, dass der reguläre Ausdruck mit dem gesamten Ziel übereinstimmt. Daher wird das 'Alphabet' mit 'al. * T' "abgeglichen".

Angenommen, Sie möchten dem folgenden Teil einer Webseite entsprechen:

name = "file" value = "readme.txt"

Und Sie möchten readme.txt extrahieren. Ein geeigneter regulärer Ausdruck wäre -

name = "file" value = "(.+?)">

Die obigen Sonderzeichen sind -

• ( und ) - Diese schließen den Teil der zurückzugebenden Übereinstimmungszeichenfolge ein

• . - mit einem beliebigen Zeichen übereinstimmen

• + - einmal oder mehrmals

• ? - Stoppen Sie, wenn das erste Spiel erfolgreich ist

Erstellen Sie einen JMeter-Testplan

Lassen Sie uns die Verwendung von regulären Ausdrücken im Extraktor für reguläre Ausdrücke - einem Postprozessorelement - verstehen, indem Sie einen Testplan schreiben. Dieses Element extrahiert Text von der aktuellen Seite mithilfe eines regulären Ausdrucks, um das Textmuster zu identifizieren, dem ein gewünschtes Element entspricht.

Zuerst schreiben wir eine HTML-Seite, die eine Liste der Personen und ihrer E-Mail-IDs enthält. Wir stellen es auf unserem Tomcat-Server bereit. Der Inhalt von HTML (index.html) ist wie folgt:

<html>
   <head>
   </head>
	
   <body>
      <table style = "border: 1px solid #000000;">
		
         <th style = "border: 1px solid #000000;">ID</th>
         <th style = "border: 1px solid #000000;">name</th>
         <th style = "border: 1px solid #000000;">Email</th>
			
         <tr>
            <td id = "ID" style = "border: 1px solid #000000;">3</td>
            <td id = "Name" style = "border: 1px solid #000000;">Manisha</td>
            <td id = "Email" style = "border: 1px solid #000000;">[email protected]</td>
         </tr>
			
         <tr>
            <td id = "ID" style = "border: 1px solid #000000;">4</td>
            <td id = "Name" style = "border: 1px solid #000000;">joe</td>
            <td id = "Email" style = "border: 1px solid #000000;">[email protected]</td>
         </tr>
			
      </table>
   </body>
</html>

Bei der Bereitstellung auf dem Tomcat-Server sieht diese Seite wie im folgenden Screenshot dargestellt aus:

In unserem Testplan wählen wir die Person in der ersten Zeile der Personentabelle aus, die auf der Seite mit der Personenliste oben angezeigt wird. Um die ID dieser Person zu erfassen, bestimmen wir zunächst das Muster, in dem wir die Person in der zweiten Reihe finden.

Wie im folgenden Schnappschuss zu sehen ist, ist die ID der zweiten Person von <td id = "ID"> und </ td> umgeben, und es ist die zweite Datenzeile mit diesem Muster. Wir können dies verwenden, um genau das Muster zu finden, aus dem wir Informationen extrahieren möchten. Da wir auf dieser Seite zwei Informationen extrahieren möchten, die Personen-ID und den Personennamen, werden die Felder wie folgt definiert:

Starten Sie JMeter und fügen Sie eine Thread-Gruppe hinzu Test Plan → Add→ Threads(Users)→ Thread Group.

Fügen Sie als Nächstes eine Sampler-HTTP-Anforderung hinzu, wählen Sie den Testplan aus und klicken Sie mit der rechten Maustaste Add → Sampler → HTTP Request und geben Sie die Details wie unten gezeigt ein -

• Name - Verwalten

• Server Name or IP - localhost

• Port Number - 8080

• Protocol - Wir werden dieses Feld leer lassen, was bedeutet, dass wir HTTP als Protokoll wollen.

• Path - jmeter / index.html

Fügen Sie als Nächstes einen Extraktor für reguläre Ausdrücke hinzu. Wählen Sie den HTTP Request Sampler (Verwalten) aus und klicken Sie mit der rechten MaustasteAdd → Post Processor → Regular Expression Extractor.

Die folgende Tabelle enthält eine Beschreibung der im obigen Screenshot verwendeten Felder -

Sr.Nr.	Feld Beschreibung
1	Reference Name Der Name der Variablen, in der der extrahierte Test gespeichert wird (Referenzname).
2	Regular Expression Das Muster, mit dem der zu extrahierende Text abgeglichen wird, wird abgeglichen. Die zu extrahierenden Textgruppen werden von den Zeichen '(' und ')' eingeschlossen. Wir verwenden '. +?' um eine einzelne Instanz des von den Tags <td ..> .. </ td> eingeschlossenen Textes anzugeben. In unserem Beispiel lautet der Ausdruck - <td id = "ID"> (+?) </ Td> \ s * <td id = "Name"> (+?) </ Td> \ s *
3	Template Jede Gruppe von extrahiertem Text, die als Mitglied der Variablen Person platziert wird, folgt der Reihenfolge jeder Gruppe von Mustern, die durch '(' und ')' eingeschlossen sind. Jede Gruppe wird als refname_g # gespeichert, wobei refname die Zeichenfolge ist, die Sie als Referenzname eingegeben haben, und # die Gruppennummer ist. $ 1 $ bezieht sich auf Gruppe 1, $ 2 $ bezieht sich auf Gruppe 2 usw. $ 0 $ bezieht sich auf alles, was mit dem gesamten Ausdruck übereinstimmt. In diesem Beispiel wird die von uns extrahierte ID in Person_g1 beibehalten, während der Wert Name in Person_g2 gespeichert wird.
4	Match No. Da wir nur das zweite Vorkommen dieses Musters extrahieren möchten, das mit dem zweiten Freiwilligen übereinstimmt, verwenden wir den Wert 2. Der Wert 0 würde eine zufällige Übereinstimmung ergeben, während mit dem ForEach-Controller ein negativer Wert verwendet werden muss.
5	Default Wenn das Element nicht gefunden wird, ist dies der Standardwert. Dies ist ein optionales Feld. Sie können es leer lassen.

Fügen Sie einen Listener hinzu, um das Ergebnis dieses Testplans zu erfassen. Klicken Sie mit der rechten Maustaste auf die Thread-Gruppe und wählen Sie die Option Hinzufügen → Listener → Ergebnisbaum anzeigen, um den Listener hinzuzufügen.

Speichern Sie den Testplan als reg_express_test.jmx und führen Sie den Test aus. Die Ausgabe wäre ein Erfolg, wie im folgenden Screenshot gezeigt -

JMeter weist einige Einschränkungen auf, insbesondere wenn es in einer verteilten Umgebung ausgeführt wird. Das Befolgen dieser Richtlinien hilft bei der Schaffung einer realen und kontinuierlichen Last -

• Verwenden Sie mehrere Instanzen von JMeter, falls die Anzahl der Threads höher ist.

• Überprüfen Sie die Scoping-Regeln und gestalten Sie sie entsprechend.

• Verwenden Sie Namenskonventionen immer für alle Elemente.

• Überprüfen Sie die Standardkonnektivitätseinstellungen des Browsers, bevor Sie Skripts ausführen.

• Fügen Sie Listener entsprechend hinzu.

• Hier einige Vorschläge zur Reduzierung des Ressourcenbedarfs:

• Verwenden Sie den Nicht-GUI-Modus: jmeter -n -t test.jmx -l test.jtl.

• Verwenden Sie so wenig Listener wie möglich. Wenn Sie das Flag -l wie oben verwenden, können alle gelöscht oder deaktiviert werden.

• Deaktivieren Sie den Listener "View Result Tree", da er viel Speicher verbraucht und dazu führen kann, dass die Konsole einfriert oder JMeter nicht mehr über genügend Speicher verfügt. Es ist jedoch sicher, den Listener "Ergebnisbaum anzeigen" zu verwenden, bei dem nur "Fehler" aktiviert ist.

• Verwenden Sie nicht viele ähnliche Sampler, sondern denselben Sampler in einer Schleife und verwenden Sie Variablen (CSV-Datensatz), um die Probe zu variieren. Oder verwenden Sie den Access Log Sampler.

• Verwenden Sie nicht den Funktionsmodus.

• Verwenden Sie CSV-Ausgabe anstelle von XML.

• Speichern Sie nur die Daten, die Sie benötigen.

• Verwenden Sie so wenig Zusicherungen wie möglich.

• Deaktivieren Sie alle JMeter-Diagramme, da sie viel Speicher belegen. Sie können alle Echtzeitdiagramme über die Registerkarte JTLs in Ihrer Weboberfläche anzeigen.

• Vergessen Sie nicht, den lokalen Pfad aus der CSV-Datensatzkonfiguration zu löschen, falls verwendet.

• Reinigen Sie die Registerkarte "Dateien" vor jedem Testlauf.