Inleiding tot Open Liberty

1. Overzicht

Met de populariteit van microservice-architectuur en cloud-native applicatie-ontwikkeling, is er een groeiende behoefte aan een snelle en lichtgewicht applicatieserver.

In deze inleidende tutorial verkennen we het Open Liberty-framework om een ​​RESTful-webservice te maken en te gebruiken. We zullen ook enkele van de essentiële functies bekijken die het biedt.

2. Open Liberty

Open Liberty is een open raamwerk voor het Java-ecosysteem waarmee microservices kunnen worden ontwikkeld met behulp van de functies van de Eclipse MicroProfile- en Jakarta EE-platforms.

Het is een flexibele, snelle en lichtgewicht Java-runtime die veelbelovend lijkt voor cloud-native microservices-ontwikkeling.

Het framework stelt ons in staat om alleen de functies te configureren die onze app nodig heeft, wat resulteert in een kleinere geheugenvoetafdruk tijdens het opstarten. Het is ook inzetbaar op elk cloudplatform met behulp van containers zoals Docker en Kubernetes.

Het ondersteunt snelle ontwikkeling door de code live te herladen voor snelle iteratie.

3. Bouwen en rennen

Eerst maken we een eenvoudig op Maven gebaseerd project met de naam open vrijheid en voeg vervolgens de laatste toe liberty-maven-plugin plug-in naar de pom.xml:

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

Of we kunnen het laatste toevoegen openliberty-runtime Maven-afhankelijkheid als alternatief voor de liberty-maven-plugin:

 io.openliberty openliberty-runtime 20.0.0.1 zip 

Evenzo kunnen we de nieuwste Gradle-afhankelijkheid toevoegen aan het build.gradle:

afhankelijkheden {libertyRuntime-groep: 'io.openliberty', naam: 'openliberty-runtime', versie: '20 .0.0.1 '}

Vervolgens voegen we het laatste toe jakarta.jakartaee-web-api en microprofiel Maven-afhankelijkheden:

 jakarta.platform jakarta.jakartaee-web-api 8.0.0 geleverd org.eclipse.microprofile microprofile 3.2 pom meegeleverd 

Laten we vervolgens de standaard HTTP-poorteigenschappen toevoegen aan het pom.xml:

 9080 9443 

Vervolgens maken we het server.xml bestand in het src / main / liberty / config directory:

  mpHealth-2.0 

Hier hebben we het mpHealth-2.0 functie om de status van de applicatie te controleren.

Dat is het met alle basisinstellingen. Laten we de opdracht Maven uitvoeren om de bestanden voor de eerste keer te compileren:

mvn schoon pakket

Laten we als laatste de server uitvoeren met behulp van een door Liberty geleverde Maven-opdracht:

mvn vrijheid: dev

Voila! Onze applicatie is gestart en zal toegankelijk zijn op localhost: 9080:

We hebben ook toegang tot de gezondheid van de app op localhost: 9080 / gezondheid:

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

De vrijheid: dev commando start de Open Liberty-server in ontwikkelingsmodus, die alle wijzigingen die in de code of configuratie zijn aangebracht, hot-herlaadt zonder de server opnieuw op te starten.

Evenzo is het vrijheid: rennen commando is beschikbaar om de server in productiemodus te starten.

We kunnen ook gebruikenvrijheid: start-server en vrijheid:stop-server om de server op de achtergrond te starten / stoppen.

4. Servlet

Om servlets in de app te gebruiken, voegen we de servlet-4.0 functie aan de server.xml:

 ... servlet-4.0 

Voeg het laatste toe servlet-4.0 Maven-afhankelijkheid als u de openliberty-runtime Maven-afhankelijkheid in het pom.xml:

 io.openliberty.features servlet-4.0 20.0.0.1 esa 

Als we echter de liberty-maven-plugin plugin, dit is niet nodig.

Vervolgens maken we het AppServlet klasse uitbreiding van de HttpServlet klasse:

@WebServlet (urlPatterns = "/ app") openbare klasse AppServlet breidt HttpServlet uit {privé statische laatste lange serialVersionUID = 1L; @Override beschermde ongeldige doGet (HttpServletRequest-verzoek, HttpServletResponse-antwoord) gooit ServletException, IOException {String htmlOutput = "

Hallo! Welkom bij Open Liberty

"; response.getWriter (). append (htmlOutput);}}

Hier hebben we het @WebServlet annotatie die de AppServlet beschikbaar op het opgegeven URL-patroon.

Laten we toegang krijgen tot de servlet op localhost: 9080 / app:

5. Maak een RESTful-webservice

Laten we eerst het jaxrs-2.1 functie aan de server.xml:

 ... jaxrs-2.1 

Dan, we maken het ApiApplication class, die eindpunten levert aan de RESTful-webservice:

@ApplicationPath ("/ api") openbare klasse ApiApplication breidt applicatie uit {}

Hier hebben we de @ApplicationPath annotatie voor het URL-pad.

Laten we vervolgens het Persoon klasse die het model dient:

public class Person {private String gebruikersnaam; privé String-e-mail; // getters en setters // constructeurs}

Vervolgens maken we het PersonResource class om de HTTP-toewijzingen te definiëren:

@RequestScoped @Path ("personen") openbare klasse PersonResource {@GET @Produces (MediaType.APPLICATION_JSON) openbare lijst getAllPersons () {return Arrays.asList (nieuwe persoon (1, "normanlewis", "[email protected]")) ; }}

Hier hebben we het getAllPersons methode voor de GET-toewijzing aan de / api / personen eindpunt. Dus we zijn klaar met een RESTful-webservice en de vrijheid: dev commando zal wijzigingen on-the-fly laden.

Laten we toegang krijgen tot het / api / personen RESTful webservice met een curl GET-verzoek:

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

Vervolgens krijgen we als reactie een JSON-array:

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

Evenzo kunnen we de POST-toewijzing toevoegen door de addPerson methode:

@POST @Consumes (MediaType.APPLICATION_JSON) openbare reactie addPerson (Persoon persoon) {String respMessage = "Persoon" + person.getUsername () + "succesvol ontvangen."; return Response.status (Response.Status.CREATED) .entity (respMessage) .build (); }

Nu kunnen we het eindpunt aanroepen met een curl POST-verzoek:

curl --request POST --url // localhost: 9080 / api / personen \ --header 'content-type: application / json' \ --data '{"gebruikersnaam": "normanlewis", "email": "[ e-mail beveiligd] "} '

Het antwoord ziet er als volgt uit:

Persoon normanlewis met succes ontvangen.

6. Volharding

6.1. Configuratie

Laten we persistentie-ondersteuning toevoegen aan onze RESTful-webservices.

Eerst voegen we de Derby Maven afhankelijkheid van de pom.xml:

 org.apache.derby derby 10.14.2.0 

Vervolgens voegen we een paar functies toe, zoals jpa-2.2, jsonp-1.1, en cdi-2.0 naar de server.xml:

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

Hier de jsonp-1.1 functie biedt de Java API voor JSON-verwerking en de cdi-2.0 functie behandelt de scopes en afhankelijkheidsinjectie.

Vervolgens maken we het persistence.xml in de src / main / resources / META-INF directory:

   jdbc / jpadatasource 

Hier hebben we de EclipseLink DDL-generatie gebruikt om ons databaseschema automatisch te maken. We kunnen ook andere alternatieven gebruiken, zoals Hibernate.

Laten we vervolgens het databron configuratie naar de server.xml:

Merk op jndiName heeft dezelfde verwijzing naar de jta-gegevensbron tag in het persistence.xml.

6.2. Entiteit en DAO

Vervolgens voegen we de @Entiteit annotatie en een identificatie voor onze Persoon klasse:

@Entity openbare klasse Persoon {@GeneratedValue (strategie = GenerationType.AUTO) @Id privé int id; private String gebruikersnaam; privé String-e-mail; // getters en setters}

Laten we vervolgens het Personensional klasse die zal communiceren met de database met behulp van de EntityManager voorbeeld:

@RequestScoped openbare klasse Personensional {@PersistenceContext (name = "jpa-unit") privé EntityManager em; publiek Persoon createPerson (Persoon persoon) {em.persist (persoon); terugkeer persoon; } public Person readPerson (int personId) {return em.find (Person.class, personId); }}

Merk op dat de @PersistenceContext definieert dezelfde verwijzing naar de persistentie-eenheid tag in het persistence.xml.

Nu zullen we de Personensional afhankelijkheid in de PersonResource klasse:

@RequestScoped @Path ("persoon") openbare klasse PersonResource {@Inject privé Personbao personensional; // ...}

Hier hebben we de @Injecteren annotatie geleverd door de CDI-functie.

Als laatste werken we het addPerson methode van de PersonResource klasse om de Persoon voorwerp:

@POST @Consumes (MediaType.APPLICATION_JSON) @Transactional openbare reactie addPerson (Persoon persoon) {personão.createPerson (persoon); String respMessage = "Persoon #" + person.getId () + "succesvol aangemaakt."; return Response.status (Response.Status.CREATED) .entity (respMessage) .build (); }

Hier de addPerson methode is geannoteerd met de @Transactional annotatie om transacties op door CDI beheerde bonen te controleren.

Laten we het eindpunt aanroepen met het reeds besproken curl POST-verzoek:

curl --request POST --url // localhost: 9080 / api / personen \ --header 'content-type: application / json' \ --data '{"gebruikersnaam": "normanlewis", "email": "[ e-mail beveiligd] "} '

Vervolgens ontvangen we een sms-antwoord:

Persoon # 1 is gemaakt.

Evenzo voegen we het getPerson methode met GET-toewijzing om een Persoon voorwerp:

@GET @Path ("{id}") @Produces (MediaType.APPLICATION_JSON) @Transactionele publieke persoon getPerson (@PathParam ("id") int id) {Persoon person = personão.readPerson (id); terugkeer persoon; }

Laten we het eindpunt aanroepen met een curl GET-verzoek:

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

Dan krijgen we de Persoon object als JSON-antwoord:

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

7. Consumeer RUSTIG Webservice met behulp van JSON-B

Ten eerste maken we het mogelijk om modellen direct te serialiseren en deserialiseren door de extensie jsonb-1.0 functie aan de server.xml:

 ... jsonb-1.0 

Laten we vervolgens het RestConsumer klasse met de consumumeWithJsonb methode:

openbare klasse RestConsumer {openbare statische String consumeWithJsonb (String targetUrl) {Client client = ClientBuilder.newClient (); Antwoordantwoord = client.target (targetUrl) .request (). Get (); String resultaat = response.readEntity (String.class); response.close (); client.close (); resultaat teruggeven; }}

Hier hebben we de ClientBuilder class om de RESTful-webservice-eindpunten aan te vragen.

Laten we als laatste een eenheidstest schrijven om het / api / persoon RESTful webservice en controleer het antwoord:

@Test openbare leegte whenConsumeWithJsonb_thenGetPerson () {String url = "// localhost: 9080 / api / personen / 1"; String resultaat = RestConsumer.consumeWithJsonb (url); Persoon person = JsonbBuilder.create (). FromJson (resultaat, Persoon.klasse); assertEquals (1, person.getId ()); assertEquals ("normanlewis", person.getUsername ()); assertEquals ("[e-mail beschermd]", person.getEmail ()); }

Hier hebben we de JsonbBuilder klasse om het Draad reactie op de Persoon voorwerp.

We kunnen ook gebruiken MicroProfile Rest Client door de mpRestClient-1.3 functie om de RESTful-webservices te gebruiken. Het biedt de RestClientBuilder interface om de RESTful-webservice-eindpunten aan te vragen.

8. Conclusie

In dit artikel hebben we het Open Liberty-framework onderzocht - een snelle en lichtgewicht Java-runtime die alle functies van de Eclipse MicroProfile- en Jakarta EE-platforms biedt.

Om te beginnen hebben we een RESTful-webservice gemaakt met JAX-RS. Vervolgens hebben we persistentie ingeschakeld met behulp van functies zoals JPA en CDI.

Als laatste hebben we de RESTful-webservice gebruikt met JSON-B.

Zoals gewoonlijk zijn alle code-implementaties beschikbaar op GitHub.