streamalism.org

1. Oversikt

Med populariteten til mikrotjenestearkitektur og cloud-native applikasjonsutvikling, er det et økende behov for en rask og lett applikasjonsserver.

I denne innledende opplæringen vil vi utforske Open Liberty-rammeverket for å opprette og konsumere en RESTful webtjeneste. Vi vil også undersøke noen av de viktigste funksjonene den gir.

2. Åpne frihet

Åpen frihet er et åpent rammeverk for Java-økosystemet som gjør det mulig å utvikle mikrotjenester ved hjelp av funksjonene til Eclipse MicroProfile og Jakarta EE-plattformene.

Det er en fleksibel, rask og lett Java-kjøretid som virker lovende for utvikling av mikrotjenester i skyen.

Rammeverket lar oss konfigurere bare funksjonene appen vår trenger, noe som resulterer i et mindre minnefotavtrykk under oppstart. Dessuten kan den distribueres på hvilken som helst skyplattform ved bruk av containere som Docker og Kubernetes.

Den støtter rask utvikling ved direkte omlasting av koden for rask iterasjon.

3. Bygg og løp

Først oppretter vi et enkelt Maven-basert prosjekt med navnet åpen frihet og legg deretter til det siste liberty-maven-plugin plugin til pom.xml:

 io.openliberty.tools liberty-maven-plugin 3.3-M3 

Eller vi kan legge til det siste openliberty-runtime Maven avhengighet som et alternativ til liberty-maven-plugin:

 io.openliberty openliberty-runtime 20.0.0.1 zip 

På samme måte kan vi legge til den siste Gradle-avhengigheten til build.gradle:

avhengigheter {libertyRuntime-gruppe: 'io.openliberty', navn: 'openliberty-runtime', versjon: '20 .0.0.1 '}

Deretter legger vi til det siste jakarta.jakartaee-web-api og mikroprofil Maven avhengigheter:

 jakarta.platform jakarta.jakartaee-web-api 8.0.0 forutsatt org.eclipse.microprofile mikroprofil 3.2 pom gitt 

La oss deretter legge til standard HTTP-portegenskaper til pom.xml:

 9080 9443 

Deretter oppretter vi server.xml filen i src / main / liberty / config katalog:

  mpHealth-2.0 

Her har vi lagt til mpHealth-2.0 funksjon for å kontrollere helsen til applikasjonen.

Det er det med alt grunnleggende oppsett. La oss kjøre Maven-kommandoen for å kompilere filene for første gang:

mvn ren pakke

Til slutt, la oss kjøre serveren ved hjelp av en Liberty-gitt Maven-kommando:

mvn frihet: dev

Voila! Søknaden vår startes og vil være tilgjengelig kl lokal vert: 9080:

Vi kan også få tilgang til helsen til appen på lokal vert: 9080 / helse:

{"checks": [], "status": "UP"}

De frihet: dev kommandoen starter Open Liberty-serveren i utviklingsmodus, som laster om alle endringer som er gjort i koden eller konfigurasjonen, uten å starte serveren på nytt.

Tilsvarende frihet: løpe kommandoen er tilgjengelig for å starte serveren i produksjonsmodus.

Vi kan også brukefrihet: start-server og frihet:stopp-server for å starte / stoppe serveren i bakgrunnen.

4. Servlet

For å bruke servlets i appen, legger vi til servlet-4.0 funksjon til server.xml:

 ... servlet-4.0 

Legg til det siste servlet-4.0 Maven avhengighet hvis du bruker openliberty-runtime Maven avhengighet i pom.xml:

 io.openliberty.features servlet-4.0 20.0.0.1 esa 

Imidlertid, hvis vi bruker liberty-maven-plugin plugin, dette er ikke nødvendig.

Deretter lager vi AppServlet klasse utvide HttpServlet klasse:

@WebServlet (urlPatterns = "/ app") offentlig klasse AppServlet utvider HttpServlet {privat statisk endelig lang serialVersionUID = 1L; @ Override beskyttet ugyldig doGet (HttpServletRequest forespørsel, HttpServletResponse svar) kaster ServletException, IOException {String htmlOutput = "
Hallo! Velkommen til Open Liberty
"; respons.getWriter (). legg til (htmlOutput);}}

Her har vi lagt til @WebServlet kommentar som vil gjøre AppServlet tilgjengelig på det angitte URL-mønsteret.

La oss få tilgang til servletten kl localhost: 9080 / app:

5. Opprett en RESTful Web Service

La oss først legge til jaxrs-2.1 funksjon til server.xml:

 ... jaxrs-2.1 

Deretter, vi lager ApiApplication klasse, som gir sluttpunkter til RESTful-nettjenesten:

@ApplicationPath ("/ api") offentlig klasse ApiApplication utvider applikasjonen {}

Her har vi brukt @ApplicationPath kommentar for URL-banen.

La oss deretter lage Person klasse som tjener modellen:

offentlig klasse Person {private String brukernavn; privat streng e-post; // getters og setter // constructors}

Deretter oppretter vi PersonResource klasse for å definere HTTP-tilordningene:

@RequestScoped @Path ("persons") offentlig klasse PersonResource {@GET @Produces (MediaType.APPLICATION_JSON) offentlig liste getAllPersons () {return Arrays.asList (ny person (1, "normanlewis", "[e-postbeskyttet]")) ; }}

Her har vi lagt til getAllPersons metode for GET-kartlegging til / api / personer endepunkt. Så vi er klare med en RESTful webtjeneste, og frihet: dev kommandoen vil laste inn endringer på farten.

La oss få tilgang til / api / personer RESTful webtjeneste ved hjelp av en curl GET-forespørsel:

curl --request GET --url // localhost: 9080 / api / persons

Deretter får vi et JSON-utvalg som svar:

[{"id": 1, "brukernavn": "normanlewis", "email": "[email protected]"}]

På samme måte kan vi legge til POST-kartleggingen ved å opprette addPerson metode:

@POST @Consumes (MediaType.APPLICATION_JSON) public Response addPerson (Person person) {String respMessage = "Person" + person.getUsername () + "mottatt vellykket."; return Response.status (Response.Status.CREATED) .entity (respMessage) .build (); }

Nå kan vi påkalle sluttpunktet med en curl POST-forespørsel:

curl --request POST --url // localhost: 9080 / api / persons \ --header 'content-type: application / json' \ --data '{"username": "normanlewis", "email": "[ e-postbeskyttet] "} '

Svaret vil se ut som:

Person normanlewis mottatt med hell.

6. Utholdenhet

6.1. Konfigurasjon

La oss legge til utholdenhetsstøtte til våre RESTful webtjenester.

Først legger vi til derby Maven avhengighet til pom.xml:

 org.apache.derby derby 10.14.2.0 

Deretter legger vi til noen få funksjoner som jpa-2.2, jsonp-1.1, og cdi-2.0 til server.xml:

 ... jpa-2.2 jsonp-1.1 cdi-2.0 

Her, den jsonp-1.1 funksjonen gir Java API for JSON Processing, og cdi-2.0 funksjonen håndterer omfanget og avhengighetsinjeksjonen.

Deretter oppretter vi persistence.xml i src / main / resources / META-INF katalog:

   jdbc / jpadatasource 

Her har vi brukt EclipseLink DDL-generasjonen til å lage databaseskjemaet vårt automatisk. Vi kan også bruke andre alternativer som dvalemodus.

La oss deretter legge til datakilde konfigurasjon til server.xml:

Merk at jndiName har samme referanse til jta-datakilde tag i persistence.xml.

6.2. Enhet og DAO

Deretter legger vi til @Enhet kommentar og en identifikator for vår Person klasse:

@Entity offentlig klasse person {@GeneratedValue (strategi = GenerationType.AUTO) @Id privat int id; privat streng brukernavn; privat streng e-post; // getters og setters}

La oss deretter lage PersonDao klasse som vil samhandle med databasen ved hjelp av EntityManager forekomst:

@RequestScoped offentlig klasse PersonDao {@PersistenceContext (name = "jpa-unit") private EntityManager em; offentlig person createPerson (personperson) {em.persist (person); retur person; } offentlig person readPerson (int personId) {return em.find (Person.class, personId); }}

Merk at @PersistenceContext definerer den samme referansen til utholdenhet tag i persistence.xml.

Nå skal vi injisere PersonDao avhengighet i PersonResource klasse:

@RequestScoped @Path ("person") offentlig klasse PersonResource {@Inject private PersonDao personDao; // ...}

Her har vi brukt @Injiser kommentar gitt av CDI-funksjonen.

Sist vil vi oppdatere addPerson metoden for PersonResource klasse for å fortsette Person gjenstand:

@POST @Consumes (MediaType.APPLICATION_JSON) @ Transaksjonell offentlig respons addPerson (Personperson) {personDao.createPerson (person); String respMessage = "Person #" + person.getId () + "opprettet vellykket."; return Response.status (Response.Status.CREATED) .entity (respMessage) .build (); }

Her, den addPerson metoden er merket med @Transaksjonell kommentar for å kontrollere transaksjoner på CDI-administrerte bønner.

La oss påkalle sluttpunktet med den allerede omtalte curl POST-forespørselen:

curl --request POST --url // localhost: 9080 / api / persons \ --header 'content-type: application / json' \ --data '{"username": "normanlewis", "email": "[ e-postbeskyttet] "} '

Deretter mottar vi et tekstsvar:

Person nr. 1 ble opprettet.

På samme måte, la oss legge til getPerson metode med GET-kartlegging for å hente en Person gjenstand:

@GET @Path ("{id}") @Produces (MediaType.APPLICATION_JSON) @Transaksjonell offentlig person getPerson (@PathParam ("id") int id) {Person person = personDao.readPerson (id); retur person; }

La oss påkalle sluttpunktet ved hjelp av en krøll GET-forespørsel:

curl --request GET --url // localhost: 9080 / api / persons / 1

Så får vi Person objekt som JSON-svar:

{"email": "[email protected]", "id": 1, "brukernavn": "normanlewis"}

7. Forbruk Avslappende Web-tjeneste bruker JSON-B

Først vil vi muliggjøre muligheten til å direkte serieisere og deserialisere modeller ved å legge til jsonb-1.0 funksjon til server.xml:

 ... jsonb-1.0 

La oss deretter lage RestConsumer klasse med forbrukerWithJsonb metode:

offentlig klasse RestConsumer {offentlig statisk streng consumeWithJsonb (String targetUrl) {Client client = ClientBuilder.newClient (); Svarrespons = client.target (targetUrl) .request (). Get (); String result = response.readEntity (String.class); respons.lukk (); client.close (); returresultat; }}

Her har vi brukt ClientBuilder klasse for å be om RESTful endepunkter for nettjeneste.

Til slutt, la oss skrive en enhetstest for å konsumere / api / person RESTful webtjeneste og bekreft svaret:

@Test offentlig ugyldig nårConsumeWithJsonb_thenGetPerson () {String url = "// localhost: 9080 / api / persons / 1"; Strengresultat = RestConsumer.consumeWithJsonb (url); Personperson = JsonbBuilder.create (). FromJson (resultat, Person.class); assertEquals (1, person.getId ()); assertEquals ("normanlewis", person.getUsername ()); assertEquals ("[email protected]", person.getEmail ()); }

Her har vi brukt JsonbBuilder klasse for å analysere String respons inn i Person gjenstand.

Vi kan også bruke MicroProfile Rest Client ved å legge til mpRestClient-1.3 funksjon for å konsumere RESTful webtjenester. Det gir RestClientBuilder grensesnitt for å be om RESTful endepunkter for webtjenester.

8. Konklusjon

I denne artikkelen utforsket vi Open Liberty-rammeverket - en rask og lett Java-kjøretid som gir alle funksjonene til Eclipse MicroProfile og Jakarta EE-plattformene.

Til å begynne med opprettet vi en RESTful webtjeneste ved hjelp av JAX-RS. Deretter aktiverte vi utholdenhet ved hjelp av funksjoner som JPA og CDI.

Sist, vi konsumerte RESTful-nettjenesten ved hjelp av JSON-B.

Som vanlig er alle kodeimplementeringene tilgjengelige på GitHub.