Introduktion til åben frihed
1. Oversigt
Med populariteten af mikroservicearkitektur og cloud-native applikationsudvikling er der et stigende behov for en hurtig og let applikationsserver.
I denne indledende vejledning udforsker vi Open Liberty-rammen for at oprette og forbruge en RESTful webtjeneste. Vi undersøger også et par af de væsentlige funktioner, den giver.
2. Åbn frihed
Åben frihed er en åben ramme for Java-økosystemet, der gør det muligt at udvikle mikroservices ved hjælp af Eclipse MicroProfile- og Jakarta EE-platforme.
Det er en fleksibel, hurtig og let Java-runtime, der synes lovende for udvikling af mikrotjenester i skyen.
Rammen giver os mulighed for kun at konfigurere de funktioner, vores app har brug for, hvilket resulterer i et mindre hukommelsesfodaftryk under opstart. Det kan også implementeres på enhver skyplatform ved hjælp af containere som Docker og Kubernetes.
Det understøtter hurtig udvikling ved live genindlæsning af koden til hurtig iteration.
3. Byg og kør
Først opretter vi et enkelt Maven-baseret projekt med navnet åben frihed og tilføj derefter det seneste liberty-maven-plugin plugin til pom.xml:
io.openliberty.tools liberty-maven-plugin 3.3-M3 Eller vi kan tilføje det seneste openliberty-runtime Maven afhængighed som et alternativ til liberty-maven-plugin:
io.openliberty openliberty-runtime 20.0.0.1 zip På samme måde kan vi tilføje den seneste Gradle-afhængighed til build.gradle:
afhængigheder {libertyRuntime-gruppe: 'io.openliberty', navn: 'openliberty-runtime', version: '20 .0.0.1 '}Derefter tilføjer vi det seneste jakarta.jakartaee-web-api og mikroprofil Maven afhængigheder:
jakarta.platform jakarta.jakartaee-web-api 8.0.0 leveret org.eclipse.microprofile microprofile 3.2 pom forudsat Lad os derefter tilføje standard HTTP-portegenskaber til pom.xml:
9080 9443 Derefter opretter vi server.xml fil i src / main / liberty / config vejviser:
mpHealth-2.0 Her har vi tilføjet mpHealth-2.0 funktion til at kontrollere applikationens helbred.
Det er det med al den grundlæggende opsætning. Lad os køre kommandoen Maven for at kompilere filerne for første gang:
mvn ren pakkeSidst, lad os køre serveren ved hjælp af en Liberty-leveret Maven-kommando:
mvn frihed: devVoila! Vores ansøgning er startet og vil være tilgængelig kl lokal vært: 9080:
Vi kan også få adgang til appens sundhed på lokal vært: 9080 / sundhed:
{"checks": [], "status": "UP"}Det frihed: dev kommandoen starter Open Liberty-serveren i udviklingstilstand, som genindlæser eventuelle ændringer foretaget i koden eller konfigurationen uden at genstarte serveren.
Tilsvarende er frihed: løb kommando er tilgængelig for at starte serveren i produktionstilstand.
Vi kan også brugefrihed: start-server og frihed:stop-server for at starte / stoppe serveren i baggrunden.
4. Servlet
For at bruge servlets i appen tilføjer vi servlet-4.0 funktion til server.xml:
... servlet-4.0 Tilføj det seneste servlet-4.0 Maven afhængighed, hvis du bruger openliberty-runtime Maven afhængighed i pom.xml:
io.openliberty.features servlet-4.0 20.0.0.1 esa Men hvis vi bruger liberty-maven-plugin plugin, dette er ikke nødvendigt.
Derefter opretter vi AppServlet klasse, der udvider HttpServlet klasse:
@WebServlet (urlPatterns = "/ app") offentlig klasse AppServlet udvider HttpServlet {privat statisk endelig lang serialVersionUID = 1L; @ Override beskyttet ugyldigt doGet (HttpServletRequest anmodning, HttpServletResponse svar) kaster ServletException, IOException {String htmlOutput = "Hej! Velkommen til Open Liberty
"; respons.getWriter (). tilføj (htmlOutput);}}Her har vi tilføjet @WebServlet kommentar, der vil gøre AppServlet tilgængelig på det angivne URL-mønster.
Lad os få adgang til servlet kl localhost: 9080 / app:
5. Opret en RESTful Web-tjeneste
Lad os først tilføje jaxrs-2.1 funktion til server.xml:
... jaxrs-2.1 Derefter, vi opretter Api-applikation klasse, der giver slutpunkter til RESTful-webservicen:
@ApplicationPath ("/ api") offentlig klasse ApiApplication udvider applikationen {}Her har vi brugt @ApplicationPath kommentar til URL-stien.
Lad os derefter oprette Person klasse, der tjener modellen:
offentlig klasse person {privat streng brugernavn; privat streng e-mail; // getters og setter // constructors}Derefter opretter vi PersonRessource klasse for at definere HTTP-tilknytninger:
@RequestScoped @Path ("persons") offentlig klasse PersonResource {@GET @Produces (MediaType.APPLICATION_JSON) offentlig liste getAllPersons () {return Arrays.asList (ny person (1, "normanlewis", "[email protected]")) ; }}Her har vi tilføjet getAllPersons metode til GET-kortlægning til / api / personer slutpunkt. Så vi er klar med en RESTful webtjeneste og frihed: dev kommando vil indlæse ændringer on-the-fly.
Lad os få adgang til / api / personer RESTful webtjeneste ved hjælp af en krøllet GET-anmodning:
curl --request GET --url // localhost: 9080 / api / personsDerefter får vi et JSON-array som svar:
[{"id": 1, "brugernavn": "normanlewis", "email": "[email protected]"}]På samme måde kan vi tilføje POST-kortlægningen ved at oprette addPerson metode:
@POST @Consumes (MediaType.APPLICATION_JSON) public Response addPerson (Person person) {String respMessage = "Person" + person.getUsername () + "modtaget med succes."; returnere Response.status (Response.Status.CREATED) .entity (respMessage) .build (); }Nu kan vi påberåbe sig slutpunktet med en krøllet POST-anmodning:
curl --request POST --url // localhost: 9080 / api / persons \ --header 'content-type: application / json' \ --data '{"username": "normanlewis", "email": "[ e-mail-beskyttet] "} 'Svaret vil se ud:
Person normanlewis modtaget med succes.6. Udholdenhed
6.1. Konfiguration
Lad os tilføje persistensstøtte til vores RESTful webtjenester.
Først tilføjer vi derby Maven afhængighed af pom.xml:
org.apache.derby derby 10.14.2.0 Derefter tilføjer vi et par funktioner som jpa-2.2, jsonp-1.1og cdi-2.0 til server.xml:
... jpa-2.2 jsonp-1.1 cdi-2.0 Her, den jsonp-1.1 funktionen giver Java API til JSON Processing, og cdi-2.0 funktion håndterer omfanget og afhængighedsindsprøjtning.
Derefter opretter vi persistence.xml i src / main / resources / META-INF vejviser:
jdbc / jpadatasource Her har vi brugt EclipseLink DDL-generationen til automatisk at oprette vores databaseskema. Vi kan også bruge andre alternativer som dvale.
Lad os derefter tilføje datakilde konfiguration til server.xml:
Bemærk, at jndiName har samme henvisning til jta-datakilde tag i persistence.xml.
6.2. Enhed og DAO
Derefter tilføjer vi @Enhed kommentar og en identifikator til vores Person klasse:
@Entity public class Person {@GeneratedValue (strategi = GenerationType.AUTO) @Id privat int id; privat streng brugernavn; privat streng e-mail; // getters og setters}Lad os derefter oprette PersonDao klasse, der interagerer med databasen ved hjælp af EntityManager eksempel:
@RequestScoped offentlig klasse PersonDao {@PersistenceContext (name = "jpa-unit") privat EntityManager em; offentlig person createPerson (Person person) {em.persist (person); tilbagevendende person } offentlig person readPerson (int personId) {return em.find (Person.class, personId); }}Bemærk, at @PersistenceContext definerer den samme henvisning til vedholdenhed tag i persistence.xml.
Nu indsprøjter vi PersonDao afhængighed i PersonRessource klasse:
@RequestScoped @Path ("person") offentlig klasse PersonResource {@Inject private PersonDao personDao; // ...}Her har vi brugt @Indsprøjte kommentar leveret af CDI-funktionen.
Til sidst opdaterer vi addPerson metode til PersonRessource klasse til at fortsætte Person objekt:
@POST @Consumes (MediaType.APPLICATION_JSON) @ Transaktionel offentlig reaktion addPerson (Personperson) {personDao.createPerson (person); String respMessage = "Person #" + person.getId () + "oprettet med succes."; returnere Response.status (Response.Status.CREATED) .entity (respMessage) .build (); }Her, den addPerson metoden er kommenteret med @Transaktionel kommentar til kontrol af transaktioner på CDI-administrerede bønner.
Lad os påberåbe sig slutpunktet med den allerede diskuterede curl POST-anmodning:
curl --request POST --url // localhost: 9080 / api / persons \ --header 'content-type: application / json' \ --data '{"username": "normanlewis", "email": "[ e-mail-beskyttet] "} 'Derefter modtager vi et tekstsvar:
Person nr. 1 oprettet med succes.Lad os ligeledes tilføje getPerson metode med GET-kortlægning for at hente en Person objekt:
@GET @Path ("{id}") @Produces (MediaType.APPLICATION_JSON) @Transaktionel offentlig person getPerson (@PathParam ("id") int id) {Person person = personDao.readPerson (id); tilbagevendende person }Lad os påkalde slutpunktet ved hjælp af en krøllet GET-anmodning:
curl --request GET --url // localhost: 9080 / api / persons / 1Så får vi Person objekt som JSON-svar:
{"email": "[email protected]", "id": 1, "username": "normanlewis"}7. Forbrug Rolig Web Service Brug JSON-B
Først muliggør vi muligheden for at direkte serieisere og deserialisere modeller ved at tilføje jsonb-1.0 funktion til server.xml:
... jsonb-1.0 Lad os derefter oprette RestConsumer klasse med forbrugeMedJsonb metode:
offentlig klasse RestConsumer {offentlig statisk streng forbrugWithJsonb (String targetUrl) {Klientklient = ClientBuilder.newClient (); Svarrespons = client.target (targetUrl) .quest (). Get (); String result = response.readEntity (String.class); respons.close (); client.close (); returresultat }}Her har vi brugt ClientBuilder klasse for at anmode om de RESTfulde webtjenesteslutpunkter.
Lad os sidst skrive en enhedstest for at forbruge / api / person RESTful webtjeneste og bekræft svaret:
@Test offentligt ugyldigt nårConsumeWithJsonb_thenGetPerson () {String url = "// localhost: 9080 / api / persons / 1"; Strengresultat = RestConsumer.consumeWithJsonb (url); Person person = JsonbBuilder.create (). FromJson (resultat, Person.class); assertEquals (1, person.getId ()); assertEquals ("normanlewis", person.getUsername ()); assertEquals ("[email protected]", person.getEmail ()); }Her har vi brugt JsonbBuilder klasse til at analysere Snor svar i Person objekt.
Vi kan også bruge MicroProfile Rest Client ved at tilføje mpRestClient-1.3 funktion til at forbruge RESTful webtjenester. Det giver den RestClientBuilder interface til at anmode om RESTful-webservicens slutpunkter.
8. Konklusion
I denne artikel udforskede vi Open Liberty-rammen - en hurtig og let Java-runtime, der giver alle funktioner i Eclipse MicroProfile og Jakarta EE-platforme.
Til at begynde med oprettede vi en RESTful webtjeneste ved hjælp af JAX-RS. Derefter aktiverede vi vedholdenhed ved hjælp af funktioner som JPA og CDI.
Til sidst brugte vi den RESTful webtjeneste ved hjælp af JSON-B.
Som normalt er alle kodeimplementeringer tilgængelige på GitHub.
