streamalism.org

1. Prehľad

S popularitou architektúry mikroslužieb a vývoja natívnych aplikácií v cloude rastie potreba rýchleho a ľahkého aplikačného servera.

V tomto úvodnom tutoriáli preskúmame rámec Open Liberty, aby sme vytvorili a využili webovú službu RESTful. Preskúmame tiež niekoľko základných funkcií, ktoré poskytuje.

2. Otvorte slobodu

Otvorená sloboda je otvorený rámec pre ekosystém Java, ktorý umožňuje vývoj mikroslužieb pomocou funkcií platforiem Eclipse MicroProfile a Jakarta EE.

Jedná sa o flexibilný, rýchly a ľahký runtime Java, ktorý sa javí ako sľubný pre vývoj natívnych cloudových mikroslužieb.

Rámec nám umožňuje konfigurovať iba funkcie, ktoré naša aplikácia potrebuje, čo má za následok menšiu pamäťovú stopu počas spustenia. Je tiež nasaditeľný na akejkoľvek cloudovej platforme pomocou kontajnerov ako Docker a Kubernetes.

Podporuje rýchly vývoj živým opätovným načítaním kódu pre rýchlu iteráciu.

3. Zostavte a spustite

Najskôr vytvoríme jednoduchý projekt založený na Maven otvorená sloboda a potom pridajte najnovšie liberty-maven-plugin doplnok k pom.xml:

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

Alebo môžeme pridať najnovšie openliberty-runtime Maven závislosť ako alternatíva k liberty-maven-plugin:

 io.openliberty openliberty-runtime 20.0.0.1 zip 

Podobne môžeme pridať najnovšiu závislosť Gradle do build.gradle:

závislosti {libertyRuntime group: 'io.openliberty', name: 'openliberty-runtime', verzia: '20 .0.0.1 '}

Potom pridáme najnovšie jakarta.jakartaee-web-api a mikroprofil Závislosti Maven:

 jakarta.platform jakarta.jakartaee-web-api 8.0.0 poskytované org.eclipse.microprofile mikroprofil 3,2 poskytované 

Potom pridajme predvolené vlastnosti portu HTTP do pom.xml:

 9080 9443 

Ďalej vytvoríme server.xml súbor v src / main / liberty / config adresár:

  mpHealth-2.0 

Tu sme pridali mpHealth-2.0 funkcia na kontrolu stavu aplikácie.

To je všetko so základným nastavením. Spustíme príkaz Maven, aby sme súbory po prvýkrát kompilovali:

mvn čistý balíček

Nakoniec spustíme server pomocou príkazu Maven od Liberty:

mvn sloboda: dev

Voila! Naša aplikácia je spustená a bude k dispozícii na adrese localhost: 9080:

Tiež môžeme získať prístup k stavu aplikácie na adrese localhost: 9080 / zdravie:

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

The sloboda: dev príkaz spustí server Open Liberty vo vývojovom režime, ktorá za horúca načíta všetky zmeny vykonané v kóde alebo konfigurácii bez reštartovania servera.

Podobne sloboda: behať príkaz je k dispozícii na spustenie servera v produkčnom režime.

Tiež môžeme použiťsloboda: start-server a sloboda:stop-server na spustenie / zastavenie servera na pozadí.

4. Servlet

Ak chcete v aplikácii používať servlety, pridáme servlet-4.0 funkcia do server.xml:

 ... servlet-4.0 

Pridajte najnovšie servlet-4.0 Maven závislosť, ak používate openliberty-runtime Maven závislosť v pom.xml:

 io.openliberty.features servlet-4.0 20.0.0.1 esa 

Ak však používame liberty-maven-plugin plugin, to nie je potrebné.

Potom vytvoríme AppServlet trieda rozširujúca HttpServlet trieda:

@WebServlet (urlPatterns = "/ app") verejná trieda AppServlet rozširuje HttpServlet {private static final long serialVersionUID = 1L; @Override protected void doGet (požiadavka HttpServletRequest, odpoveď HttpServletResponse) vyvolá ServletException, IOException {String htmlOutput = "
Ahoj! Vitajte v Open Liberty
"; response.getWriter (). append (htmlOutput);}}

Tu sme pridali @WebServlet anotácia, ktorá vytvorí AppServlet k dispozícii v zadanom vzore adresy URL.

Poďme pristupovať k servletu na adrese localhost: 9080 / aplikácia:

5. Vytvorte RESTful webovú službu

Najskôr pridajme jaxrs-2.1 funkcia do server.xml:

 ... jaxrs-2.1 

Potom, vytvoríme ApiApplication trieda, ktorá poskytuje koncové body pre webovú službu RESTful:

@ApplicationPath ("/ api") verejná trieda ApiApplication rozširuje aplikáciu {}

Tu sme použili @ApplicationPath anotácia pre cestu URL.

Potom vytvorme Osoba trieda, ktorá slúži modelu:

public class Person {private String username; súkromný reťazcový e-mail; // getre a setre // konštruktory}

Ďalej vytvoríme PersonResource triedy na definovanie mapovaní HTTP:

@RequestScoped @Path ("osoby") verejná trieda PersonResource {@GET @Produces (MediaType.APPLICATION_JSON) verejný zoznam getAllPersons () {návrat Arrays.asList (nová osoba (1, "normanlewis", "[chránený e-mailom]"))) ; }}

Tu sme pridali getAllPersons metóda pre mapovanie GET na / api / osoby koncový bod. Takže sme pripravení na webovú službu RESTful a sloboda: dev príkaz načíta zmeny priebežne.

Poďme pristupovať k / api / osoby RESTful webová služba využívajúca curl GET požiadavku:

curl --request ZÍSKAŤ --url // localhost: 9080 / api / osoby

Potom dostaneme ako odpoveď pole JSON:

[{"id": 1, "username": "normanlewis", "email": "[chránený e-mailom]"}]

Podobne môžeme pridať mapovanie POST vytvorením addPerson metóda:

@POST @Consumes (MediaType.APPLICATION_JSON) verejná odpoveď addPerson (Osoba osoba) {String respMessage = "Osoba" + person.getUsername () + "úspešne prijatá."; vrátiť Response.status (Response.Status.CREATED) .entity (respMessage) .build (); }

Teraz môžeme koncový bod vyvolať požiadavkou na zvlnenie POST:

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

Odpoveď bude vyzerať takto:

Osoba normanlewis bola úspešne prijatá.

6. Perzistencia

6.1. Konfigurácia

Pridajme k našim RESTful webovým službám podporu vytrvalosti.

Najskôr pridáme derby Maven závislosť na pom.xml:

 org.apache.derby derby 10.14.2.0 

Potom pridáme niekoľko funkcií ako jpa-2.2, jsonp-1.1a cdi-2.0 do server.xml:

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

Tu je jsonp-1.1 funkcia poskytuje rozhranie Java API pre spracovanie JSON a cdi-2.0 funkcia spracováva rozsahy a vkladanie závislostí.

Ďalej vytvoríme persistence.xml v src / main / resources / META-INF adresár:

   jdbc / jpadatasource 

Tu sme použili generáciu EclipseLink DDL na automatické vytvorenie našej databázovej schémy. Môžeme tiež použiť iné alternatívy, ako je napríklad režim dlhodobého spánku.

Potom pridajme dátový zdroj konfigurácia do server.xml:

Všimnite si jndiName má rovnaký odkaz na jta-data-source značka v persistence.xml.

6.2. Subjekt a DAO

Potom pridáme @Entity anotáciu a identifikátor k nášmu Osoba trieda:

@Entity verejná trieda Osoba {@GeneratedValue (strategy = GenerationType.AUTO) @Id private int id; súkromné ​​reťazcové používateľské meno; súkromný reťazcový e-mail; // zakladatelia a zakladatelia}

Ďalej vytvoríme PersonDao triedy, ktorá bude interagovať s databázou pomocou EntityManager inštancia:

@RequestScoped verejná trieda PersonDao {@PersistenceContext (name = "jpa-unit") súkromný EntityManager em; public Person createPerson (Person person) {em.persist (person); návratová osoba; } public Person readPerson (int personId) {return em.find (Person.class, personId); }}

Všimnite si, že @PersistenceContext definuje rovnaký odkaz na jednotka perzistencie značka v persistence.xml.

Teraz si vpichneme injekciu PersonDao závislosť v PersonResource trieda:

@RequestScoped @Path („osoba“) verejná trieda PersonResource {@Inject private PersonDao personDao; // ...}

Tu sme použili @Inject anotácia poskytnutá funkciou CDI.

Nakoniec aktualizujeme addPerson metóda PersonResource triedy pretrvávať Osoba objekt:

@POST @Consumes (MediaType.APPLICATION_JSON) @Transactional public Response addPerson (Osoba osoba) {personDao.createPerson (osoba); Reťazec respMessage = "Osoba #" + person.getId () + "bola úspešne vytvorená."; vrátiť Response.status (Response.Status.CREATED) .entity (respMessage) .build (); }

Tu je addPerson metóda je anotovaná s @ Transakčné anotácia na kontrolu transakcií na fazuli spravovanej CDI.

Vyvolame koncový bod s už diskutovanou požiadavkou na zvlnenie POST:

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

Potom dostaneme textovú odpoveď:

Osoba č. 1 bola úspešne vytvorená.

Podobne pridajme getPerson metóda s mapovaním GET na získanie a Osoba objekt:

@GET @Path ("{id}") @Produces (MediaType.APPLICATION_JSON) @Transactional public Osoba getPerson (@PathParam ("id") int id) {Osoba osoba = personDao.readPerson (id); návratová osoba; }

Vyvolame koncový bod pomocou žiadosti GET o zvlnenie:

curl --request ZÍSKAŤ --url // localhost: 9080 / api / osôb / 1

Potom dostaneme Osoba objekt ako odpoveď JSON:

{"email": "[chránený e-mailom]", "id": 1, "používateľské meno": "normanlewis"}

7. Spotrebujte RESTful Používanie webových služieb JSON-B

Najskôr povolíme možnosť priamej serializácie a deserializácie modelov pridaním jsonb-1.0 funkcia do server.xml:

 ... jsonb-1.0 

Potom vytvorme RestConsumer trieda s konzumovaťWithJsonb metóda:

public class RestConsumer {public static String consumeWithJsonb (String targetUrl) {Client client = ClientBuilder.newClient (); Odozva odpoveď = client.target (targetUrl) .request (). Get (); Výsledok reťazca = response.readEntity (String.class); response.close (); client.close (); návratový výsledok; }}

Tu sme použili ClientBuilder triedy na vyžiadanie koncových bodov webovej služby RESTful.

Na záver napíšeme jednotkový test na spotrebovanie / api / osoba RESTful webová služba a overte odpoveď:

@Test public void whenConsumeWithJsonb_thenGetPerson () {String url = "// localhost: 9080 / api / persons / 1"; Výsledok reťazca = RestConsumer.consumeWithJsonb (url); Osoba osoba = JsonbBuilder.create (). FromJson (výsledok, Person.class); assertEquals (1, person.getId ()); assertEquals ("normanlewis", person.getUsername ()); assertEquals ("[chránený e-mailom]", person.getEmail ()); }

Tu sme použili JsonbBuilder triedy analyzovať String odpoveď do Osoba objekt.

Tiež môžeme použiť MicroProfile Rest Client pridaním mpRestClient-1.3 funkcia využívajúca webové služby RESTful. Poskytuje RestClientBuilder rozhranie na vyžiadanie koncových bodov webovej služby RESTful.

8. Záver

V tomto článku sme preskúmali rámec Open Liberty - rýchly a ľahký runtime Java, ktorý poskytuje všetky funkcie platforiem Eclipse MicroProfile a Jakarta EE.

Najprv sme vytvorili webovú službu RESTful pomocou JAX-RS. Potom sme povolili vytrvalosť pomocou funkcií ako JPA a CDI.

Nakoniec sme spotrebovali webovú službu RESTful pomocou JSON-B.

Ako obvykle sú všetky implementácie kódu dostupné na GitHub.