In diesem ausführlichen Tutorial zu Rest Assured lernen wir das Rest API Testing in der Tiefe, API Test Automation zusammen mit Rest Assured in modularisiertem Ansatz
Was ist RestAssured und seine Verwendung?
Rest Assured ist eine sehr weit verbreitete Open Source-Technologie für REST API Automation Testing, die auf einer Java-basierten Bibliothek basiert.
Rest Assured interagiert mit der Rest-API in einem Headless-Client-Modus. Wir können dieselbe Anforderung verbessern, indem wir verschiedene Ebenen hinzufügen, um die Anforderung zu bilden und eine HTTP-Anforderung über verschiedene HTTPS-Verben auf dem Server zu erstellen.
Die in Rest Assured integrierte Bibliothek bietet enorme Methoden und Dienstprogramme, um die vom Server empfangene Antwort zu validieren, z. B. Statusnachricht, Statuscode und Antworttext.
Diese vollständige Reihe von Rest Assured-Lernprogrammen für REST API-Automatisierungstests besteht aus den folgenden Themen:
Erste Schritte: Konfiguration von restAssured mit dem Build-Tool, dh Maven / gradle
SCHRITT 1: Wenn Sie mit maven arbeiten, fügen Sie einfach die folgende Abhängigkeit in pom.xml hinzu (Sie können auch eine andere Version auswählen):
Um mit REST Assured zu beginnen, fügen Sie einfach die Abhängigkeit zu Ihrem Projekt hinzu.
Ich bin versichert seien Sie versichert 4.3.0 Prüfung
Wenn Sie mit gradle arbeiten, fügen Sie einfach Folgendes in build.gradle hinzu (Sie können auch eine andere Version auswählen):
testCompile-Gruppe: 'io.rest-versichert', Name: 'rest-versichert', Version: '4.3.0'SCHRITT 2: REST Assured kann sehr einfach in die vorhandenen Unit-Test-Frameworks integriert und verwendet werden, z. B. Testng, JUnit
Hier verwenden wir testNg gemäß dem betreffenden Unit Test Framework.
Sobald die Bibliotheken von Rest Assured importiert wurden, müssen wir unseren Testklassen die folgenden statischen Importe hinzufügen:
statisches io.restassured.RestAssured importieren. *;statische org.hamcrest.Matchers importieren. *;
HINWEIS: Für diesen bevorstehenden Lernzweck testen wir die Ergast Developer API. welche finden Sie hier. Diese API bietet historische Daten zu Formel-1-Rennen, Fahrern, Rennstrecken usw.
Vertrautheit mit der Syntax:
Rest Assured unterstützt das BDD-Format (Gurkensyntax) um die Testskripte zu schreiben, dh im Format Gegeben / Wann / Dann / Und, gehen wir davon aus, dass Sie Verständnis für die BDD / Gurken-Syntax haben. Wenn nicht, empfehlen wir Ihnen, 30 Minuten Zeit zu investieren, um zu verstehen, was BDD ist (Gurkensyntax) und wie funktioniert es und es ist sehr einfach.
T-01: Unser erstes Skript, das im Wesentlichen die Anzahl der Schaltkreise in F1 im Jahr 1 mithilfe dieser API überprüft (http://ergast.com/api/f1/2017/circuits.json)
@Test (description = "Anzahl der Schaltungen in der Saison 2017 sollte 20 sein") public void validatingNumberOfCircuits () {Given (). When (). Get ("http://ergast.com/api/f1/2017/circuits. json "). then (). assertThat (). body ("MRData.CircuitTable.Circuits.circuitId", hasSize (20)); }}Validierung der Rest-API-Antwort :
1. Erfasst die JSON-Antwort der API-Anforderung.
2. Abfragen für die CircuitId mit dem GPath-Ausdruck "MRData.CircuitTable.Circuits.circuitId"
3. Überprüft, ob die Sammlung der CircuitId-Elemente die Größe 20 hat
Hier verwenden wir Hamcrest Matcher für verschiedene Validierungen wie
Es gibt verschiedene andere Methoden, die nützlich sind, um eine bestimmte Validierung durchzuführen.
Eine vollständige Liste der Matcher und Methoden finden Sie in der Dokumentation zur Hamcrest-Bibliothek.
Antwortcode validieren:
gegeben (). wann (). get ("http://ergast.com/api/f1/2017/circuits.json") .then (). assertThat (). statusCode (200);
Validierung des Inhaltstyps
Given (). when (). get ("http://ergast.com/api/f1/2017/circuits.json") .then (). assertThat (). contentType (ContentType.JSON);Überprüfen des Headers "Content-Length"
gegeben (). wann (). get ("http://ergast.com/api/f1/2017/circuits.json") .then (). assertThat (). header (" Content-Length ", gleichTo (" 4551 "));
Mehrfachvalidierung in einem einzigen Test als (mit und) Methoden:
@Test (description = "Anzahl der Strecken in der Saison 2017 sollte 20 sein")
public void validatingNumberOfCircuits () {
Given (). when (). get ("http://ergast.com/api/f1/2017/circuits.json") .then (). assertThat (). header ("Content-Length", sameTo (") 4551 ")). Und (). StatusCode (200);
}Überprüfen des Antwortkörperelements / -attributs:
Wir können JsonPath verwenden, um den Wert der json-Attribute abzurufen und die Assertion mit TestNg zu setzen
@Test (description = "Validierung des Seriennamens f1")
public void validatingSeriesName () {
// ResponseBody in String konvertieren
String responseBody = Given (). When (). Get ("http://ergast.com/api/f1/2017/circuits.json") .getBody (). AsString ();
// JsonPath-Objekt erstellen, indem der Antworttext als Zeichenfolge übergeben wird
JsonPath resJson = neuer JsonPath (responseBody);
// Die Attributwertreihe unter MRData abrufen
String seriesName = resJson.getString ("MRData.series");
// BenutzertestNg-Behauptung
Assert.assertEquals ("f1", seriesName);
}In ähnlicher Weise könnten wir den Wert der XML-Antwort mit XMLPath ermitteln. Hier arbeiten wir mit JSON, daher haben wir hier JSonPath verwendet
RESTful-APIs unterstützen nur zwei Arten von Parametern:
A. Abfrageparameter: Hier werden Parameter am Ende des API-Endpunkts angehängt und können durch das Fragezeichen identifiziert werden und bilden ein Schlüsselwertpaar wie z
https://www.google.com/search?q=https://www.wikipedia.org/
Hier in der obigen API ist 'q' der Parameter und 'https://www.wikipedia.org/' ist der Wert dieses Parameters, wenn wir suchen wollen 'ETWAS_SONST_TEXT'Wir könnten den Wert des Parameters ersetzen 'q' mit 'ETWAS_SONST_TEXT'anstelle von https://www.wikipedia.org/.
B. Pfadparameter: Dies ist der Teil des RESTful API-Endpunkts.
z.B. Endpunkt, den wir zuvor verwendet haben: http://ergast.com/api/f1/2017/circuits.json, hier ist „2017“ ein Pfadparameterwert.
Um ein Ergebnis für das Jahr zu erhalten 2016 könnten wir 2017 durch 2016 ersetzen dann gibt die API den Antworttext für 2016 an.
Tests mit Pfadparametern für RestAssured
@Test (description = "Validierung der Anzahl der Schaltkreise mithilfe von Pfadparametern")
public void testWithPathParams () {
String SeasonNumber = "2017";
String responseBody = Given (). PathParam ("Season", SeasonNumber) .when (). Get ("http://ergast.com/api/f1/{season}/circuits.json") .getBody (). AsString ();
// JsonPath-Objekt erstellen, indem der Antworttext als Zeichenfolge übergeben wird
JsonPath resJson = neuer JsonPath (responseBody);
// Die Attributwertreihe unter MRData abrufen
String seriesName = resJson.getString ("MRData.series");
// BenutzertestNg-Behauptung
Assert.assertEquals ("f1", seriesName);
}Tests mit Abfrageparametern für RestAssured
@Test (description = "Validierung der Google-Suche mithilfe von Abfrageparametern")
public void testWithPathParams () {
String searchItem = "https://www.wikipedia.org/";
Given (). queryParam ("q", searchItem) .when (). get ("https://www.google.com/search") .then (). assertThat (). statusCode (200);
}Parametrisierungstests:
Mit Rest Assured können wir datengesteuerte Tests durchführen (dh dasselbe Testskript wird mehrmals mit unterschiedlichen Eingabedatensätzen ausgeführt und unterschiedliche Ausgabedaten bereitstellen)
SCHRITT 1: Erstellt einen Testdatenanbieter.
SCHRITT 2: Verwenden Sie den Datenprovider im Testskript.
@DataProvider (name = "easonsAndRaceNumbers ")
öffentliches Objekt [] [] testDataFeed () {
neues Objekt zurückgeben [] [] {
{"2017", 20},
{"2016", 21}
};
}@Test (description = "Überprüfung der Anzahl der Schaltkreise in verschiedenen Jahreszeiten", dataProvider = "JahreszeitenAndRaceNumbers") public void CircuitNumberValidation (String SeasonYear, int RaceNumbers) {Given ().pathParam ("Jahreszeit", JahreszeitJahr) .when (). get ("http://ergast.com/api/f1/{Jahreszeit}/circuits.json "). then (). assertThat (). body (" MRData.CircuitTable.Circuits.circuitId ", hasSize (RaceNumbers)); }}Arbeiten mit mehrwertigen Parametern mit RestAssured
Mehrwertparameter sind Parameter, die mehr als einen Wert pro Parametername haben (dh eine Liste von Werten pro Parameterschlüssel). Wir können sie wie folgt behandeln:
Given (). param ("paramKey", "paramValue1", "paramaValue2"). when (). get ("API URL");Oder wir könnten eine Liste erstellen und die Liste als Wert des paramKey übergeben, wie:
Aufführen paramValue = neue neue ArrayList ();
paramValue.add ("paramvalue1");
paramValue.add (“paramvalue2);
Given (). param ("paramKey", paramValue) .when (). get ("API URL");
Arbeiten mit Cookies mit RestAssured
Given (). Cookie ("cookieK", "cookieVal"). when (). get ("API URL");Or
Wir können hier auch ein mehrwertiges Cookie wie folgt angeben:
Given (). Cookie ("cookieK", "cookieVal1", "cookieVal2"). when (). get ("API URL");Arbeiten mit Headern:
Wir können in einer Anfrage mithilfe von Headern angeben:
Given (). Header ("HeaderK1", "HeaderValue1"). Header ("HeaderK2", "HeaderValue2"). When (). Get ("API URL");Arbeiten mit contentType:
angegeben (). contentType ("application / json"). when (). get ("API URL");Or
Given (). contentType (ContentType.JSON) .when (). get ();Reaktionszeit messen:
long timeDurationInSeconds = get ("API-URL"). timeIn (SEKUNDEN);
Rest-API-Authentifizierung
REST versichert unterstützt verschiedene Authentifizierungsschemata, z. B. OAuth, Digest, Zertifikat, Formular und präventive Basisauthentifizierung. Wir können entweder die Authentifizierung für jede einzelne Anfrage festlegen
Hier ist eine Beispielanfrage, die dasselbe verwendet:
angegeben (). auth (). basic ("uName", "pwd"). when (). get ("URL") ..Auf der anderen Seite Authentifizierung und im folgenden Ansatz für die HTTP-Anforderungen definiert:
RestAssured.authentication = basic ("uName", "pwd");Grundlegende AUTH-Typen:
Es gibt zwei Arten der Basisauthentifizierung: "Präemptive" und "Herausgeforderte Token-Basisauthentifizierung".
Präventive Basisauthentifizierung:
Dadurch wird der grundlegende Authentifizierungsnachweis gesendet, noch bevor der Server in bestimmten Situationen zusammen mit der ausgelösten Anforderung eine nicht autorisierte Antwort gibt, wodurch der Aufwand für das Herstellen einer zusätzlichen Verbindung verringert wird. Dies ist in der Regel eine häufig auftretende Situation, es sei denn, wir testen die Herausforderungsfähigkeit des Servers.
Eg.
Given (). auth (). preemptive (). basic ("uName", "pwd"). when (). get ("URL"). then (). statusCode (200);Herausgeforderte Basisauthentifizierung
Auf der anderen Seite liefert REST Assured die Anmeldeinformationen nur dann, wenn der Server explizit danach gefragt hat, dh der Server löst die nicht autorisierte Antwort aus. Nach dieser nicht autorisierten Antwort sendet Rest-Assured eine weitere Anfrage an den Server, nämlich die Auth.
Given (). auth (). basic ("uName", "pwd"). when (). get ("URL"). then (). statusCode (200);Digest-Authentifizierung
Derzeit wird nur die "herausgeforderte Digest-Authentifizierung" berücksichtigt. z.B:
Given (). auth (). Digest ("uName", "pwd"). when (). get ("URL"). then (). statusCode (200); Formularauthentifizierung
Wir könnten dies hauptsächlich in 3 verschiedenen Ansätzen erreichen, abhängig von der Anwendung / den Szenarien:
Die Formularauthentifizierung ist eine sehr beliebte Methode im Internet, bei der ein Benutzer seine Anmeldeinformationen (z. B. Benutzername und Passwort) über eine Webseite eingibt und sich beim System anmeldet. Dies könnte auf diese Weise behoben werden
Given (). Auth (). Form ("uName", "pWd").
when (). get ("URL");
then (). statusCode (200);Dies funktioniert möglicherweise nicht, da es optimal ist, und kann je nach Komplexität der Webseite erfolgreich sein oder fehlschlagen. Eine bessere Option besteht darin, diese Details beim Einrichten der Formularauthentifizierung im folgenden Ansatz anzugeben:
angegeben (). auth (). form ("uName", "pwd", neue FormAuthConfig ("/ 'hier den Namen der Formularaktion erwähnen, der Teil des HTML-Seitencodes unter dem Formular-Tag'", "uName", "pwd" ist ")). when (). get (" URL "). then (). statusCode (200);Bei diesem Ansatz muss der intern versicherte REST keine zusätzliche Anforderung auslösen und über die Webseite analysieren.
Wenn Sie die Standard-Spring-Sicherheit verwenden, dann Eine vordefinierte FormAuthConfig wird ausgelöst.
angegeben (). auth (). form ("uName", "Pwd", FormAuthConfig.springSecurity ()). when (). get ("URL"). then (). statusCode (200);HINWEIS: Wenn wir zusätzliche Eingabedaten zusammen mit der Formularauthentifizierung senden möchten, können wir Folgendes schreiben:
angegeben (). auth (). form ("uName", "pwd", formAuthConfig (). withAdditionalFields ("firstInputField", "secondInputField"). ..CSRF:
CSRF steht für Cross-Site Request Forgery.
Heutzutage ist es sehr üblich, dass der Server ein CSRF-Token mit der Antwort bereitstellt, um die CSRF-Sicherheitsangriffe zu vermeiden. REST Assured unterstützt dies durch die Verwendung eines automatischen Parsers und die Bereitstellung eines CSRF-Tokens.
Um dies zu erreichen, muss REST Assured eine zusätzliche Anfrage stellen und die Website (wenige Positionen) analysieren.
Wir können die CSRF-Unterstützung aktivieren, indem wir den folgenden Code schreiben:
angegeben (). auth (). form ("uName", "pwd", formAuthConfig (). withAutoDetectionOfCsrf ()). when (). get ("URL"). then (). statusCode (200);Zusätzlich zur Unterstützung von REST Assured und zur Verbesserung der Fehlerfreiheit und Robustheit der Analyse können wir den CSRF-Feldnamen angeben (hier wird davon ausgegangen, dass wir Spring Security-Standardwerte verwenden und vordefinierte springSecurity FormAuthConfig verwenden können):
angegeben (). auth (). form ("uName", "pwd", springSecurity (). withCsrfFieldName ("_ csrf")). when (). get ("URL"). then (). statusCode (200);Standardmäßig wird der CSRF-Wert als Formularparameter mit der Anforderung übergeben. Wir können ihn jedoch so konfigurieren, dass er als Header gesendet wird, falls dies wie folgt erforderlich ist:
angegeben (). auth (). form ("uName", "pwd", springSecurity (). withCsrfFieldName ("_ csrf"). sendCsrfTokenAsHeader ()). when (). get ("URL"). then (). statusCode (200);OAuth 1:
Für OAuth 1 muss sich Scribe im Klassenpfad befinden. Um die oAuth 1-Authentifizierung zu verwenden, haben wir folgende Möglichkeiten:
gegeben (). auth (). oauth (..). wenn (). ..OAuth 2:
angegeben (). auth (). oauth2 (accessToken) .when (). ..
Bei dem obigen Ansatz wird das OAuth2-Zugriffstoken in einem Header berücksichtigt. Genauer gesagt können wir auch Folgendes tun:
angegeben (). auth (). preemptive (). oauth2 (accessToken) .when (). ..Übergeben von Datei, Byte-Array, Eingabestream oder Text in Anfrage:
Wenn Sie große Datenmengen an den Server senden, ist es im Allgemeinen üblich, die mehrteilige Formulardatentechnik zu verwenden. Rest Assured bietet Methoden namens multiPart, mit denen wir eine Datei, ein Byte-Array, einen Eingabestream oder einen Text zum Hochladen angeben können.
angegeben (). multiPart (neue Datei ("/ File_Path")). when (). post ("/ upload");POST-Anforderungserstellung mit Rest versichert
Bei POST- und PUT-Anforderungen senden wir Daten an den Server und dessen Erstellung von Ressourcen / Aktualisierung von Ressourcen. Sie können dies als Schreib- oder Aktualisierungsvorgang betrachten.
Die Daten, die in einer POST-Anforderung an den Server gesendet werden, werden im Hauptteil der HTTP-Anforderung / des API-Aufrufs gesendet.
Die Art des Inhalts oder der Daten, die gesendet werden, kann je nach API ein anderes Format haben, dh XML, JSON oder ein anderes Format wird durch den Header "Inhaltstyp" definiert.
Wenn der POST-Körper aus den JSON-Daten besteht, ist der Header-Inhaltstyp „application/json“. Ebenso wäre der Header-Inhaltstyp für eine POST-Anfrage, die aus einem XML besteht, vom Typ „application/xml“.
Hier ist das folgende Code-Snippet für dasselbe:
angegeben (). contentType ("application / json"). param ("pk", "pv"). when (). body ("JsonPAyloadString"). post ("url"). then (). assertThat (). statusCode (200);HINWEIS: Es gibt verschiedene Möglichkeiten, wie wir den Nutzdaten- / Anforderungshauptteil innerhalb der Methode „body“ wie String (wie im obigen Snippet gezeigt), JsonObject, als Datei usw. usw. übergeben können.
PUT-Anfrage mit Rest versichert:
angegeben (). contentType ("application / json"). param ("pk", "pv"). when (). body ("JsonPAyloadString"). put ("url"). then (). assertThat (). statusCode (200);Anfrage mit Rest-Assured löschen:
Given (). contentType ("application / json"). param ("pk", "pv"). when (). delete ("url"). then (). assertThat (). statusCode (200);Auf diese Weise können wir verschiedene Rest-API-Aufrufe für verschiedene API-Verben erstellen (GET / POST / PUT / DELETE usw.)
Serialisierung und Deserialisierung in Java:
Die Serialisierung ist im Grunde eine Verarbeitung oder Konvertierung des Objektstatus in einen Bytestrom. Andererseits verarbeitet oder konvertiert die Deserialisierung in Java den Bytestream in ein tatsächliches Java-Objekt im Speicher. Dieser Mechanismus wird bei der Persistenz von Object verwendet.
Unten ist das Blockdiagramm für das gleiche
Vorteile der Serialisierung
A. Speichern / Beibehalten des Status eines Objekts.
B. Um ein Objekt über ein Netzwerk zu fließen.
Serialisierung mit JAVA erreichen
Um ein serialisierbares Java-Objekt zu erhalten, müssen wir die Schnittstelle java.io.Serializable implementieren.
Die ObjectOutputStream-Klasse, die die Methode writeObject () enthält, die für die Serialisierung eines Objekts verantwortlich ist.
Die ObjectInputStream-Klasse enthält auch eine andere Methode namens readObject (), die für die Deserialisierung eines Objekts verantwortlich ist.
Klassen, die die Schnittstelle java.io.Serializable implementieren, können dort nur serialisiert werden.
Serializable ist nur eine Markierungsschnittstelle und hat wie andere Marktschnittstellen kein Datenelement oder keine Methode. Diese wird zum „Markieren“ von Java-Klassen verwendet, damit Objekte dieser Klassen bestimmte Funktionen erhalten. Wie wenige andere Markierungsschnittstellen sind: - Klonbar und Remote usw.
Anmerkungen :
1. Wenn eine übergeordnete Klasse eine serialisierbare Schnittstelle implementiert hat, muss die untergeordnete Klasse diese nicht implementieren, aber umgekehrt ist sie nicht anwendbar.
2. Beim Serialisierungsprozess werden nur nicht statische Datenelemente gespeichert.
3. Statische Datenelemente und auch die transienten Datenelemente werden von der Serialisierung nicht gespeichert. Wenn wir also den Wert des nicht statischen Datenelements nicht speichern müssen, können wir ihn vorübergehend machen.
4. Der Konstruktor wird niemals aufgerufen, wenn ein Objekt deserialisiert wird.
SCHRITT 1: Der erste Schritt ist im Wesentlichen die Erstellung einer Klasse, die die serialisierbare Schnittstelle implementiert:
java.io.Serializable importieren;
public class Dummy implementiert Serializable {
private int i;
private String-Daten;
public Dummy (int i, String data)
{
dies.i = ich;
this.data = Daten;
}
}SCHRITT 2: Erstellen Sie eine Klasse, um sie zu serialisieren:
java.io.FileNotFoundException importieren;
java.io.FileOutputStream importieren;
import java.io.IOException;
java.io.ObjectOutputStream importieren;
öffentliche Klasse Serialize {
public static void Serialization (Object classObject, String fileName) {
versuche {
FileOutputStream fileStream = neuer FileOutputStream (Dateiname);
ObjectOutputStream objectStream = neuer ObjectOutputStream (fileStream);
objectStream.writeObject (classObject);
objectStream.close ();
fileStream.close ();
} Catch (FileNotFoundException e) {
// TODO Automatisch generierter Fangblock
e.printStackTrace ();
} Catch (IOException e) {
// TODO Automatisch generierter Fangblock
e.printStackTrace ();
}
}
public static void main (String [] args) {
Dummy dummyObj = neuer Dummy (10, "Lambda-Geeks");
Serialisierung (dummyObj, "DummSerialized");
}
}SCHRITT 3: Sobald Schritt 2 erfolgreich abgeschlossen wurde, wird angezeigt, dass eine Datei mit einigen Daten erstellt wurde. Diese Daten sind im Grunde genommen serialisierte Daten der Objektmitglieder.
Deserialisierung mit Java:
Hier ist das folgende Code-Snippet:
öffentliches statisches Objekt DeSerialize (String fileName)
{
versuche {
FileInputStream fileStream = neuer FileInputStream (neue Datei (Dateiname));
ObjectInputStream objectStream = neuer ObjectInputStream (fileStream);
Object deserializeObject = objectStream.readObject ();
objectStream.close ();
fileStream.close ();
DeserializeObject zurückgeben;
} Catch (FileNotFoundException e) {
e.printStackTrace ();
} Catch (IOException e) {
e.printStackTrace ();
} Catch (ClassNotFoundException e) {
e.printStackTrace ();
}
Null zurückgeben;
}Der Treibercode lautet wie folgt:
public static void main (String [] args) {
/ * Dummy dummyObj = neuer Dummy (10, "Lambda-Geeks");
Serialisierung (dummyObj, "DummSerialized");
System.out.println ("--------------------------------------- ------------------------------- ");
*/
Dummy deSerializedRect = (Dummy) DeSerialize ("DummSerialized");
System.out.println ("Daten von serialisiertem Objekt" + deSerializedRect.print ());
System.out.println ("--------------------------------------- ------------------------------- ");
}JSONPATH Weitere Syntax / Abfrage:
Nehmen wir einen JSON wie folgt an:
{
"OrganizationDetails": "Dummy-Details der Organisation",
"Region": "Asien",
"Emp-Details": [
{
"Org": "Lambda-Geeks",
"Information": {
"Ph": 1234567890,
"Hinzufügen": "XYZ",
"Alter": 45
}
},
{
"Org": "Lambda-Geeks-2",
"Information": {
"Ph": 2134561230,
"Hinzufügen": "ABC",
"Alter": 35
}
}
]
}In der obigen JSON werden die OrganizationDetails & Region als Blattknotengrund bezeichnet, da sie keine weiteren untergeordneten Knoten / Elemente haben, aber andererseits die Emp-Details einen untergeordneten Knoten haben, weshalb sie nicht als Blattknoten bezeichnet werden.
Wenn wir versuchen, den Wert von OrganizationDetails zu ermitteln, müssen wir Folgendes verwenden:
$ .OrganizationDetails Dies führt zu: [ "Dummy Details der Organisation" ]
Wie Wise, um die Daten für die Region zu erhalten, müssen wir schreiben:
$ .Region
Wenn wir den Wert des Alters für den 1. Mitarbeiter ermitteln möchten, können wir schreiben:
$ .Emp-Details [0] .Information.Age Dies führt zu: [ 45 ]
Für das Alter des 2. Mitarbeiters könnten wir gerne schreiben
$ .Emp-Details [1] .Information.Age Dies führt zu: [35]
Auf diese Weise können wir den JsonPath-Ausdruck / die Abfrage ermitteln, um die Daten für die jeweiligen Felder im JSON abzurufen.
Debarghya Roy, eine Ingenieurarchitektin mit über 12 Jahren Erfahrung, arbeitet für ein Fortune-5-Unternehmen und ist eine aktive Open-Source-Mitwirkende. Er verfügt über Kenntnisse in einer breiten Palette von Technologien, darunter Java, C#, Python und verschiedenen Automatisierungs- und Performance-Engineering-Tools, und verfügt außerdem über Fachkenntnisse in Sicherheitsautomatisierung, RPA und Back-End-Entwicklung mit SpringBoot, Kafka und ELK-Stack. Debarghya ist in Bangalore, Indien ansässig und liebt Bloggen, Musik und setzt sich für „Bildung für alle“ ein, was zur Gründung von LambdaGeeks führte.
Hallo Mitleser,
Wir sind ein kleines Team bei Techiescience, das hart mit den Großen zusammenarbeitet. Wenn Ihnen gefällt, was Sie sehen, teilen Sie unsere Inhalte bitte in den sozialen Medien. Ihre Unterstützung macht einen großen Unterschied. Danke schön!