Pagsubok sa Rest API || Mabilis na Patnubay sa RestAssured tutorial 2020

Pagpahinga ng Tiyak na API na pagsubok para sa pag-automate ng Rest API na Pagsubok

RestAssured -Ang natitiyak na tutorial ng pagsubok sa api
Magpahinga ng Tiyak na API Automation

Sa kumpletong tutorial ng Rest Assured na ito malalaman natin ang Rest API Testing sa lalim, API Test Automation kasama ang Rest Assured sa modularised na diskarte

Ano ang RestAssured at ang paggamit nito

Ang Rest Assured ay isang napakalawak na ginagamit na bukas na teknolohiya ng mapagkukunan para sa REST API Automation Testing, ito ay batay sa java based library.

Nakikipag-ugnay ang Rest Assured sa Rest API sa isang walang ulo na client mode, maaari naming mapahusay ang parehong kahilingan sa pamamagitan ng pagdaragdag ng iba't ibang mga layer upang mabuo ang kahilingan at lumikha ng kahilingan sa HTTP sa pamamagitan ng iba't ibang mga HTTPS na pandiwa sa server.

Ang Rest Assured na naka-built sa library ay nagbibigay ng napakalaking pamamaraan at mga utility upang maisagawa ang pagpapatunay ng tugon na natanggap mula sa server tulad ng status message, status code at body ng pagtugon.

Ang kumpletong serye ng Rest Assured Tutorial para sa REST API Automation Testing ay binubuo ng mga sumusunod na paksa:

Pagsisimula: Pag-configure ng pahingaMasigurado sa Build tool ie Maven / gradle

HAKBANG 1: Kung nagtatrabaho ka sa maven idagdag lamang ang sumusunod na dependency sa pom.xml (maaari kang pumili ng anumang iba pang bersyon):

Upang makapagsimula sa REST Assured, idagdag lamang ang pagtitiwala sa iyong proyekto. 


    io.pinaniguro
    Huwag kang magalala
    4.3.0
    pagsusulit

Kung nagtatrabaho ka sa gradle idagdag lamang ang sumusunod sa build.gradle (muli maaari kang pumili ng ibang iba pang bersyon):

testCompile group: 'io.rest-assured', pangalan: 'rest-sure', bersyon: '4.3.0'

HAKBANG 2: Ang Pahinga ay tiniyak na maaaring isama at napakadali na magamit sa mga umiiral na mga framework ng pagsubok sa yunit na tulad ng Testng, JUnit

Narito ginagamit namin ang testNg alinsunod sa Unit Test Framework na nababahala.

Kapag na-import na ang mga silid-aklatan ng Rest Assured pagkatapos kailangan nating idagdag ang mga sumusunod na static na pag-import sa aming mga klase sa pagsubok:

i-import ang static io. nasiksik. Pinatunayan. *;

i-import ang static org.hamcrest.Matchers. *;

TANDAAN: Para sa paparating na hangarin sa pag-aaral, susubukan namin ang Ergast Developer API, na matatagpuan dito. Nagbibigay ang API na ito ng makasaysayang data na nauugnay sa mga karera sa Formula 1, mga driver, circuit, atbp.

Pamilyar sa Syntax:

Sinusuportahan ng Rest Assured ang format na BDD (Gherkin Syntax) upang isulat ang mga script ng pagsubok ie sa format na Give / When / Then / And, Ipinapalagay namin na mayroon kang pag-unawa sa BDD / gherkin syntax, kung hindi man ay imumungkahi namin na gumastos ng 30 minuto ng oras upang maunawaan kung ano ang BDD (Gherkin Syntax) at paano ito gumagana at ang napaka-batayan nito.

T-01: Ang aming ika-1 na script na karaniwang nagpapatunay ng bilang ng mga circuit sa F1 noong 2017 gamit ang API na ito (http://ergast.com/api/f1/2017/circuits.json)

@Test (paglalarawan = "Bilang Ng Mga Circuits Sa 2017 Season Dapat Maging 20") pampublikong walang bisa na pagpapatunayNumberOfCircuits () {ibinigay (). Kailan (). Kumuha ("http://ergast.com/api/f1/2017/circuits. json "). pagkatapos (). assertThat (). katawan ("MRData.CircuitTable.Circuits.circuitId", hasSize (20)); }

Pagpapatunay ng pagtugon sa API :

1. Nakukuha ang tugon ng JSON ng kahilingan sa API.

2. Mga query para sa circuitId gamit ang ekspresyong GPath na "MRData.CircuitTable.Circuits.circuitId"

3. Pinatutunayan ang koleksyon ng mga elemento ng circuitId na may sukat na 20

Narito ginagamit namin Hamcrest matchers para sa iba`t ibang pagpapatunay tulad ng

  • pantayTo () napatunayan ang pagkakapantay-pantay
  • LessThan () at mas malakiThan () na pamamaraan para sa kumpara sa pagpapatunay,
  • Ang pamamaraan ng hasItem () ay ginagamit upang mapatunayan ang pagkakaroon ng isang elemento mula sa isang koleksyon ng mga elemento.

Mayroong iba`t ibang mga pamamaraan na kapaki-pakinabang upang maisagawa ang tiyak na pagpapatunay.

Maaari ka ring sumangguni sa dokumentasyon ng aklatan ng Hamcrest para sa isang buong listahan ng mga matcher at pamamaraan.

Pagpapatunay ng Code sa pagtugon:

ibinigay (). kailan (). kumuha ("http://ergast.com/api/f1/2017/circuits.json") .tapos (). assertThat (). statusCode (200);

Pagpapatunay ng Uri ng Nilalaman

ibinigay (). kailan (). kumuha ("http://ergast.com/api/f1/2017/circuits.json") .tapos (). assertThat (). contentType (ContentType.JSON);

Ang pagpapatunay ng header na "Haba ng Nilalaman"

ibinigay (). kailan (). kumuha ("http://ergast.com/api/f1/2017/circuits.json") .tapos (). assertThat (). header (" Haba ng Nilalaman ", pantayTo (" 4551 "));

Maramihang Pagpapatunay sa isang solong Pagsubok bilang (Sa pamamagitan ng paggamit at () mga pamamaraan):

@Test (paglalarawan = "Bilang ng Mga Circuits Sa 2017 Season Dapat Maging 20")
    public void validatingNumberOfCircuits () {
        ibinigay (). kailan (). kumuha ("http://ergast.com/api/f1/2017/circuits.json") .tapos (). assertThat (). header ("Haba ng Nilalaman", equalTo (" 4551 ")). At (). StatusCode (200);
    }

Pagpapatunay ng sangkap / katangiang Tugon ng Katawan:

Maaari naming gamitin ang JsonPath upang makuha ang halaga ng mga katangiang json at ilagay ang assertion gamit ang TestNg

@Test (paglalarawan = "Pagpapatunay ng pangalan ng serye na f1")
    public void validatingSeriesName () {
        // convert ResponseBody to String
        String responseBody = ibinigay (). Kailan (). Kumuha ("http://ergast.com/api/f1/2017/circuits.json") .getBody (). AsString ();
        // Lumikha ng Bagay ng JsonPath sa pamamagitan ng Pagpasa ng Katawan ng Tugon bilang isang string
        JsonPath resJson = bagong JsonPath (responseBody);
        // Kunin ang serye ng halaga ng katangian sa ilalim ng MRData
        String seriesName = resJson.getString ("MRData.series");
        // User TestNg Assertion
        Assert.assertEquals ("f1", seriesName);
    }

Sa katulad na fashion maaari naming makuha ang halaga ng tugon sa XML gamit ang XMLPath. Dito kami nagtatrabaho kasama si JSON samakatuwid ginamit namin dito ang JSonPath

Sinusuportahan lamang ng RESTful API ang dalawang uri ng mga parameter:

A. Mga parameter ng query: Narito ang mga parameter ay nakadugtong sa dulo ng endpoint ng API at maaaring makilala sa pamamagitan ng marka ng tanong at bumubuo ng isang pangunahing pares ng halaga tulad ng 

https://www.google.com/search?q=https://www.wikipedia.org/

Dito sa itaas na API 'q' ay ang parameter at ang 'https://www.wikipedia.org/' ay halaga ng parameter na iyon, kung maghanap kami 'SOMETHING_ELSE_TEXT'mapapalitan natin ang halaga ng parameter 'q' kasama 'SOMETHING_ELSE_TEXT'kapalit ng https://www.wikipedia.org/.

B. Mga parameter ng path: Ito ang bahagi ng RESTful API endpoint. 

hal. endpoint na ginamit namin nang mas maaga: http://ergast.com/api/f1/2017/circuits.json, narito ang "2017" ay isang halaga ng parameter ng path.

Upang makakuha ng isang resulta para sa taon Maaari naming palitan ang 2016 sa 2017 pagkatapos ay bibigyan ng API ang katawang tugon para sa 2016.

Mga pagsusulit gamit ang Path Params para sa RestAssured

@Test (paglalarawan = "Pagpapatunay ng bilang ng mga Circuits gamit ang Path Params")
    public void testWithPathParams () {
        String seasonNumber = "2017";
       String responseBody = ibinigay (). PathParam ("season", seasonNumber). Kailan (). Get ("http://ergast.com/api/f1/{season}/circuits.json") .getBody (). AsString ();
        // Lumikha ng Bagay ng JsonPath sa pamamagitan ng Pagpasa ng Katawan ng Tugon bilang isang string
        JsonPath resJson = bagong JsonPath (responseBody);
        // Kunin ang serye ng halaga ng katangian sa ilalim ng MRData
        String seriesName = resJson.getString ("MRData.series");
        // User TestNg Assertion
        Assert.assertEquals ("f1", seriesName);
    }

Mga pagsusulit gamit ang Mga Query Param para sa RestAssured

@Test (paglalarawan = "Pagpapatunay ng paghahanap sa Google gamit ang Mga Query Param")
    public void testWithPathParams () {
        String searchItem = "https://www.wikipedia.org/";
  ibinigay (). queryParam ("q", searchItem) .kapag (). kumuha ("https://www.google.com/search") .tapos (). assertThat (). statusCode (200);
    }

Mga pagsusulit sa parameterizing:

Maaari naming gawin ang pagsubok na hinimok ng data (ibig sabihin, ang parehong script ng pagsubok ay naisasagawa ng maraming beses na may iba't ibang mga hanay ng data ng pag-input at magbibigay ng iba't ibang data ng output) gamit ang Rest Assured 

HAKBANG 1: Nilikha ang isang testNg Data Provider.

HAKBANG 2: ubusin ang Tagabigay ng Data sa script ng Pagsubok.

@DataProvider (pangalan = "SeasonAndRaceNumber")
    pampublikong Bagay [] [] testDataFeed () {
        ibalik ang bagong Bagay [] [] {
                {"2017", 20},
                {"2016", 21}
        };
    }
@Test (paglalarawan = "Bilang Ng Mga Circuits na pagpapatunay sa iba't ibang mga Panahon", dataProvider = "mga panahonAndRaceNumber") public void circuitNumberValidation (String seasonYear, int raceNumber) {ibinigay ().pathParam ("panahon", seasonYear). kailan (). kumuha ("http://ergast.com/api/f1/{panahon}/circuits.json "). pagkatapos (). assertThat (). katawan (" MRData.CircuitTable.Circuits.circuitId ", hasSize (lahiNumber)); }

Paggawa gamit ang Mga parameter na Multi -valued na may RestAssured 

Ang mga parameter ng multi-halaga ay ang mga parameter na mayroong higit sa isang halaga bawat pangalan ng parameter (hal. Isang listahan ng mga halaga bawat paramKey), maaari nating tugunan ang mga ito tulad ng sa ibaba:

ibinigay (). param ("paramKey", "paramValue1", "paramaValue2"). kailan (). makuha ("API URL");

O maaari naming ihanda ang isang listahan at ipasa ang listahan bilang ang halaga ng paramKey tulad ng:

Listahan paramValue = bagong bagong ArrayList ();
paramValue.add ("paramvalue1");
paramValue.add (“paramvalue2);
ibinigay (). param ("paramKey", paramValue). kailan (). kumuha ("API URL");
Paggawa gamit ang cookie sa RestAssured 
ibinigay (). cookie ("cookieK", "cookieVal"). kailan (). kumuha ("API URL");

Or 

Maaari din kaming tumukoy ng isang multi-value cookie dito tulad ng:

ibinigay (). cookie ("cookieK", "cookieVal1", "cookieVal2"). kailan (). makuha ("API URL");

Nagtatrabaho sa Mga Header:

Maaari naming tukuyin sa isang kahilingan gamit ang mga header / header tulad ng:

ibinigay (). header ("headerK1", "headerValue1"). header ("headerK2", "headerValue2"). kailan (). kumuha ("API URL");

Paggawa gamit ang contentType:

ibinigay (). contentType ("application / json"). kailan (). makuha ("API URL");

Or 

ibinigay (). contentType (ContentType.JSON) .kung (). makakuha ();

Sukatin ang Oras ng Tugon:

mahabang orasDurationInSeconds = makakuha ("API URL"). timeIn (SECONDS);

Pahinga API Pagpapatotoo

Sinusuportahan ng REST sure ang iba't ibang mga scheme ng auth, hal. OAuth, digest, sertipiko, form at pauna-unahang pangunahing pagpapatotoo. Maaari naming itakda ang pagpapatunay para sa bawat at bawat kahilingan 

narito ang isang halimbawang kahilingan gamit ang pareho:

ibinigay (). auth (). pangunahing ("uName", "pwd"). kailan (). makuha ang (“URL“) ..

Sa kabilang banda pagpapatotoo at tinukoy sa diskarte sa ibaba para sa mga kahilingan sa HTTP:

RestAssured.authentication = basic ("uName", "pwd");

Pangunahing Mga Uri ng AUTH:

Mayroong dalawang uri ng pangunahing auth, "pauna" at "hinamon na pangunahing pangunahing pagpapatotoo".

Preemptive Basic Auth:

Ipapadala nito ang pangunahing kredensyal ng pagpapatotoo kahit na bago magbigay ang server ng isang hindi pinahintulutang tugon sa ilang mga sitwasyon kasama ang kahilingan na na-trigger, sa gayon binabawasan ang overhead ng paggawa ng isang karagdagang koneksyon. Karaniwan itong pangunahing mga nangyayari na sitwasyon maliban kung sinusubukan namin ang kakayahan ng mga server na hamunin. 

Hal.

ibinigay (). auth (). preemptive (). pangunahing ("uName", "pwd"). kailan (). kumuha ("URL"). pagkatapos (). statusCode (200);

Hinahamon Batayang Pagpapatotoo

Sa kabilang kamay na "hinamon ang pangunahing pagpapatotoo" REST Assured ay hindi ibibigay ang mga kredensyal maliban kung malinaw na tinanong ito ng server ibig sabihin, itinapon ng server ang Hindi Pinahintulutang Tugon. Matapos nito ang Hindi Pinapahintulutang tugon sa Rest-Assured ay nagpapadala ng isa pang kahilingan sa server na kung saan ay ang Auth.

ibinigay (). auth (). pangunahing ("uName", "pwd"). kailan (). makuha ("URL"). pagkatapos (). statusCode (200);

Digest Authentication

Sa ngayon ay "hinamon lamang na pagpapatotoo sa digest" ang isinasaalang-alang. hal:

ibinigay (). auth (). digest ("uName", "pwd"). kailan (). kumuha ("URL"). pagkatapos (). statusCode (200); 

Pagpapatotoo ng Form

Maaari nating makamit ito nang higit sa lahat sa 3 magkakaibang mga diskarte depende sa Application / senaryo:

Ang pagpapatotoo sa form ay isa sa napakapopular sa internet na isang gumagamit ay pumapasok sa kanyang mga kredensyal ibig sabihin username at password sa pamamagitan ng isang web page at mag-log in sa system. Maaaring tugunan ito gamit ito 

ibinigay (). auth (). form ("uName", "pWd").
kailan (). makakuha ("URL");
pagkatapos (). statusCode (200);

Habang maaaring hindi ito gumana dahil ito ay pinakamainam at maaari itong pumasa o mabigo depende sa pagiging kumplikado ng webpage. Ang isang mas mahusay na pagpipilian ay upang ibigay ang mga detalyeng ito kapag nagse-set up ng pagpapatotoo ng form sa diskarte sa ibaba:

ibinigay (). auth (). form ("uName", "pwd", bagong FormAuthConfig ("/ 'banggitin dito ang pangalan ng pagkilos na form na bahagi ng html code ng pahina sa ilalim ng form tag'", "uName", "pwd ")). kailan (). kumuha (" URL "). pagkatapos (). statusCode (200);

Sa pamamaraang ito, ang REST Assured na panloob na kostumbre ay nangangailangan ng pag-trigger ng karagdagang kahilingan at pag-parse sa pamamagitan ng webpage. 

Kung sakaling gumagamit ka ng default na Spring Security pagkatapos ang isang paunang natukoy na FormAuthConfig ay na-trigger.

ibinigay (). auth (). form ("uName", "Pwd", FormAuthConfig.springSecurity ()). kapag (). kumuha ("URL"). pagkatapos (). statusCode (200);

TANDAAN: Kung nais naming magpadala ng karagdagang data ng pag-input kasama ang form auth maaari naming isulat ang nasa ibaba:

ibinigay (). auth (). form ("uName", "pwd", formAuthConfig (). withAdditionalFields ("firstInputField", "secondInputField"). ..

CSRF:

Ang CSRF ay nangangahulugang pagpapatalsik sa kahilingan sa Cross-site.

Ngayong mga araw na ito ay napaka-pangkaraniwan para sa server na magbigay ng isang token ng CSRF na may tugon upang maiwasan ang mga pag-atake sa seguridad ng CSRF. Sinusuportahan ito ng REST Assured sa pamamagitan ng paggamit at awtomatikong pag-parser at pagbibigay ng CSRF token. 

Upang makamit ang REST Assured na kailangan na gumawa ng isang karagdagang kahilingan at pag-parse (ilang posisyon) ng website.

Maaari naming paganahin ang suporta ng CSRF sa pamamagitan ng pagsulat ng code sa ibaba:

ibinigay (). auth (). form ("uName", "pwd", formAuthConfig (). withAutoDetectionOfCsrf ()). kailan (). kumuha ("URL"). pagkatapos (). statusCode (200);

Bilang karagdagan upang matulungan ang REST Assured at gawing mas walang kamali-mali at matatag ang pag-parse maaari naming ibigay ang pangalan ng patlang ng CSRF (dito ipinapalagay na gumagamit kami ng mga default na halaga ng Spring Security at maaari naming gamitin ang paunang natukoy na SpringSecurity FormAuthConfig):

ibinigay (). auth (). form ("uName", "pwd", springSecurity (). withCsrfFieldName ("_ csrf")). kapag (). kumuha ("URL"). pagkatapos (). statusCode (200);

Bilang default ang halaga ng CSRF ay naipasa bilang isang parameter ng form na may kahilingan ngunit maaari naming mai-configure upang ipadala ito bilang isang header kung sakaling kinakailangan ito tulad ng sa ibaba:

ibinigay (). auth (). form ("uName", "pwd", springSecurity (). withCsrfFieldName ("_ csrf"). sendCsrfTokenAsHeader ()). kapag (). kumuha ("URL"). pagkatapos (). statusCode (200);

OAuth 1:

Ang OAuth 1 ay nangangailangan ng Scribe na maging sa classpath. Upang magamit ang pagpapatotoo ng oAuth 1 maaari naming gawin:

ibinigay (). auth (). oauth (..). kailan (). ..

OAuth 2:

ibinigay (). auth (). oauth2 (accessToken) .kung (). ..

Sa diskarte sa itaas ang OAuth2 accessToken ay isasaalang-alang sa isang header. Upang maging mas malinaw maaari din nating gawin:

ibinigay (). auth (). pauna (). oauth2 (accessToken) .kapag (). ..

Pagpasa ng File, byte-array, stream ng pag-input o teksto sa Kahilingan:

Kapag nagpapadala ng malaking halaga ng data sa server sa pangkalahatan ay isang pangkaraniwang diskarte upang magamit ang diskarteng data ng multipart form. Ang Rest Assured ay nagbibigay ng mga pamamaraan na tinatawag na multiPart na nagbibigay-daan sa amin upang tukuyin ang isang file, byte-array, input stream o teksto upang mai-upload. 

ibinigay (). multiPart (bagong File ("/ File_Path")). kailan (). post ("/ upload");

Humihiling ng Paglikha ng POST na may Natiyak na Pahinga

Sa mga kahilingan sa POST at PUT, nagpapadala kami ng Data sa Server at ang karaniwang paglikha ng mga mapagkukunan / pag-update ng mga mapagkukunan, maaari mong isaalang-alang ito bilang isang pagsulat o pag-update ng operasyon.

Ang data na ipinapadala sa server sa isang kahilingan sa POST ay ipinadala sa katawan ng HTTP na kahilingan / API na tawag. 

Ang uri ng nilalaman o data na ipinapadala ay maaaring magkakaibang format depende sa API hal XML, JSON o ilang iba pang format ay tinukoy ng header ng Uri ng Nilalaman. 

Kung ang katawan ng POST ay binubuo ng data ng JSON pagkatapos ang uri ng Nilalaman ng header ay magiging application / json. Katulad nito, para sa isang kahilingan sa POST na binubuo ng isang XML kung gayon ang uri ng Nilalaman ng header ay magiging uri ng application / xml.

Narito ang snippet ng code sa ibaba para sa pareho:

ibinigay (). contentType ("application / json"). param ("pk", "pv"). kailan (). body ("JsonPAyloadString"). post ("url"). pagkatapos (). assertThat (). statusCode (200);

TANDAAN: Mayroong iba't ibang mga paraan upang maipasa namin ang payload / humiling ng katawan sa loob ng pamamaraang "katawan" tulad ng String (tulad ng ipinakita sa itaas na snippet), JsonObject, bilang isang File atbp atbp.

Humiling ng PUT na may Nasisiguro na Rest:

ibinigay (). contentType ("application / json"). param ("pk", "pv"). kapag (). body ("JsonPAyloadString"). ilagay ("url"). pagkatapos (). assertThat (). statusCode (200);

Tanggalin ang kahilingan gamit ang Rest-Assured:

ibinigay (). contentType ("application / json"). param ("pk", "pv"). kailan (). tanggalin ("url"). pagkatapos (). assertThat (). statusCode (200);

At sa ganoong paraan makakalikha tayo ng iba't ibang tawag sa Rest API para sa iba't ibang mga pandiwa ng API (GET / POST / PUT / Tanggalin atbp)

Serialisasyon at Deserialization sa Java:

Ang Serialization ay isang karaniwang pagpoproseso o pag-convert ng estado ng object sa isang byte stream. Sa kabilang banda ang Deserialization sa Java ay nagpoproseso o nagko-convert ng byte stream sa aktwal na object ng Java sa loob ng memorya. Ang mekanismong ito ay ginagamit sa pagtitiyaga ng Bagay.

Nasa ibaba ang block diagram para sa pareho 

Pagsubok sa Rest API || Mabilis na Patnubay sa RestAssured tutorial 2020

Mga kalamangan ng Serialisasyon

A. Upang mai-save / magpatuloy ang estado ng isang bagay.

B. Upang dumaloy ang isang bagay sa isang network.

Pagkamit ng Serialisasyon sa JAVA

Upang makamit ang isang Java object na serializable kailangan naming ipatupad ang java.io.Serializable interface.

Ang klase ng ObjectOutputStream na naglalaman ng paraan ng pagsulat ngObject () na responsable para sa serializing isang Bagay.

Naglalaman din ang klase ng ObjectInputStream ng isa pang pamamaraan na tinatawag na readObject () na responsable para sa deserializing ng isang bagay.

mga klase na nagpapatupad ng java.io.Serializable interface, may object na maaari lamang ma-serialize.

Ang Serializable ay isang interface lamang ng marker at tulad ng ibang interface ng merkado wala itong miyembro ng data o pamamaraan na nauugnay dito. Na ginagamit upang "markahan" ang mga klase sa java upang ang mga bagay ng mga klase ay makakakuha ng ilang mga kakayahan. Tulad ng ilang iba pang mga interface ng marker ay ang: - Cloneable at Remote atbp.

TANDAAN:

1. Kung ang isang magulang na klase ay nagpatupad ng isang Serializable interface sa gayon ang klase ng bata ay hindi kinakailangan na magpatupad ng pareho ngunit ang kabaligtaran ay hindi naaangkop.

2. Ang mga kasapi lamang na hindi static na data ang nakaimbak sa proseso ng Serialization.

3. Static na mga kasapi ng data at pati na rin ang mga pansamantalang miyembro ng data ay hindi naiimbak ng Serialization. Kaya, kung sakaling hindi natin kailangang iimbak ang halaga ng di-static na miyembro ng data pagkatapos ay magagawa natin itong pansamantala.

4. Ang tagapagbuo ay hindi kailanman tinawag kapag ang isang bagay ay deserialized.

HAKBANG 1: Ang unang hakbang ay karaniwang ang paglikha ng isang klase na nagpapatupad ng Serializable interface:

i-import ang java.io.Serializable;
pampubliko klase Dummy nagpapatupad Serializable {
    pribadong int i;
    pribadong data ng String;
    pampublikong Dummy (int i, String data)
    {
        ito.i = i;
        this.data = data;
    }
}

HAKBANG 2: Lumikha ng isang klase upang ma-serialize ito:

i-import ang java.io.FileNotFoundException;
i-import ang java.io.FileOutputStream;
import java.io.IOException;
i-import ang java.io.ObjectOutputStream;
pampublikong klase Serialize {
    public static void Serialization (Object classObject, String fileName) {
        subukan {
            FileOutputStream fileStream = bagong FileOutputStream (fileName);
            ObjectOutputStream objectStream = bagong ObjectOutputStream (fileStream);
            objectStream.writeObject (classObject);
            objectStream.close ();
            fileStream.close ();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace ();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace ();
        }
    }
    public static void main (String [] args) {
        Dummy dummyObj = bagong Dummy (10, "Lambda-geeks");
        Serialisasyon (dummyObj, "DummSerialized");
    }
}

HAKBANG 3: Kapag ang Step2 ay nakumpleto nang matagumpay pagkatapos ay makikita mo ang isang file na nilikha gamit ang ilang data dito, ang data na iyon ay karaniwang naka-serialize na data ng mga miyembro ng Bagay.

  Deserialization na may java:

Narito ang snippet ng code sa ibaba:

 pampublikong static na Object DeSerialize (String fileName)
    {
        subukan {
            FileInputStream fileStream = bagong FileInputStream (bagong File (fileName));
            ObjectInputStream objectStream = bagong ObjectInputStream (fileStream);
            Object deserializeObject = objectStream.readObject ();
            objectStream.close ();
            fileStream.close ();
            ibalik ang deserializeObject;
        } catch (FileNotFoundException e) {
            e.printStackTrace ();
        } catch (IOException e) {
            e.printStackTrace ();
        } catch (ClassNotFoundException e) {
            e.printStackTrace ();
        }
        ibalik ang null;
    }

Ganito ang Driver Code:

 public static void main (String [] args) {
      / * Dummy dummyObj = bagong Dummy (10, "Lambda-geeks");
        Serialisasyon (dummyObj, "DummSerialized");
        System.out.println ("------------------------------------------- ------------------------------ "";
      */
        Dummy deSerializedRect = (Dummy) DeSerialize ("DummSerialized");
        System.out.println ("Data Mula sa Serialized Object" + deSerializedRect.print ());
        System.out.println ("------------------------------------------- ------------------------------ "";
    }

JSONPATH Marami pang Syntax / Query:

Hinahayaan Ipagpalagay ang isang JSON sa ibaba:

{
  "OrganizationDetails": "Mga Detalye ng Dummy ng Organisasyon",
  "Rehiyon": "Asya",
  "Mga Detalye ng Emp": [
    {
      "Org": "lambda-Geeks",
      "Impormasyon": {
        "Ph": 1234567890,
        "Idagdag": "XYZ",
        "Edad": 45
      }
    },
    {
      "Org": "lambda-Geeks-2",
      "Impormasyon": {
        "Ph": 2134561230,
        "Idagdag": "ABC",
        "Edad": 35
      }
    }
  ]
}

sa nabanggit na JSON, ang OrganizationDetails & Region ay tinawag bilang Leaf node dahilan na wala silang anumang karagdagang mga node / elemento ng bata ngunit sa kabilang banda ang Emp-Details na mayroong node ng bata, samakatuwid hindi ito tinukoy bilang Leaf node.

Dito kung susubukan nating makuha ang halaga ng OrganizationDetails kung gayon kailangan nating gamitin:

$ .OrganizationDetails 
Magreresulta ito sa:
 [
  "Mga Detalye ng Dummy ng Organisasyon"
]

Tulad ng Wise upang makuha ang data para sa rehiyon na kailangan nating isulat:

$ .Rehiyon 

Kung nais naming hanapin ang halaga ng Edad para sa Ika-1 na Empleyado maaari kaming magsulat:

$ .Emp-Details [0] .Information. Edad
Magreresulta ito sa:
[
  45
]

Para sa Edad ng Ika-2 na empleyado maaari kaming magsulat tulad ng

$ .Emp-Details [1] .Information. Edad
Magreresulta ito sa: [35]

Sa ganitong paraan maaari nating malaman ang ekspresyon / query ng JsonPath upang makuha ang data para sa kani-kanilang mga patlang sa JSON.

Tungkol kay Debarghya

Pagsubok sa Rest API || Mabilis na Patnubay sa RestAssured tutorial 2020Ang Sarili kong Debarghya Roy, ako ay isang Engineering ARCHITECT na nagtatrabaho kasama ang fortune 5 na kumpanya at isang open source na nag-aambag, pagkakaroon ng humigit-kumulang 12 taong karanasan / kadalubhasaan sa iba't ibang stack ng Teknolohiya.
Nagtrabaho ako sa iba't ibang mga teknolohiya tulad ng Java, C #, Python, Groovy, UI Automation (Selenium), Mobile Automation (Appium), API / Backend Automation, Performance Engineering (JMeter, Locust), Security Automation (MobSF, OwAsp, Kali Linux , Astra, ZAP atbp), RPA, Process Engineering Automation, Mainframe Automation, Back End Development na may SpringBoot, Kafka, Redis, RabitMQ, ELK stack, GrayLog, Jenkins at mayroon ding karanasan sa Cloud Technologies, DevOps atbp.
Nakatira ako sa Bangalore, India kasama ang aking asawa at may hilig sa Blogging, musika, pagtugtog ng gitara at ang aking Pilosopiya ng buhay ay Edukasyon para sa Lahat na nagbigay ng kapanganakan ng LambdaGeeks. Hinahayaan nating kumonekta sa loob ng naka-link - https://www.linkedin.com/in/debarghya-roy/

en English
X