Rest API-ի փորձարկում || RestAssured ձեռնարկի արագ ուղեցույց 2020

Վստահ եղեք API-ի թեստավորում Rest API Testing ավտոմատացման համար

RestAssured - Մնացած վստահված ձեռնարկը api-ի փորձարկում
Վստահ եղեք API-ի ավտոմատացում

Վստահ եղիր այս սպառիչ ձեռնարկում մենք սովորելու ենք Հանգստացեք API-ի խորությամբ փորձարկում, API թեստի ավտոմատացում և վստահ եղեք մոդուլյարացված մոտեցմամբ

Ինչ է RestAssured-ը և դրա օգտագործումը

Վստահ եղեք, շատ լայնորեն օգտագործվող բաց կոդով տեխնոլոգիա է REST API-ի ավտոմատացման փորձարկման համար, որը հիմնված է java-ի վրա հիմնված գրադարանի վրա:

Վստահ եղեք, համագործակցում է Rest API-ի հետ առանց գլխի հաճախորդի ռեժիմում, մենք կարող ենք նույն հարցումը կատարելագործել՝ ավելացնելով տարբեր շերտեր՝ հարցումը ձևավորելու և HTTP հարցում ստեղծելու համար տարբեր HTTPS բայերի միջոցով սերվերին:

Վստահ եղեք, ներկառուցված գրադարանում տրամադրվում են հսկայական մեթոդներ և օգտակար ծառայություններ սերվերից ստացված պատասխանի վավերացումն իրականացնելու համար, ինչպիսիք են կարգավիճակի հաղորդագրությունը, կարգավիճակի կոդը և պատասխանի մարմինը:

«Rest Assured» ձեռնարկի այս ամբողջական շարքը REST API ավտոմատացման փորձարկման համար բաղկացած է հետևյալ թեմաներից.

Սկսում ենք. restAssured-ի կազմաձևում Build գործիքի միջոցով, այսինքն՝ Maven/gradle

ՔԱՅԼ 1. Եթե դուք աշխատում եք maven-ի հետ, պարզապես ավելացրեք հետևյալ կախվածությունը pom.xml-ում (կարող եք ընտրել նաև ցանկացած այլ տարբերակ).

REST Assured-ով սկսելու համար պարզապես ձեր նախագծին ավելացրեք կախվածությունը: 


    io.վստահ եղիր
    հանգիստ
    4.3.0
    փորձարկում

Եթե ​​դուք աշխատում եք gradle-ի հետ, պարզապես ավելացրեք հետևյալը build.gradle-ում (կրկին կարող եք ընտրել նաև ցանկացած այլ տարբերակ).

testCompile խումբ՝ «io.rest-assured», անունը՝ «rest-assured», տարբերակ՝ «4.3.0»

ՔԱՅԼ 2. REST Assured-ը կարող է շատ հեշտությամբ ինտեգրվել և օգտագործվել առկա միավորի թեստային շրջանակների հետ, օրինակ՝ Testng, JUnit

Այստեղ մենք օգտագործում ենք testNg՝ համաձայն Unit Test Framework-ի:

Երբ Rest Sured-ի գրադարանները ներմուծվեն, մենք պետք է ավելացնենք հետևյալ ստատիկ ներմուծումները մեր թեստային դասերին.

ներմուծել ստատիկ io.restassured.RestAssured.*;

ներմուծել ստատիկ org.hamcrest.Matchers.*;

ՆՇՈՒՄ : Այս առաջիկա ուսումնական նպատակի համար մենք կփորձարկենք Ergast Developer API-ն, որը կարելի է գտնել այստեղ. Այս API-ն տրամադրում է պատմական տվյալներ՝ կապված Ֆորմուլա 1-ի մրցարշավների, վարորդների, սխեմաների և այլնի հետ:

Ծանոթություն շարահյուսությանը.

Վստահ եղեք, որ աջակցում է BDD ձևաչափին (Գերկինի շարահյուսություն) թեստային սցենարները գրելու համար, այսինքն՝ Given/When/Then/And ձևաչափով, մենք ենթադրում ենք, որ դուք հասկանում եք BDD/gherkin շարահյուսությունը, եթե ոչ, ապա մենք առաջարկում ենք 30 րոպե ժամանակ հատկացնել՝ հասկանալու համար, թե ինչ է BDD-ը (Գերկինի շարահյուսություն) և ինչպես է այն աշխատում և դա շատ հիմնական է:

T-01 : Մեր 1-ին սցենարը, որը հիմնականում վավերացնում է F1 սխեմաների թիվը 2017 թվականին՝ օգտագործելով այս API-ն (http://ergast.com/api/f1/2017/circuits.json)

@Test(description = «Սխեմաների թիվը 2017-ի սեզոնին պետք է լինի 20») public void validatingNumberOfCircuits() {ved().when().get("http://ergast.com/api/f1/2017/circuits. json»): then().assertThat().body("MRData.CircuitTable.Circuits.circuitId", hasSize(20)); }

Հանգիստ API պատասխանի վավերացում :

1. Գրավում է API հարցման JSON պատասխանը:

2. հարցումներ circuitId-ի համար՝ օգտագործելով GPath արտահայտությունը «MRData.CircuitTable.Circuits.circuitId»

3. Ստուգում է, որ circuitId տարրերի հավաքածուն ունի 20 չափս

Այստեղ մենք օգտագործում ենք Hamcrest համապատասխանողներ տարբեր վավերացման համար, ինչպիսիք են

Կան տարբեր այլ մեթոդներ, որոնք օգտակար են որոշակի վավերացում կատարելու համար:

Դուք կարող եք նաև հղում կատարել Համկրեստի գրադարանի փաստաթղթերին համընկնումների և մեթոդների ամբողջական ցանկի համար:

Վավերացնող պատասխանի կոդը.

տրված().when().get("http://ergast.com/api/f1/2017/circuits.json").then().assertThat().statusCode(200);

Բովանդակության տեսակի վավերացում

տրված().when().get("http://ergast.com/api/f1/2017/circuits.json").then().assertThat().contentType(ContentType.JSON);

«Բովանդակության երկարություն» վերնագրի վավերացում

տրված().when().get("http://ergast.com/api/f1/2017/circuits.json").then().assertThat().header("Content-Length",equalTo("4551"));

Բազմակի վավերացում մեկ թեստերում որպես (օգտագործելով և () մեթոդները):

@Test (նկարագրություն = «2017 սեզոնում սխեմաների թիվը պետք է լինի 20»)
    public void validatingNumberOfCircuits() {
        տրված().when().get("http://ergast.com/api/f1/2017/circuits.json").then().assertThat().header("Content-Length",equalTo(" 4551")).and().statusCode(200);
    }

Պատասխանող մարմնի տարր/հատկանիշ վավերացնող.

Մենք կարող ենք օգտագործել JsonPath-ը՝ json ատրիբուտների արժեքը ստանալու և TestNg-ի միջոցով պնդումներ դնելու համար

@Test (նկարագրություն = «Սերիաների անվան վավերացում, որը f1 է»)
    public void validatingSeriesName() {
        //Փոխակերպեք ResponseBody-ը տողի
        Լարի պատասխանBody=given().when().get("http://ergast.com/api/f1/2017/circuits.json").getBody().asString();
        //Ստեղծեք JsonPath օբյեկտ՝ փոխանցելով Response Body-ը որպես տող
        JsonPath resJson=նոր JsonPath(responseBody);
        //Վերցրեք հատկանիշի արժեքների շարքը MRData-ի տակ
        String seriesName=resJson.getString("MRData.series");
        // Օգտագործողի TestNg պնդում
        Assert.assertEquals("f1",seriesName);
    }

Նույն ձևով մենք կարող ենք ստանալ XML պատասխանի արժեքը՝ օգտագործելով XMLPath: Այստեղ մենք աշխատում ենք JSON-ի հետ, հետևաբար մենք այստեղ օգտագործել ենք JSonPath

RESTful API-ներն աջակցում են միայն երկու տեսակի պարամետրեր.

A. Հարցման պարամետրեր. Այստեղ պարամետրերը կցվում են API-ի վերջնակետի վերջում և կարող են նույնականացվել հարցականով և ձևավորել առանցքային արժեքների զույգ, ինչպիսիք են. 

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

Այստեղ վերը նշված API-ում «q» պարամետրն է, իսկ «https://www.wikipedia.org/»-ն այդ պարամետրի արժեքն է, եթե որոնենք «SOMETHING_ELSE_TEXTմենք կարող ենք փոխարինել պարամետրի արժեքը «q» հետ 'SOMETHING_ELSE_TEXThttps://www.wikipedia.org/-ի փոխարեն։

B. Ուղու պարամետրեր. Սրանք RESTful API վերջնակետի մասն են: 

օր. վերջնակետը, որը մենք օգտագործել ենք ավելի վաղ՝ http://ergast.com/api/f1/2017/circuits.json, այստեղ «2017»-ը ուղու պարամետրի արժեք է:

Տարվա արդյունք ստանալու համար 2016 թվականը մենք կարող ենք 2017 թվականը փոխարինել 2016-ով ապա API-ն կտա պատասխան մարմինը 2016թ.

Թեստեր՝ օգտագործելով Path Params-ը RestAssured-ի համար

@Test (նկարագրություն = «Շղթաների քանակի վավերացում՝ օգտագործելով Path Params»)
    public void testWithPathParams() {
        String seasonNumber = «2017»;
       String answerBody = dhënë().pathParam("season", seasonNumber).when().get("http://ergast.com/api/f1/{season}/circuits.json").getBody().asString ();
        //Ստեղծեք JsonPath օբյեկտ՝ փոխանցելով Response Body-ը որպես տող
        JsonPath resJson = նոր JsonPath(responseBody);
        //Վերցրեք հատկանիշի արժեքների շարքը MRData-ի տակ
        String seriesName = resJson.getString ("MRData.series");
        // Օգտագործողի TestNg պնդում
        Assert.assertEquals("f1", seriesName);
    }

Թեստեր RestAssured-ի համար Query Params-ի միջոցով

@Test (նկարագրություն = «Google-ի որոնման վավերացում հարցումների պարամետրերի միջոցով»)
    public void testWithPathParams() {
        Տողային որոնման տարր = "https://www.wikipedia.org/";
  տրված().queryParam("q",searchItem).when().get("https://www.google.com/search").then().assertThat().statusCode(200);
    }

Պարամետրավորման թեստեր.

Մենք կարող ենք կատարել տվյալների վրա հիմնված թեստավորում (այսինքն՝ նույն թեստային սկրիպտը կկատարվի մի քանի անգամ՝ մուտքային տվյալների տարբեր հավաքածուներով և տրամադրելու տարբեր ելքային տվյալներ)՝ օգտագործելով Վստահ եղեք։ 

ՔԱՅԼ 1. Ստեղծել է testNg տվյալների մատակարար:

ՔԱՅԼ 2. Սպառեք Տվյալների մատակարարը թեստային սցենարում:

@DataProvider (անուն = "seasonsAndRaceNumbers")
    հանրային օբյեկտ[][] testDataFeed() {
        վերադարձնել նոր օբյեկտ[][] {
                {«2017»,20},
                {«2016»,21}
        };
    }
@Test (նկարագրություն = "Սխեմաների քանակի վավերացում տարբեր սեզոններում",dataProvider = "սեզոններ AndRaceNumbers") public void circuitNumberValidation(String seasonYear,int raceNumbers) {տրված().pathParam («սեզոն», սեզոնՏար).when().get("http://ergast.com/api/f1/{սեզոն}/circuits.json").then().assertThat().body("MRData.CircuitTable.Circuits.circuitId",hasSize(մրցավազքի համարներ)); }

Աշխատեք բազմարժեք պարամետրերով RestAssured-ի հետ 

Բազմարժեք պարամետրերն այն պարամետրերն են, որոնք մեկ պարամետրի անվան համար ունեն մեկից ավելի արժեք (այսինքն՝ մեկ պարամետրի արժեքների ցանկ), մենք կարող ենք դրանք հասցեագրել հետևյալ կերպ.

give().param("paramKey", "paramValue1", "paramaValue2").when().get("API URL");

Կամ մենք կարող ենք ցուցակ պատրաստել և ցուցակը փոխանցել որպես paramKey-ի արժեք, ինչպիսին է.

Ցուցակ paramValue=նոր նոր ArrayList ();
paramValue.add («paramvalue1»);
paramValue.add («paramvalue2);
give().param("paramKey", paramValue).when().get("API URL");
Cookie-ի հետ աշխատել RestAssured-ի հետ 
give().cookie("cookieK", "cookieVal").when().get("API URL");

Or 

Այստեղ մենք կարող ենք նաև նշել բազմարժեք թխուկ, ինչպիսին է.

give().cookie("cookieK", "cookieVal1", "cookieVal2").when().get("API URL");

Վերնագրերի հետ աշխատելը.

Հարցման մեջ մենք կարող ենք նշել՝ օգտագործելով վերնագիր/վերնագրեր, ինչպիսիք են՝

տրված ().header ("headerK1","headerValue1").header ("headerK2","headerValue2").when ().get ("API URL");

Աշխատում է բովանդակության տեսակով.

give().contentType("application/json").when().get("API URL");

Or 

give().contentType(ContentType.JSON).when().get();

Չափել արձագանքման ժամանակը.

երկար ժամանակDurationInSeconds = ստանալ («API URL»).timeIn (SECONDS);

Հանգիստ API վավերացում

Վստահ եղեք, որ աջակցում են տարբեր վավերացման սխեմաներ, օրինակ՝ OAuth, digest, վկայական, ձև և կանխարգելիչ հիմնական նույնականացում: Մենք կամ կարող ենք նույնականացում սահմանել յուրաքանչյուր հարցման համար 

ահա օրինակելի հարցումը, օգտագործելով նույնը.

dhënë().auth().basic("uName", "pwd").when().get("URL") ..

Մյուս կողմից իսկությունը և սահմանված է ստորև բերված մոտեցմամբ HTTP հարցումների համար.

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

Հիմնական AUTH տեսակները.

Գոյություն ունեն հիմնական վավերացման երկու տեսակ՝ «կանխարգելիչ» և «վիճարկվող նշանային հիմնական նույնականացում»:

Preemptive Basic Auth:

Սա կուղարկի նույնականացման հիմնական հավատարմագիրը նույնիսկ նախքան սերվերը որոշակի իրավիճակներում չլիազորված պատասխան կտա՝ հայտի գործարկման հետ մեկտեղ, այդպիսով նվազեցնելով լրացուցիչ կապ հաստատելու ծախսերը: Սա սովորաբար հիմնականում առաջանում է իրավիճակներ, եթե մենք չենք փորձարկում սերվերների վիճարկելու ունակությունը: 

Օրինակ

give().auth().preemptive().basic("uName", "pwd").when().get("URL").then().statusCode(200);

Վիճարկված հիմնական նույնականացում

Մյուս կողմից, «վիճարկված հիմնական նույնականացումը» REST Assured-ը չի տրամադրի հավատարմագրերը, քանի դեռ սերվերը բացահայտորեն չի խնդրել դա, այսինքն՝ սերվերը չի նետում Չլիազորված պատասխանը: Դրանից հետո Չլիազորված պատասխանը Rest-Assured-ը ևս մեկ հարցում է ուղարկում սերվերին, որը հանդիսանում է Auth-ը:

տրված().auth().basic("uName", "pwd").when().get("URL").then().statusCode(200);

Digest վավերացում

Այս պահի դրությամբ դիտարկվում է միայն «մարտահրավերի նույնականացումը»: օրինակ՝

տրված().auth().digest("uName", "pwd").when().get("URL").then().statusCode(200); 

Ձևի վավերացում

Մենք կարող ենք դրան հասնել հիմնականում 3 տարբեր մոտեցումներով՝ կախված Դիմումից/Սցենարներից.

Ձևի նույնականացումը համացանցում շատ տարածվածներից է, երբ օգտատերը վեբ էջի միջոցով մուտքագրում է իր հավատարմագրերը, այսինքն՝ օգտվողի անունը և գաղտնաբառը և մուտք է գործում համակարգ: Սա կարող է լուծվել այս միջոցով: 

տրված().auth().form("uName", "pWd"):
when().get("URL");
then().statusCode(200);

Թեև սա կարող է չաշխատել, քանի որ այն օպտիմալ է, և այն կարող է անցնել կամ ձախողվել՝ կախված վեբ էջի բարդությունից: Ավելի լավ տարբերակ է տրամադրել այս մանրամասները հետևյալ մոտեցմամբ ձևի իսկությունը կարգավորելիս.

dhënë().auth().form("uName", "pwd", new FormAuthConfig("/'նշեք այստեղ ձևի գործողության անունը, որը html էջի կոդի մաս է կազմում ձևի պիտակի տակ'", "uName", "pwd" ")).when().get("URL").then().statusCode(200);

Այս մոտեցման դեպքում REST Assured-ը ներքին կարգով չի պահանջի գործարկել լրացուցիչ հարցում և վերլուծել վեբ էջի միջոցով: 

Եթե ​​դուք օգտագործում եք լռելյայն Spring Security, ապա գործարկվում է նախապես սահմանված FormAuthConfig:

give().auth().form("uName", "Pwd", FormAuthConfig.springSecurity()).when().get("URL").then().statusCode(200);

ԾԱՆՈԹԱԳՐՈՒԹՅՈՒՆ. Եթե մենք ցանկանում ենք լրացուցիչ մուտքային տվյալներ ուղարկել auth ձևի հետ միասին, ապա կարող ենք գրել ստորև.

տրված().auth().form("uName", "pwd", formAuthConfig().withAdditionalFields("firstInputField", "secondInputField") ..

CSRF:

CSRF-ը նշանակում է Cross-site հարցումների կեղծում:

Մեր օրերում շատ տարածված է, որ սերվերը տրամադրում է CSRF նշան՝ պատասխանով, որպեսզի խուսափի CSRF անվտանգության հարձակումներից: REST Assured-ն աջակցում է դրան՝ օգտագործելով և ավտոմատ վերլուծիչ և տրամադրելով CSRF նշան: 

Այս REST-ին հասնելու համար վստահվածները պետք է լրացուցիչ հարցում կատարեն և վերլուծեն (մի քանի դիրք) կայքը:

Մենք կարող ենք միացնել CSRF աջակցությունը՝ գրելով ստորև նշված կոդը.

give().auth().form("uName", "pwd", formAuthConfig().withAutoDetectionOfCsrf()).when().get("URL").then().statusCode(200);

Ի հավելումն REST Assured-ին օգնելու և վերլուծությունն ավելի անթերի և ամուր դարձնելու համար մենք կարող ենք տրամադրել CSRF դաշտի անվանումը (այստեղ մենք ենթադրում ենք, որ մենք օգտագործում ենք Spring Security լռելյայն արժեքները և կարող ենք օգտագործել նախապես սահմանված springSecurity FormAuthConfig):

give().auth().form("uName", "pwd", springSecurity().withCsrfFieldName("_csrf")).when().get("URL").then().statusCode(200);

Լռելյայնորեն CSRF արժեքը փոխանցվում է որպես ձևի պարամետր հարցումով, բայց մենք կարող ենք կարգավորել այն ուղարկել որպես վերնագիր, եթե այն պահանջվում է ստորև.

give().auth().form("uName", "pwd", springSecurity().withCsrfFieldName("_csrf").sendCsrfTokenAsHeader()).when().get("URL").then().statusCode (200);

OAuth 1:

OAuth 1-ը պահանջում է, որ Scribe-ը լինի դասարանում: oAuth 1 նույնականացումն օգտագործելու համար մենք կարող ենք անել.

տրված().auth().oauth(..).երբ(). ..

OAuth 2:

տրված().auth().oauth2(accessToken).when(): ..

Վերոնշյալ մոտեցման դեպքում OAuth2 accessToken-ը կդիտարկվի վերնագրի տեսքով: Ավելի հստակ լինելու համար մենք կարող ենք նաև անել.

տրված().auth().preemptive().oauth2(accessToken).when(). ..

Ֆայլի, բայթ զանգվածի, մուտքագրման հոսքի կամ տեքստի փոխանցում հարցումում.

Սերվերին մեծ քանակությամբ տվյալներ ուղարկելիս, ընդհանուր առմամբ, սովորական մոտեցում է օգտագործել տվյալների բազմաբնույթ ձևի տեխնիկան: Վստահ եղեք, տրամադրում են մեթոդներ, որոնք կոչվում են MultiPart, որոնք թույլ են տալիս մեզ նշել ֆայլ, բայթ-զանգված, մուտքագրման հոսք կամ տեքստ վերբեռնելու համար: 

give().multiPart(new File("/File_Path")).when().post("/upload");

POST Request Creation-ը վստահ եղեք

POST-ի և PUT-ի հարցումներով մենք Տվյալներն ուղարկում ենք սերվեր և դրա հիման վրա ռեսուրսների ստեղծում/ռեսուրսների թարմացում, դուք կարող եք դա համարել որպես գրելու կամ թարմացնելու գործողություն:

Տվյալները, որոնք ուղարկվում են սերվերին POST հարցումով, ուղարկվում են HTTP հարցում/API զանգի մարմնում: 

Ուղարկվող բովանդակության կամ տվյալների տեսակը կարող է լինել տարբեր ձևաչափի՝ կախված API-ից, այսինքն՝ XML, JSON կամ որևէ այլ ձևաչափ, որը սահմանվում է Content-Type վերնագրի կողմից: 

Եթե ​​POST մարմինը բաղկացած է JSON տվյալներից, ապա վերնագրի Content-Type-ը կլինի application/json: Նմանապես, POST հարցումի համար, որը բաղկացած է XML-ից, ապա վերնագրի Content-Type-ը կլինի application/xml տիպի:

Ահա ստորև նշված կոդի հատվածը նույնի համար.

give().contentType("application/json").param("pk","pv").when().body("JsonPAyloadString").post("url").then().assertThat(): statusCode(200);

ԾԱՆՈԹՈՒԹՅՈՒՆ. Կան տարբեր եղանակներ, որոնցով մենք կարող ենք փոխանցել ծանրաբեռնվածությունը/հարցման մարմինը «body» մեթոդի ներսում, օրինակ՝ String (ինչպես ցույց է տրված վերևի հատվածում), JsonObject, որպես Ֆայլ և այլն,

PUT հարցումը վստահ եղեք.

give().contentType("application/json").param("pk","pv").when().body("JsonPAyloadString").put("url").then().assertThat(): statusCode(200);

Ջնջել հարցումը Rest-Assured-ով.

give().contentType("application/json").param("pk","pv").when().delete("url").then().assertThat().statusCode(200);

Եվ այդ կերպ մենք կարող ենք ստեղծել տարբեր Rest API կանչ տարբեր API բայերի համար (GET/POST/PUT/DELETE և այլն)

Սերիալացում և ապասերիալացում Java-ում.

Սերիալացումը հիմնականում մշակում կամ փոխակերպում է օբյեկտի վիճակը բայթ հոսքի: Մյուս կողմից, Java-ում Deserialization-ը մշակում կամ փոխակերպում է բայթային հոսքը իրական Java օբյեկտի հիշողության մեջ: Այս մեխանիզմն օգտագործվում է Օբյեկտի կայունության մեջ:

Ստորև բերված է նույնի բլոկային դիագրամը 

Սերիալիզացիայի առավելությունները

A. Պահպանել/պահպանել օբյեկտի վիճակը:

Բ. Օբյեկտը ցանցով հոսելու համար:

JAVA-ի միջոցով սերիալիզացիայի ձեռքբերում

Java-ի սերիականացման ենթակա օբյեկտի հասնելու համար մենք պետք է իրականացնենք java.io.Serializable ինտերֆեյսը:

ObjectOutputStream դասը, որը պարունակում է writeObject() մեթոդ, որը պատասխանատու է օբյեկտի սերիականացման համար:

ObjectInputStream դասը պարունակում է նաև մեկ այլ մեթոդ, որը կոչվում է readObject(), որը պատասխանատու է օբյեկտի ապասերիալացման համար:

դասեր, որոնք իրականացնում են java.io.Serializable ինտերֆեյս, այնտեղ օբյեկտը կարող է միայն սերիալացվել:

Serializable-ը պարզապես մարկերային ինտերֆեյս է և, ինչպես շուկայական այլ ինտերֆեյս, այն չունի տվյալների անդամ կամ դրա հետ կապված մեթոդ: որն օգտագործվում է java դասերը «նշելու» համար, որպեսզի այս դասերի օբյեկտները ստանան որոշակի հնարավորություններ: Ինչպես ևս մի քանի մարկերային միջերեսներ, հետևյալն են.- Cloneable և Remote և այլն:

ԾԱՆՈԹԱԳՐՈՒԹՅՈՒՆՆԵՐ.

1. Եթե ծնող դասը ներդրել է Serializable ինտերֆեյս, ապա երեխայի դասը չի պահանջվում իրականացնել նույնը, բայց հակառակը կիրառելի չէ:

2. Սերիալիզացիայի գործընթացում պահվում են միայն ոչ ստատիկ տվյալների անդամները:

3. Ստատիկ տվյալների անդամները և նաև անցողիկ տվյալների անդամները չեն պահպանվում Սերիալիզացիայի միջոցով: Այսպիսով, եթե մենք կարիք չունենանք պահել ոչ ստատիկ տվյալների անդամի արժեքը, մենք կարող ենք այն դարձնել անցողիկ:

4. Կոնստրուկտորը երբեք չի կանչվում, երբ օբյեկտը ապասերիալացվում է:

ՔԱՅԼ 1. Առաջին քայլը հիմնականում դասի ստեղծումն է, որն իրականացնում է Serializable ինտերֆեյսը.

ներմուծել java.io.Serializable;
public class Dummy implements Serializable {
    մասնավոր int i;
    մասնավոր տողային տվյալներ;
    հանրային կեղծ (int i, լարային տվյալներ)
    {
        this.i = i;
        this.data = տվյալներ;
    }
}

ՔԱՅԼ 2. Ստեղծեք դաս՝ այն սերիականացնելու համար.

ներմուծել java.io.FileNotFoundException;
ներմուծել java.io.FileOutputStream;
ներմուծել java.io.IOException;
ներմուծել java.io.ObjectOutputStream;
հանրային դասի Սերիալիզացիա {
    հանրային ստատիկ դատարկ սերիականացում (Օբյեկտի դասի օբյեկտ, լարային ֆայլի անունը) {
        փորձեք {
            FileOutputStream fileStream = նոր FileOutputStream(fileName);
            ObjectOutputStream objectStream = նոր ObjectOutputStream(fileStream);
            objectStream.writeObject(classObject);
            objectStream.close();
            fileStream.close();
        } catch (FileNotFoundException e) {
            // TODO Ավտոմատ ստեղծվող բռնման բլոկ
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Ավտոմատ ստեղծվող բռնման բլոկ
            e.printStackTrace();
        }
    }
    public static void main (String [] args) {
        Dummy dummyObj = նոր Dummy(10, «Lambda-geeks»);
        Սերիալացում (dummyObj, «DummSerialized»);
    }
}

ՔԱՅԼ 3. Երբ Քայլ 2-ը հաջողությամբ ավարտվի, դուք կտեսնեք, որ ստեղծվել է մի ֆայլ, որը պարունակում է որոշ տվյալներ, այդ տվյալները հիմնականում Օբյեկտի անդամների սերիականացված տվյալներ են:

  Deserialization java-ով.

Ահա ստորև բերված կոդի հատվածը.

 հանրային ստատիկ օբյեկտի Deserialize (լարային ֆայլի անունը)
    {
        փորձեք {
            FileInputStream fileStream = նոր FileInputStream (նոր Ֆայլ (ֆայլի անուն));
            ObjectInputStream objectStream = նոր ObjectInputStream(fileStream);
            Օբյեկտ deserializeObject = objectStream.readObject();
            objectStream.close();
            fileStream.close();
            վերադարձնել deserializeObject;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        վերադարձնել զրոյական;
    }

Վարորդի ծածկագիրը հետևյալն է.

 public static void main (String [] args) {
      /* Dummy dummyObj = new Dummy(10, «Lambda-geeks»);
        Սերիալացում (dummyObj, «DummSerialized»);
        System.out.println ("------------------------------------------- -------------------------------»);
      */
        Dummy deSerializedRect = (Dummy) DeSerialize ("DummSerialized");
        System.out.println ("Տվյալներ սերիականացված օբյեկտից" + deSerializedRect.print());
        System.out.println ("------------------------------------------- -------------------------------»);
    }

JSONPATH Լրացուցիչ շարահյուսություն/հարցում.

Ենթադրենք JSON ստորև.

{
  «OrganizationDetails»: «Կազմակերպության կեղծ տվյալները»,
  «Տարածաշրջան»: «Ասիա»,
  «Emp-Details»:
    {
      «Օրգ»՝ «լամբդա-գիքներ»,
      «Տեղեկություն»: {
        «Ph»՝ 1234567890,
        «Ավելացնել»: «XYZ»,
        «Տարիքը»՝ 45
      }
    },
    {
      «Օրգ»՝ «lambda-Geeks-2»,
      «Տեղեկություն»: {
        «Ph»՝ 2134561230,
        «Ավելացնել»: «ABC»,
        «Տարիքը»՝ 35
      }
    }
  ]
}

Վերոնշյալ JSON-ում OrganisationDetails & Region-ը կոչվում է Leaf հանգույց, քանի որ նրանք չունեն այլ զավակային հանգույցներ/տարրեր, բայց, ինչպես մյուս կողմից, Emp-Details-ն ունի երեխա հանգույց, հետևաբար այն չի նշվում որպես Leaf հանգույց:

Այստեղ, եթե մենք փորձենք ստանալ OrganizationDetails-ի արժեքը, ապա մենք պետք է օգտագործենք.

$.OrganizationՄանրամասներ 
Սա կհանգեցնի.
 [
  «Կազմակերպության կեղծ մանրամասներ»
]

Wise-ի պես տարածաշրջանի տվյալները ստանալու համար մենք պետք է գրենք.

$.Տարածաշրջան 

Եթե ​​մենք ուզում ենք գտնել Տարիքի արժեքը 1-ին աշխատակցի համար, ապա կարող ենք գրել.

$.Emp-Details[0].Information.Age
Սա կհանգեցնի.
[
  45
]

2-րդ աշխատակցի տարիքի համար մենք կարող էինք գրել նման

$.Emp-Details[1].Information.Age
Սա կհանգեցնի՝ [35]

Այս կերպ մենք կարող ենք պարզել JsonPath արտահայտությունը/հարցումը JSON-ում համապատասխան դաշտերի տվյալները ստանալու համար: