de Prithviraj Pawar

Cum să vă puneți în funcțiune serverul Java GraphQL în cel mai scurt timp

GraphQL este un limbaj de interogare pentru preluarea datelor pe internet. De când a fost anunțat public de Facebook în 2015, a stârnit interesul multor minți. GraphQL a fost utilizat în principal în JavaScript. De fapt, Facebook a lansat implementarea de referință pentru aceasta în JavaScript (graphql-js).

Dar această postare de blog se va concentra pe dezvoltarea serverului GraphQL în Java. GraphQL-Java este implementarea corespunzătoare GraphQL în Java și primește actualizări și îmbunătățiri ale versiunii aproape în fiecare lună. Funcții precum instrumentele, apelurile asincrone către backend, încărcătorul de date, directivele și multe altele fac din acesta un depozit foarte interesant și puternic în Java.

Cum sa va puneti in functiune serverul Java GraphQL in
GraphQL Java

Cum se construiește un server Java GraphQL în springboot

Să luăm exemplul unei școli de magie din Universul Harry Potter. Datele școlii de magie sunt următoarele:

Cum sa va puneti in functiune serverul Java GraphQL in

Aici Magazinele de date pot fi servere backend sau chiar baze de date. O preluare RESTful va arăta ca mai jos.

GET: /student?{parameters}GET: /House?{parameters}

Expuneți practic o interfață pentru un serviciu. Astfel dacă Profesori sunt adăugate în modelul de mai sus, apoi trebuie deschis un nou punct final și clientul trebuie să facă mai multe călătorii dus-întors. De asemenea, dacă clientul dorește date imbricate precum Bagheta lui Harry origine sau Culoarea casei lui Ron, atunci serverul API trebuie să apeleze backend-ul de două ori. De asemenea, va rezulta unele informații nedorite despre casă și baghetă.

Introduceți GraphQL: GraphQL este o abordare bazată pe schemă pentru preluarea datelor. Modelează datele ca grafice și trebuie să lansați o interogare pentru a prelua datele. Funcționează ca SQL, dar pentru obiecte web. Deci, o interogare graphQL pentru Harry se pare ca:

query{Magic School{Student{namewand{origin}}}}

Înainte de a intra în GraphQL, trebuie să configurăm un MVC de primăvară. Cel mai simplu mod de a face acest lucru este SpringBootStarter. Puteți selecta instrumentul de automatizare a construcției dorit. Acest lucru oferă un pachet de Tomcat încorporat în primăvară gata de rulare pe portul 8080. Pentru a testa Tomcat, rulați:

$gradle clean build$java -jar ./build/libs/graphql-demo-0.0.1-SNAPSHOT.jar

În mod implicit, Gradle numește JAR-ul dvs. „project_name-version-SNAPSHOT.jar”. Verifica http: localhost: 8080 pentru a vedea Tomcat rulând pe portul 8080.

Să adăugăm acum un GraphQL-Java dependența noastră build.gradle.

dependencies {compile('com.graphql-java:graphql-java:{version}')compile group: 'org.json', name: 'json', version: '20170516'}

Adăugați versiunea curentă așa cum se găsește în mavenCentral repertoriu. În prezent, cea mai recentă versiune este 8.0. Adăugați și org.json, care este o bibliotecă la îndemână, deoarece GraphQL gestionează răspunsul la cerere în JSON.

După cum am menționat mai devreme, GraphQL este un limbaj bazat pe schemă. Solicită utilizatorilor să selecteze obiecte în interogarea împotriva schemei.

Să ne aruncăm direct în:

Am deschis un / graphql interfață pentru solicitările GraphQL POST. Trebuie să creăm o schemă pentru reprezentarea datelor.

  • SchemaGenerator analizează schema și creează un Arborele sintaxei abstracte cu nume de câmp ca noduri copil.
  • Apoi câmpurile sunt atribuite tipuri de TypeDefinitionRegister, de exemplu Int, String și așa mai departe. GraphQL are un aspect frumos Tip sistem în care putem avea tipuri personalizate în schemă, inclusiv enum, interfețe, uniuni, liste și multe altele.
  • Uită-te la RuntimeWiring () pas în care câmpul „MagicSchool” este mapat la „Hogwarts” de către un StaticDataFetcher.
  • Fiecare câmp este susținut de un datafetcher, și este treaba lui datafetcher să rezolve datele și să revină la GraphQL.
  • Apoi GraphQL îl conectează cu numele schemelor definite, indiferent dacă este o hartă cu liste imbricate sau o hartă generică. GraphQL o face atâta timp cât definiți schema adecvată.
  • După trimiterea acestor date către ExecutionInput, motorul GraphQL analizează-> validează-> preluează-> execută interogarea și vă returnează o ieșire JSON a răspunsuluise foloseste .toSpecifiație ()

Să lansăm o interogare folosind GraphiQL. Adăugați această extensie în browser și setați punctul final.

1611467467 580 Cum sa va puneti in functiune serverul Java GraphQL in

Uitați-vă cum forma interogării dvs. determină forma răspunsului. Schema poate fi vizualizată corect datorită naturii introspective a GraphQL. Acest lucru permite validarea și verificarea sintaxei schemei în mod automat datorită Arborelui abstract de sintaxă creat în timpul analizei schemei.

Să adăugăm câteva câmpuri în schemă. Vom construi un Limbajul definiției schemei. Creați un fișier numit magicSchool.graphql.

type Query{magicSchool:MagicSchool}type MagicSchool{name: StringHeadMaster:Stringstudent:Student}type Student{name:Stringwand:Wandhouse:House}type House{name:Stringcolor:Stringpoints:Int}type Wand{name:Stringorigin:String}

Modificați sursa schemei în cod și verificați noua schemă în GraphiQL

File schemaFile = loadSchema("magicSchool.graphql");TypeDefinitionRegistry typeRegistry=schemaParser.parse(schemaFile);

RuntimeWiring pentru schemă și extragere se modifică semnificativ pentru a include celelalte tipuri. Fiecare tip are DataFetcher independent.

Aici avem @Autowired toți căutătorii să ne obțină datele. Fiecare tip GraphQL este susținut de un rezolvator de tipuri (recuperator de date). Acești rezolutori sunt independenți unul de celălalt și pot avea surse diferite. Fiecare DataFetcher de aici are un DatafetchingEnvironment, care este o interfață în execuția interogării GraphQL. Acesta conține interogare-argumente, context, executionId, parametrii specifici câmpului, si asa mai departe.

Aruncați o privire la StudentFetcher și rezultatul interogării noastre (ignorați extensiile):

public DataFetcher getData() {    return environment -> {        Map<String, Object> student = new HashMap<>();        if ("1".equalsIgnoreCase(environment.getArgument("id"))) {            student.put("name", "Harry Potter");        }        return student;    };}
1611467468 889 Cum sa va puneti in functiune serverul Java GraphQL in
Ieșire GraphiQL

Vă amintește de SQL, nu-i așa? Vezi și cum Sub-preluare și Exagerare să fie eliminați, iar controlul datelor este în mâinile clientului. Acum putem obține informațiile lui Harry și Ron în mod ordonat și într-un singur apel către server!

Strategia și instrumentarea de execuție GraphQL

Fiecare execuție de interogare este asincronă în graphql-java. Când suni build.execute (executionInput), returnează o CompletableFuture obiect care se finalizează atunci când interogarea își finalizează fluxul de execuție.

De asemenea, deoarece câmpurile sunt rezolvate separat, în exemplul de mai sus, Baghetă și Casă informațiile sunt preluate și executate în paralel. Setarea implicită ExecutionStrategy folosește grupul de îmbinare a furcii Java, dar puteți adăuga grupul de fire personalizat utilizând clasa Executor.

ExecutorService executorService = new ThreadPoolExecutor(            128, /* core pool size 128 threads */            256, /* max pool size 256 threads */            10, TimeUnit.SECONDS,            new LinkedBlockingQueue<Runnable>(),            new ThreadPoolExecutor.CallerRunsPolicy());    return GraphQL.newGraphQL()            .instrumentation(new TracingInstrumentation ())             .queryExecutionStrategy(new ExecutorServiceExecutionStrategy(executorService))            .build();}

graphql-java vă permite să instrumentați executarea interogării în fiecare punct: înainte de Executare, înainte de Pararsing, și înainte de Preluare. Puteți extinde Instrumentaţie clasa și furnizați propria acțiune la fiecare pas – de exemplu, înregistrarea interogărilor și returnarea timpului fiecărui pas.

Ieșirea de instrumentare oferă o hartă a extensiilor în Format Apollo Tracing în mod implicit. Acest lucru poate fi folosit ulterior de un anumit client pentru a vizualiza datele de execuție (de exemplu, folosind elastic-search și Grafana). Acum știi ce înseamnă extensiile din imaginea de mai sus!

Codul complet al exemplului de mai sus poate fi accesat de la aici.

Înfășurându-se

Există mult mai multe funcții în graphql-java, cum ar fi Dataloader (care rezolvă problema preluării N + 1), directivelor (care facilitează scrierea schemelor) și așa mai departe. GraphQL este o tehnologie emergentă care face viața clientului mai ușoară și poate schimba modul în care facem lucrurile pe Internet. De aceea, multe companii precum Facebook, Twitter, GitHub și Coursera l-au adoptat deja.

Mi-ar plăcea să aud comentariile dvs. despre GraphQL. Vă rugăm să ne împărtășiți opiniile. De asemenea, dacă vă place postarea pe blog, nu uitați să bateți din palme.