Microservice Architecture - Kurzanleitung

Microservice ist eine service-basierte Anwendungsentwicklungsmethode. Bei dieser Methode werden große Anwendungen in kleinste unabhängige Serviceeinheiten unterteilt. Bei Microservice wird die serviceorientierte Architektur (SOA) implementiert, indem die gesamte Anwendung als Sammlung miteinander verbundener Services aufgeteilt wird, wobei jeder Service nur einen Geschäftsbedarf erfüllt.

Das Konzept von Going Micro

In einer serviceorientierten Architektur werden ganze Softwarepakete in kleine, miteinander verbundene Geschäftsbereiche unterteilt. Jede dieser kleinen Geschäftseinheiten kommuniziert unter Verwendung verschiedener Protokolle miteinander, um dem Kunden ein erfolgreiches Geschäft zu liefern. Die Frage ist nun, wie sich Microservice Architecture (MSA) von SOA unterscheidet. Mit einem Wort, SOA ist ein Entwurfsmuster und Microservice ist eine Implementierungsmethode zur Implementierung von SOA, oder wir können sagen, Microservice ist eine Art von SOA.

Im Folgenden finden Sie einige Regeln, die wir bei der Entwicklung einer Microservice-orientierten Anwendung beachten müssen.

Independent - Jeder Microservice sollte unabhängig voneinander bereitstellbar sein.
Coupling - Alle Mikrodienste sollten lose miteinander gekoppelt sein, damit Änderungen an einem den anderen nicht beeinflussen.
Business Goal - Jede Serviceeinheit der gesamten Anwendung sollte die kleinste sein und ein bestimmtes Geschäftsziel erreichen können.

Betrachten wir ein Beispiel für ein Online-Shopping-Portal, um den Microservice genauer zu verstehen. Lassen Sie uns nun das gesamte E-Commerce-Portal in kleine Geschäftsbereiche wie Benutzerverwaltung, Auftragsverwaltung, Check-in, Zahlungsverwaltung, Lieferverwaltung usw. aufteilen. Eine erfolgreiche Bestellung muss alle diese Module innerhalb einer bestimmten Zeit durchlaufen Rahmen. Es folgt das konsolidierte Bild verschiedener Geschäftsbereiche, die einem elektronischen Handelssystem zugeordnet sind.

Jedes dieser Geschäftsmodule sollte seine eigene Geschäftslogik und Stakeholder haben. Sie kommunizieren mit Software von Drittanbietern für bestimmte Anforderungen und auch miteinander. Beispielsweise kann die Auftragsverwaltung mit der Benutzerverwaltung kommunizieren, um Benutzerinformationen abzurufen.

Wenn Sie nun ein Online-Shopping-Portal mit all diesen zuvor erwähnten Geschäftsbereichen betreiben, benötigen Sie eine Anwendung auf Unternehmensebene, die aus verschiedenen Ebenen wie Front-End, Back-End, Datenbank usw. besteht. Wenn Ihre Anwendung nicht skaliert ist und vollständig in einer einzigen Kriegsdatei entwickelt, wird es als typische monolithische Anwendung bezeichnet. Laut IBM sollte eine typische monolithische Anwendung intern die folgende Modulstruktur besitzen, wobei nur ein Endpunkt oder eine Anwendung für die Verarbeitung aller Benutzeranforderungen verantwortlich ist.

In der obigen Abbildung sehen Sie verschiedene Module wie die Datenbank zum Speichern verschiedener Benutzer und Geschäftsdaten. Im Front-End haben wir verschiedene Geräte, auf denen wir normalerweise Benutzer- oder Geschäftsdaten zur Verwendung rendern. In der Mitte haben wir ein Paket, das eine bereitstellbare EAR- oder WAR-Datei sein kann, die Anforderungen vom Ende des Benutzers akzeptiert, sie mit Hilfe der Ressourcen verarbeitet und an die Benutzer zurückgibt. Alles wird gut, bis das Unternehmen Änderungen im obigen Beispiel wünscht.

Stellen Sie sich die folgenden Szenarien vor, in denen Sie Ihre Anwendung entsprechend den Geschäftsanforderungen ändern müssen.

Der Geschäftsbereich benötigt einige Änderungen im Modul „Suchen“. Anschließend müssen Sie den gesamten Suchvorgang ändern und Ihre Anwendung erneut bereitstellen. In diesem Fall stellen Sie Ihre anderen Einheiten ohne Änderungen erneut bereit.

Jetzt muss Ihr Geschäftsbereich erneut einige Änderungen im Modul "Auschecken" vornehmen, um die Option "Brieftasche" einzuschließen. Sie müssen jetzt Ihr "Check out" -Modul ändern und es erneut auf dem Server bereitstellen. Beachten Sie, dass Sie die verschiedenen Module Ihrer Softwarepakete erneut bereitstellen, obwohl wir keine Änderungen daran vorgenommen haben. Hier kommt das Konzept der serviceorientierten Architektur, das spezifischer für die Microservice-Architektur ist. Wir können unsere monolithische Anwendung so entwickeln, dass sich jedes einzelne Modul der Software als unabhängige Einheit verhält, die in der Lage ist, eine einzelne Geschäftsaufgabe unabhängig zu erledigen.

Betrachten Sie das folgende Beispiel.

In der obigen Architektur erstellen wir keine Ear-Datei mit kompaktem End-to-End-Service. Stattdessen teilen wir verschiedene Teile der Software auf, indem wir sie als Service verfügbar machen. Jeder Teil der Software kann leicht miteinander kommunizieren, indem die entsprechenden Dienste genutzt werden. So spielt Microservice in modernen Webanwendungen eine große Rolle.

Vergleichen wir unser Warenkorbbeispiel im Bereich Microservice. Wir können unseren Warenkorb in verschiedene Module wie "Suchen", "Filter", "Kasse", "Warenkorb", "Empfehlung" usw. aufteilen. Wenn wir ein Warenkorbportal erstellen möchten, müssen wir das erstellen Die oben genannten Module so, dass sie miteinander verbunden werden können, um Ihnen rund um die Uhr ein gutes Einkaufserlebnis zu bieten.

Vorteile Nachteile

Im Folgenden finden Sie einige Punkte zu den Vorteilen der Verwendung von Microservice anstelle einer monolithischen Anwendung.

Vorteile

Small in size- Microservices ist eine Implementierung des SOA-Entwurfsmusters. Es wird empfohlen, Ihren Service so weit wie möglich beizubehalten. Grundsätzlich sollte ein Dienst nicht mehr als eine Geschäftsaufgabe ausführen, daher ist er offensichtlich klein und leicht zu warten als jede andere monolithische Anwendung.
Focused- Wie bereits erwähnt, ist jeder Microservice so konzipiert, dass er nur eine Geschäftsaufgabe erfüllt. Bei der Gestaltung eines Mikrodienstes sollte sich der Architekt um den Schwerpunkt des Dienstes kümmern, nämlich dessen Leistung. Per Definition sollte ein Microservice ein Full-Stack-System sein und sich dazu verpflichten, nur eine Geschäftseigenschaft bereitzustellen.
Autonomous- Jeder Microservice sollte eine autonome Geschäftseinheit der gesamten Anwendung sein. Dadurch wird die Anwendung lockerer gekoppelt, was zur Reduzierung der Wartungskosten beiträgt.
Technology heterogeneity- Microservice unterstützt verschiedene Technologien für die Kommunikation in einem Geschäftsbereich, wodurch die Entwickler die richtige Technologie am richtigen Ort einsetzen können. Durch die Implementierung eines heterogenen Systems kann maximale Sicherheit, Geschwindigkeit und ein skalierbares System erzielt werden.
Resilience- Ausfallsicherheit ist eine Eigenschaft zum Isolieren einer Softwareeinheit. Microservice zeichnet sich durch ein hohes Maß an Ausfallsicherheit bei der Erstellung von Methoden aus. Wenn also eine Einheit ausfällt, wirkt sich dies nicht auf das gesamte Unternehmen aus. Ausfallsicherheit ist eine weitere Eigenschaft, die ein hoch skalierbares und weniger gekoppeltes System implementiert.
Ease of deployment- Da die gesamte Anwendung in kleine Einheiten unterteilt ist, sollte jede Komponente einen vollständigen Stapel aufweisen. Alle von ihnen können im Gegensatz zu anderen monolithischen Anwendungen der gleichen Art sehr einfach in jeder Umgebung mit weniger Zeitaufwand bereitgestellt werden.

Im Folgenden werden einige Punkte zu den Nachteilen der Microservice-Architektur aufgeführt.

Nachteile

Distributed system- Aufgrund der technischen Heterogenität werden verschiedene Technologien verwendet, um verschiedene Teile eines Mikrodienstes zu entwickeln. Zur Unterstützung dieser großen heterogenen verteilten Software ist eine große Anzahl qualifizierter Fachkräfte erforderlich. Daher ist die Verteilung und Heterogenität der größte Nachteil bei der Verwendung von Microservice.
Cost - Microservice ist kostspielig, da Sie für verschiedene Geschäftsaufgaben unterschiedlichen Serverplatz verwalten müssen.
Enterprise readiness- Die Microservice-Architektur kann als Konglomerat verschiedener Technologien betrachtet werden, da sich die Technologie von Tag zu Tag weiterentwickelt. Daher ist es ziemlich schwierig, ein Microservice-Anwendungsunternehmen für den Vergleich mit herkömmlichen Softwareentwicklungsmodellen vorzubereiten.

Microservice über SOA

In der folgenden Tabelle sind bestimmte Funktionen von SOA und Microservice aufgeführt, wobei die Bedeutung der Verwendung von Microservice gegenüber SOA hervorgehoben wird.

Komponente	SOA	Microservice
Entwurfsmuster	SOA ist ein Design-Paradigma für Computersoftware, bei dem Softwarekomponenten der Außenwelt zur Verwendung in Form von Diensten ausgesetzt sind.	Micro Service ist ein Teil von SOA. Es ist eine spezialisierte Implementierung von SOA.
Abhängigkeit	Geschäftsbereiche sind voneinander abhängig.	Alle Geschäftsbereiche sind unabhängig voneinander.
Größe	Die Software ist größer als die herkömmliche Software.	Die Software ist klein.
Technologie	Der Technologie-Stack ist kleiner als der Microservice.	Microservice ist heterogener Natur, da genaue Technologien zur Ausführung einer bestimmten Aufgabe verwendet werden. Microservices können als Konglomerat vieler Technologien betrachtet werden.
Autonom und fokussiert	SOA-Anwendungen können mehrere Geschäftsaufgaben ausführen.	Microservice-Anwendungen sind für die Ausführung einer einzelnen Geschäftsaufgabe konzipiert.
Natur	Monolithisch in der Natur.	Voller Stapel in der Natur.
Einsatz	Die Bereitstellung ist zeitaufwändig.	Die Bereitstellung ist sehr einfach. Daher ist es weniger zeitaufwändig.
Kosteneffektivität	Kostengünstiger.	Weniger kostengünstig.
Skalierbarkeit	Weniger im Vergleich zu Microservices.	Vollständig skaliert.
Beispiel	Betrachten wir eine Online-CAB-Buchungsanwendung. Wenn wir diese Anwendung mit SOA erstellen möchten, sind ihre Softwareeinheiten - GetPayments und DriverInformation And MappingDataAPI AuthenticateUsersAnd DriversAPI	Wenn dieselbe Anwendung unter Verwendung einer Microservice-Architektur erstellt wird, lauten ihre APIs: SubmitPaymentsService GetDriverInfoService GetMappingDataService AuthenticateUserService AuthenticateDriverService

Beim Skalieren wird eine Software in verschiedene Einheiten zerlegt. Die Skalierung definiert auch die Skalierbarkeit. Skalierbarkeit ist das Potenzial, erweiterte Funktionen der Anwendung zu implementieren. Es hilft, die Sicherheit, Haltbarkeit und Wartbarkeit der Anwendung zu verbessern. Wir haben drei Arten von Skalierungsverfahren, die in der Industrie angewendet werden. Im Folgenden werden die verschiedenen Skalierungsmethoden sowie die entsprechenden Beispiele aus der Praxis aufgeführt.

X-Achsen-Skalierung

Die X-Achsen-Skalierung wird auch als horizontale Skalierung bezeichnet. Bei diesem Verfahren wird die gesamte Anwendung in verschiedene horizontale Teile unterteilt. Normalerweise kann jede Webserveranwendung diese Art der Skalierung haben. Stellen Sie sich eine normale MVC-Architektur vor, die der horizontalen Skalierung folgt (siehe folgende Abbildung).

Als Beispiel können wir jede JSP-Servlet-Anwendung betrachten. In dieser Anwendung steuert der Controller jede Anforderung und generiert bei Bedarf eine Ansicht, indem er mit dem Modell kommuniziert. Normalerweise folgen monolithische Anwendungen dieser Skalierungsmethode. Die X-Achsen-Skalierung ist sehr einfach und weniger zeitaufwendig. Bei dieser Methode wird eine Software abhängig von ihrer unterschiedlichen Aufgabe, für die das Gerät verantwortlich ist, skaliert. Beispielsweise ist der Controller für die Steuerung der eingehenden und ausgehenden Anforderung verantwortlich, die Ansicht ist für die Darstellung der Geschäftsfunktionalität für die Benutzer im Browser verantwortlich, während das Modell für die Speicherung unserer Daten verantwortlich ist und als Datenbank fungiert.

Y-Achsen-Skalierung

Die Y-Achsen-Skalierung wird auch als vertikale Skalierung bezeichnet, die eine Skalierung auf Ressourcenebene umfasst. Jedes DBaaS- oder Hadoop-System kann als Y-Achsen-skaliert betrachtet werden. Bei dieser Art der Skalierung wird die Benutzeranforderung durch Implementieren einer Logik umgeleitet und eingeschränkt.

Betrachten wir Facebook als Beispiel. Facebook muss in jeder Sekunde 1,79 Millionen Nutzer bedienen. Daher liegt die Kontrolle des Datenverkehrs in der großen Verantwortung der Facebook-Netzwerktechniker. Um jede Gefahr zu vermeiden, folgen sie der Y-Achsen-Skalierung, bei der mehrere Server gleichzeitig mit derselben Anwendung ausgeführt werden. Um dieses enorme Verkehrsaufkommen zu kontrollieren, leitet Facebook den gesamten Verkehr von einer Region zu einem bestimmten Server um, wie im Bild dargestellt. Diese Übertragung von Verkehr basierend auf der Region wird in der Architektursprache als Lastausgleich bezeichnet.

Diese Methode zur Aufteilung von Ressourcen in kleine unabhängige Geschäftsbereiche wird als Y-Achsen-Skalierung bezeichnet.

Z-Achsen-Skalierung

Die Skalierung der X- und Y-Achse ist viel einfacher zu verstehen. Eine Anwendung kann jedoch auch auf Unternehmensebene skaliert werden, was als Z-Achsen-Skalierung bezeichnet wird. Im Folgenden finden Sie ein Beispiel für die Skalierung einer Kabinendienstanwendung in den verschiedenen Branchen von Geschäftsbereichen.

Vorteile der Skalierung

Cost - Durch eine ordnungsgemäße Skalierung einer Software werden die Wartungskosten gesenkt.
Performance - Aufgrund der losen Kopplung ist die Leistung einer richtig skalierten Software immer besser als die einer nicht skalierten Software.
Load distribution - Mit verschiedenen Technologien können wir unsere Serverlast problemlos aufrechterhalten.
Reuse - Die Skalierbarkeit einer Software erhöht auch die Benutzerfreundlichkeit der Software.

Microservice implementiert SOA intern. Im weiteren Sinne können wir es als Teilmenge einer SOA-Anwendung betrachten.

Regel & Workflow

Im Folgenden sind die Grundsätze aufgeführt, die bei der Entwicklung eines Mikroservices berücksichtigt werden müssen.

High Cohesion- Alle Geschäftsmodelle müssen so weit wie möglich in den kleinsten Geschäftsbereich unterteilt werden. Jeder Service sollte darauf ausgerichtet sein, nur eine Geschäftsaufgabe auszuführen.
Independent - Alle Dienste sollten vollständig und unabhängig voneinander sein.
Business Domain Centric - Die Software wird je nach Geschäftsbereich modularisiert und ist nicht tierbasiert.
Automation- Das Testen der Bereitstellung wird automatisiert. Versuchen Sie, eine minimale menschliche Interaktion einzuführen.
Observable - Jeder Dienst ist ein Full-Stack-Dienst und sollte unabhängig wie eine Unternehmensanwendung bereitstellbar und beobachtbar sein.

Team Management

"Two Pizza Rule" ist eine Art Regel, die die Anzahl der Teilnehmer in einem Microservice-Entwicklungsteam einschränkt. Nach dieser Regel sollte die Anzahl der Teammitglieder einer Anwendung so gering sein, dass sie von zwei Pizzas gefüttert werden können. Im Allgemeinen sollte die Anzahl nicht mehr als 8 betragen. Da der Microservice von Natur aus ein Full-Stack ist, ist das Team auch ein Full-Stack. Um die Produktivität zu steigern, müssen wir ein Team von maximal 8 Mitgliedern mit allen für diesen Service erforderlichen Fachkenntnissen aufbauen.

Aufgabenmanagement

Aufgabe ist eine wichtige Rolle im Lebenszyklus der Softwareentwicklung. Die Entwicklung einer großen Anwendung kann in mehrere kleine Aufgabeneinheiten unterteilt werden. Betrachten wir, wir müssen eine Anwendung wie Facebook entwickeln. Die Anmeldefunktion kann dann als Aufgabe des gesamten Erstellungsprozesses betrachtet werden. Der Fortschritt für jede dieser Aufgaben muss unter hochqualifizierten Fachleuten ordnungsgemäß überwacht werden. Agil ist die in den Branchen bekannte Prozessstruktur, um mit einem guten Aufgabenmanagement Schritt zu halten.

Bis jetzt haben wir gelernt, was Microservice ist und welche Grundbedürfnisse es über der modernen MVC-Architektur hat. In diesem Kapitel lernen wir die verschiedenen Elemente dieser Architektur kennen, die für einen Service gleichermaßen wichtig sind.

Kategorien von Dienstleistungen

Unter dem Namen Microservice gehen wir davon aus, dass es sich um einen Dienst handelt, der über HTTP-Protokolle genutzt werden kann. Wir müssen jedoch wissen, welche Art von Diensten mit dieser Architektur erstellt werden können. Im Folgenden finden Sie eine Liste der Dienste, die mithilfe der Microservice-Architektur implementiert werden können.

Platform as a Service [PaaS]- In dieser serviceorientierten Architektur wird die Plattform als Werkzeug angegeben, das an die Geschäftsanforderungen angepasst werden kann. PaaS spielt eine wichtige Rolle bei der Entwicklung mobiler Anwendungen. Das beste Beispiel für PaaS ist die Google App Engine, bei der Google verschiedene nützliche Plattformen zum Erstellen Ihrer Anwendung bereitstellt. PaaS wurde ursprünglich entwickelt, um Entwicklern eine integrierte Architektur oder Infrastruktur bereitzustellen. Es reduziert die Programmierkomplexität auf höherer Ebene in drastisch verkürzter Zeit. Im Folgenden finden Sie eine Momentaufnahme des von Google bereitgestellten PaaS.

Software as a Service [SaaS]- Software as a Service ist ein Softwarelizenzierungsunternehmen, bei dem die Software zentral auf Abonnementbasis gehostet und lizenziert wird. Auf SaaS kann hauptsächlich über den Browser zugegriffen werden. Es ist ein sehr verbreitetes Architekturmuster in vielen Geschäftsbereichen wie Personalmanagement (HRM), Enterprise Resource Planning (ERP), Kundenbeziehungsmanagement (CRM) usw. Der folgende Screenshot zeigt Beispiele für verschiedene von Oracle bereitgestellte SaaS.

Infrastructure as a Service [IaaS]- Die Infrastruktur spielt in der IT-Branche eine gute Rolle. Mithilfe von Cloud Computing stellen einige Unternehmen die virtuelle Infrastruktur als ihre Dienste bereit. IaaS ist sehr hilfreich, um Flexibilität, Kosteneffizienz, Sicherheit, Leistung, Produktivität usw. in die Softwareentwicklung zu bringen. Amazon EC2 und Microsoft Azure sind die größten Beispiele für IaaS. Das folgende Bild zeigt ein Beispiel für AWS, bei dem das Rechenzentrum als IaaS bereitgestellt wird.

Data as a Service [DaaS]- Die Informationstechnologie befasst sich mit Daten, und einige der führenden Branchenführer glauben, dass Daten die neue Nahrung der Gesellschaft sein werden. DaaS ist eine Art von Dienst, bei dem Daten für Forschungs- und Analysezwecke an Unternehmenskonglomerate weitergegeben werden. DaaS bietet Einfachheit, Flexibilität und Sicherheit in der Datenzugriffsschicht. Im Folgenden finden Sie ein Beispiel für die Oracle Data Cloud, auf die Sie zugreifen oder die Sie für Ihre eigenen Geschäftsanforderungen lizenzieren können.

Back End as a Service [BaaS]- BaaS wird auch als MBaaS bezeichnet, was Mobile Back-End als Service bedeutet. Bei dieser Art von Service wird das Backend der Anwendung den Geschäftsbereichen für ihre eigenen Geschäftsvorhaben zur Verfügung gestellt. Alle Push-Benachrichtigungen und Social-Networking-Dienste fallen unter diese Art von Diensten. Facebook und Twitter sind Beispiele für bekannte BaaS-Dienstleister.

Sicherheit

Beim Umgang mit Tonnen von Kundendaten spielt die Sicherheit eine wichtige Rolle. Sicherheitsprobleme sind mit allen auf dem Markt verfügbaren Diensten verbunden. Unabhängig von der von Ihnen verwendeten Cloud - privat, öffentlich, hybride usw. - sollte die Sicherheit auf allen Ebenen gewährleistet sein. Das gesamte Sicherheitsproblem kann grob in die folgenden Teile unterteilt werden:

Security issue faced by service providers - Diese Art von Sicherheitsproblemen treten bei Dienstanbietern wie Google, Amazon usw. auf. Um den Sicherheitsschutz zu gewährleisten, ist eine Hintergrundprüfung des Clients erforderlich, insbesondere für diejenigen, die direkten Zugriff auf den Kern der Cloud haben.
Security issue faced by consumers- Cloud ist kostenfreundlich und wird daher branchenübergreifend eingesetzt. Einige Organisationen speichern die Benutzerdaten in Rechenzentren von Drittanbietern und rufen die Daten bei Bedarf ab. Daher ist es obligatorisch, die Sicherheitsstufen so zu halten, dass private Daten eines Kunden für andere Benutzer nicht sichtbar sind.

Um die oben genannten Sicherheitsprobleme zu vermeiden, werden im Folgenden einige der von Organisationen verwendeten Abwehrmechanismen aufgeführt.

Deterrent Control - Kennen Sie Ihre potenzielle Bedrohung zur Reduzierung von Cyber-Angriffen.
Preventive Control - Pflegen Sie die Authentifizierungsrichtlinie auf hoher Ebene, um auf Ihre Cloud zuzugreifen.
Detective Control - Überwachen Sie Ihre Benutzer und erkennen Sie potenzielle Risiken.
Corrective Control - Arbeiten Sie eng mit verschiedenen Teams zusammen und beheben Sie die Probleme, die während der Detektivkontrollphase auftreten.

Software-Komposition bedeutet die Art und Weise, wie Sie Ihr Softwareprodukt erstellen. Grundsätzlich handelt es sich um ein übergeordnetes Software-Architekturdiagramm, in dem verschiedene Module Ihrer Software für bestimmte Geschäftsziele kommunizieren. In diesem Kapitel lernen wir verschiedene Software-Zusammensetzungsmuster kennen, die in Organisationen weit verbreitet sind. Im Microservice teilen wir jede Funktion in einen Prozess auf. Jeder dieser Dienste wird unabhängig und vollständig sein.

Die funktionale Zerlegung spielt eine wichtige Rolle beim Aufbau Ihrer Mikrodienste. Es bietet Ihrer Anwendung Flexibilität, Flexibilität und Skalierbarkeit.

Aggregatormuster

Das Aggregatormuster ist das einfachste Webmuster, das bei der Entwicklung eines Mikrodienstes implementiert werden kann. In diesem Kompositionsmuster fungiert ein einfaches Webmodul als Load Balancer, dh es ruft je nach Anforderung verschiedene Dienste auf. Das folgende Diagramm zeigt eine einfache Microservice-Web-App mit Aggregator-Design. Wie in der folgenden Abbildung zu sehen ist, ist der "Aggregator" dafür verantwortlich, verschiedene Dienste nacheinander aufzurufen. Wenn wir eine Geschäftslogik auf die Ergebnisse der Dienste A, B und C anwenden müssen, können wir die Geschäftslogik im Aggregator selbst implementieren.

Ein Aggregator kann erneut als ein anderer Dienst für die Außenwelt verfügbar gemacht werden, der bei Bedarf von anderen genutzt werden kann. Bei der Entwicklung des Webdienstes für Aggregatormuster müssen wir berücksichtigen, dass jeder unserer Dienste A, B und C seine eigenen Caching-Ebenen haben und von Natur aus vollständig gestapelt sein sollte.

Proxy-Muster

Das Proxy-Mikroservice-Muster ist eine Variation des Aggregatormodells. In diesem Modell verwenden wir das Proxy-Modul anstelle des Aggregationsmoduls. Der Proxy-Dienst kann verschiedene Dienste einzeln aufrufen.

Im Proxy-Muster können wir eine zusätzliche Sicherheitsstufe erstellen, indem wir eine Dump-Proxy-Schicht bereitstellen. Diese Schicht verhält sich ähnlich wie die Schnittstelle.

Verkettetes Muster

Wie der Name schon sagt, folgt diese Art von Zusammensetzungsmuster der Kettenstruktur. Hier werden wir nichts zwischen der Client- und der Service-Schicht verwenden. Stattdessen ermöglichen wir dem Kunden die direkte Kommunikation mit den Diensten, und alle Dienste werden so verkettet, dass die Ausgabe eines Dienstes die Eingabe des nächsten Dienstes ist. Das folgende Bild zeigt einen typischen Mikrodienst für verkettete Muster.

Ein Hauptnachteil dieser Architektur besteht darin, dass der Client blockiert wird, bis der gesamte Prozess abgeschlossen ist. Daher ist es sehr empfehlenswert, die Länge der Kette so kurz wie möglich zu halten.

Branch Microservice Pattern

Branch Microservice ist die erweiterte Version des Aggregator- und Kettenmusters. In diesem Entwurfsmuster kann der Client direkt mit dem Dienst kommunizieren. Ein Dienst kann auch mit mehr als einem Dienst gleichzeitig kommunizieren. Es folgt die schematische Darstellung von Branch Microservice.

Mit dem Branch Microservice-Muster kann der Entwickler Serviceaufrufe dynamisch konfigurieren. Alle Serviceanrufe werden gleichzeitig ausgeführt, dh Service A kann Service B und C gleichzeitig anrufen.

Muster für gemeinsam genutzte Ressourcen

Das Muster für gemeinsam genutzte Ressourcen ist eigentlich ein Konglomerat aller zuvor erwähnten Arten von Mustern. In diesem Muster kommuniziert der Client oder der Load Balancer bei Bedarf direkt mit jedem Dienst. Dies ist das effektivste Entwurfsmuster, das in den meisten Organisationen weit verbreitet ist. Im Folgenden finden Sie eine schematische Darstellung des Entwurfsmusters für gemeinsam genutzte Ressourcen.

In diesem Kapitel werden wir eine CRUD-basierte Anwendung mit SOA-Architektur entwickeln. Später in den folgenden Kapiteln werden wir diesen Service in Microservice aufteilen und den grundlegenden Unterschied zwischen SOA- und Microservice-Architektur kennenlernen.

Systemkonfiguration und -einrichtung

In diesem Abschnitt erstellen wir eine CRUD-Beispielanwendung, die bei jedem Aufruf unseres Dienstes ein JSON-Objekt als Antwort zurückgibt. Wir werden das Jersey-Framework verwenden, um dasselbe zu entwickeln. Im Folgenden finden Sie die Schritte zum Einrichten Ihrer lokalen Systemumgebung.

Entwicklung einer CRUD-Anwendung

Step 1- Wir werden NetBeans als Entwicklungs-IDE verwenden. Bitte laden Sie die neueste Version herunter und installieren Sie sie, die auf der offiziellen NetBeans-Website verfügbar isthttps://netbeans.org/downloads/.

Step 2- Öffnen Sie Ihre NetBeans-IDE. Gehen Sie zu "Datei -> Neues Projekt". Der folgende Screenshot wird angezeigt. Wählen Sie "Maven" als Kategorie und wählen Sie "Projekt von ArchType" als Projekt und klicken Sie auf "Weiter".

Dadurch werden alle erforderlichen JAR-Dateien heruntergeladen, um Ihr erstes Maven-Projekt und Ihren ersten RESTful-Webdienst zu erstellen.

Step 3- Wenn Sie im vorherigen Schritt auf die Schaltfläche Weiter klicken, wird der folgende Screenshot angezeigt. Hier müssen Sie den Maven-Archetyp angeben.

Suchen Sie im Suchfeld nach "Jersey-archType-Webapp (2.16)" und aktivieren Sie das Kontrollkästchen "Älter anzeigen".

Step 4- Sobald Sie dasselbe ausgewählt haben, werden Sie zum folgenden Bildschirm weitergeleitet. Wählen Sie das bevorzugte Glas aus der Liste aus und klicken Sie auf Weiter, um fortzufahren.

Step 5- In diesem Schritt müssen Sie den Namen Ihres Projekts und seine Gruppen-ID sowie die Paketdetails angeben. Nachdem Sie alle diese Informationen eingegeben haben, klicken Sie auf Fertig stellen, um fortzufahren.

Step 6- Sie sind mit der Einrichtung Ihres Arbeitsbereichs fertig. Das Projektverzeichnis sieht folgendermaßen aus.

Überprüfen Sie Ihren Ordner "Abhängigkeiten" und Sie werden feststellen, dass Maven automatisch alle erforderlichen JAR-Dateien für dieses Projekt heruntergeladen hat.

Step 7- Ihr Arbeitsbereich ist eingerichtet und Sie können mit der Codierung beginnen. Erstellen Sie vier Klassen und Pakete, wie im folgenden Screenshot beschrieben. Sie können feststellen, dass MyResource.java bereits von Maven erstellt wurde, da Maven intelligent genug ist, um zu erkennen, dass Sie Ihren eigenen Webdienst erstellen werden.

Step 8 - Sobald wir mit dem obigen Schritt fertig sind, erstellen wir unsere POJO-Klasse UserProfile.java wie folgt.

package com.tutorialspoint.userprofile.Model;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class UserProfile {
   private long ProId;
   private String FName;
   private String LName;
   private String Add;
   public UserProfile(){}
   
   public UserProfile(long Proid, String Fname, String Lname,String Add) {
      this.ProId = Proid;
      this.FName = Fname;
      this.LName = Lname;
      this.Add = Add;
   }
   public long getProId() {
      return ProId;
   }
   public void setProId(long ProId) {
      this.ProId = ProId;
   }
   public String getFName() {
      return FName;
   }
   public void setFName(String FName) {
      this.FName = FName;
   }
   public String getLName() {
      return LName;
   }
   public void setLName(String LName) {
      this.LName = LName;
   }
   public String getAdd() {
      return Add;
   }
   public void setAdd(String Add) {
      this.Add = Add;
   }
}

Step 9- Jetzt erstellen wir unsere Datenbankklasse. Da dies Teil des Lernmaterials ist, werden wir keine Datenbank als Datenbank verwenden. Wir werden einen eingebauten Java-Speicher als temporären Speicher verwenden. Wie Sie im folgenden Code sehen können, verwenden wir MAP als Datenbank. Bei allen von uns ausgeführten Webdienstvorgängen werden wir an diesem in der Klasse definierten MAP arbeiten.

package com.tutorialspoint.userprofile.DAO;

import com.tutorialspoint.userprofile.Model.UserProfile;

import java.util.HashMap;
import java.util.Map;

public class DatabaseClass {
   private static Map<Long,UserProfile> messages = new HashMap<Long,UserProfile>();
   public static Map<Long,UserProfile> getUsers() {
      return messages; 
      // Each time this method will return entire map as an instance of database
   }
}

Step 10- Lassen Sie uns jetzt unsere Serviceklasse aufbauen. Kopieren Sie den folgenden Codesatz und fügen Sie ihn in die Klasse "ProfileService.java" ein. Dies ist die Klasse, in der wir alle unsere Webdienstmethoden deklarieren, die für die Außenwelt verfügbar gemacht werden sollen. Wir müssen eine Referenz unserer DatabaseClass erstellen, damit in dieser Klasse auf unsere temporäre Datenbank zugegriffen werden kann.

package com.tutorialspoint.userprofile.service;

import com.tutorialspoint.userprofile.DAO.DatabaseClass;
import com.tutorialspoint.userprofile.Model.UserProfile;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class ProfileService {
   private Map<Long,UserProfile> Userprofiles = DatabaseClass.getUsers();
   
   // Creating some predefine profile and populating the same in the map
   public ProfileService() {
      UserProfile m1 = new UserProfile(1L,"Tutorials1","Point1","TutorialsPoint.com");
      UserProfile m2 = new UserProfile(2L,"Tutorials2","Point2","TutorialsPoint.com2");
      UserProfile m3 = new UserProfile(3L,"Tutorials3","Point3","TutorialsPoint.com3");
      UserProfile m4 = new UserProfile(4L,"Tutorials4","Point4","TutorialsPoint.com4");
      
      Userprofiles.put(1L, m1);
      Userprofiles.put(2L, m2);
      Userprofiles.put(1L, m3);
      Userprofiles.put(2L, m4);
   }
   
   //Method to fetch all profile
   public List<UserProfile> getAllProfile() {
      List<UserProfile> list = new ArrayList<UserProfile>(Userprofiles.values());
      return list;
   }  // Method to fetch only one profile depending on the ID provided
   
   public UserProfile getProfile(long id) {
      return Userprofiles.get(id);
   }  //Method to add profile
   
   public UserProfile addProfile(UserProfile UserProfile) {
      UserProfile.setProId(Userprofiles.size()+1);
      Userprofiles.put(UserProfile.getProId(), UserProfile);
      return UserProfile;
   }  //method to update Profile

   public UserProfile UpdateProfile(UserProfile UserProfile) {
      if(UserProfile.getProId()<=0) { 
         return null;
      } else { 
         Userprofiles.put(UserProfile.getProId(), UserProfile);
         return UserProfile;
      }
   } //method to delete profile
   
   public void RemoveProfile(long Id) {
      Userprofiles.remove(Id);
   }
}

Step 11 - In diesem Schritt erstellen wir unsere Ressourcenklasse, die mit der URL verknüpft wird, und der entsprechende Dienst wird aufgerufen.

package com.tutorialspoint.userprofile.Resource;

import com.tutorialspoint.userprofile.Model.UserProfile;
import com.tutorialspoint.userprofile.service.ProfileService;

import java.util.List;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("/Profile")
@Consumes(MediaType.APPLICATION_XML)
@Produces(MediaType.APPLICATION_XML)

public class ProfileResource {
   ProfileService messageService = new ProfileService();
   
   @GET
   public List<UserProfile> getProfile() {
      return messageService.getAllProfile();
   }

   @GET
   @Path("/{ProID}")
   public UserProfile getProfile(@PathParam("ProID")long Id) {
      return messageService.getProfile(Id);
   }

   @POST
   public UserProfile addProfile(UserProfile profile) {
      return messageService.addProfile(profile);
   }

   @PUT
   @Path("/{proID}")
   public UserProfile UpdateProfile(@PathParam("proID")long Id,UserProfile UserProfile) {
      UserProfile.setProId(Id);
      return messageService.UpdateProfile(UserProfile);
   }
   
   @DELETE
   @Path("/{ProID}")
   public void deleteProfile(@PathParam("ProID")long Id) {
      messageService.RemoveProfile(Id);
   }
}

Step 12- Erstellen Sie das Projekt sauber und führen Sie es aus. Wenn alles gut geht, sollten Sie beim Zugriff die folgende Ausgabe im Browser erhaltenhttp://localhost:8080/UserProfile/webapi/Profile” URL.

Sie können sehen, dass verschiedene Einträge mithilfe der XML-Darstellung ausgefüllt werden.

Verschiedene Methoden können mit Postman getestet werden, indem die richtige Methoden-URL angewendet wird.

@GET method - Der folgende Screenshot zeigt, wie wir das gewünschte Ergebnis für die Abrufanforderung erhalten können, die alle Benutzerdetails zurückgibt.

@POST- Die folgende Anfrage kann verwendet werden, um unsere Post-Methode zu testen. Beachten Sie, wie die proId automatisch generiert wurde.

@PUT- Diese Methode aktualisiert die Einträge. Der folgende Screenshot zeigt, wie Jersey die proId von der Anforderungs-URL nimmt und dieselbe Benutzerprofilantwort aktualisiert.

Auf die gleiche Weise können Sie nach anderen Methoden suchen, die in Ihren Webdiensten verfügbar sind.

Im vorherigen Abschnitt haben wir einen Dienst entwickelt, der die CRUD-Funktionalität verfügbar macht. Wenn wir jetzt versuchen, diesen Service in unserer Anwendung zu implementieren, müssen wir einen Client für diese Anwendung erstellen und an unsere Anwendung anhängen. In diesem Kapitel erfahren Sie, wie Sie diese Funktionalität mithilfe des Konzepts von Microservice erstellen. Das Folgende ist eine schematische Darstellung unserer Anwendung, die mit den obigen Schritten erstellt wurde.

Der Schauspieler sollte der Einstiegspunkt unseres Dienstes sein. In diesem Fall übernimmt „ProfileResource.java“ die Verantwortung eines Akteurs. Diese Klasse ruft verschiedene Methoden auf, um verschiedene Vorgänge wie Hinzufügen, Aktualisieren und Löschen auszuführen.

Zerlegung der CRUD-Anwendung

Nach dem Hauptprinzip des Mikroservices müssen wir für jedes Modul nur eine Geschäftsaufgabe haben, daher sollte nicht ein Akteur für alle vier CRUD-Funktionen verantwortlich sein. Betrachten Sie das folgende Beispiel, in dem wir einige neue Rollen eingeführt haben, damit Ihnen konzeptionell klar wird, dass Microservice eine architektonische Darstellung von SOA ist.

"Hauptbenutzer" ist der Benutzer, der mit dem "Application Controller" kommuniziert, um seine Bedürfnisse zu erfüllen. "Application Controller" ist derjenige, der je nach Anforderung des Endbenutzers nur unterschiedliche "Resource Manager" aufruft. "Resource Manager" erledigt die Aufgabe, die erledigt werden muss. Lassen Sie uns einen kurzen Blick auf die verschiedenen Rollen der verschiedenen Einheiten der Anwendung werfen.

End User/Main Users - Anforderung einiger Ressourcen an Application Controller.
Application - Empfängt die Anfrage und leitet sie an einen bestimmten Ressourcenmanager weiter.
Resource Manager - Erledigt die eigentliche Aufgabe des Aktualisierens, Löschens und Hinzufügens von Benutzern.

Sehen Sie, wie sich die Gesamtverantwortung einer Klasse auf verschiedene andere Klassen verteilt.

In diesem Kapitel erstellen wir eine Microservice-Anwendung, die verschiedene verfügbare Services verwendet. Wir alle wissen, dass Microservice keine kostengünstige Möglichkeit ist, eine Anwendung zu erstellen, da jeder einzelne Service, den wir erstellen, von Natur aus ein Full-Stack-Dienst ist. Das Erstellen eines Mikrodienstes in der lokalen Umgebung würde eine High-End-Systemkonfiguration erfordern, da Sie vier Instanzen eines Servers benötigen, um weiter ausgeführt zu werden, damit er zu einem bestimmten Zeitpunkt verwendet werden kann. Um unseren ersten Microservice zu erstellen, werden wir einige der verfügbaren SOA-Endpunkte verwenden und diese in unserer Anwendung verwenden.

Systemkonfiguration und -einrichtung

Bereiten Sie Ihr System entsprechend vor, bevor Sie mit der Erstellungsphase fortfahren. Sie würden einige öffentliche Webdienste benötigen. Sie können leicht dafür googeln. Wenn Sie den SOAP-Webdienst nutzen möchten, erhalten Sie eine WSDL-Datei, und von dort aus müssen Sie den spezifischen Webdienst nutzen. Für den REST-Service benötigen Sie nur einen Link, um denselben zu verwenden. In diesem Beispiel blockieren Sie drei verschiedene Webdienste "SOAP", "REST" und "benutzerdefiniert" in einer Anwendung.

Anwendungsarchitektur

Sie erstellen eine Java-Anwendung mithilfe des Microservice-Implementierungsplans. Sie erstellen einen benutzerdefinierten Dienst und die Ausgabe dieses Dienstes dient als Eingabe für andere Dienste.

Im Folgenden finden Sie die Schritte zum Entwickeln einer Microservice-Anwendung.

Step 1: Client creation for SOAP service- Es gibt viele kostenlose Web-APIs, um einen Webdienst zu erlernen. Verwenden Sie für dieses Tutorial den GeoIP-Dienst von „http://www.webservicex.net/.”Die WSDL-Datei finden Sie unter dem folgenden Link auf der Website „ webservicex.net. Um den Client aus dieser WSDL-Datei zu generieren, müssen Sie lediglich den folgenden Befehl in Ihrem Terminal ausführen.

wsimport http://www.webservicex.net/geoipservice.asmx?WSDL

Dieser Befehl generiert alle erforderlichen Client-Dateien in einem Ordner mit dem Namen "SEI", der nach der Service-Endpunkt-Schnittstelle benannt ist.

Step 2: Create your custom web service- Befolgen Sie den in diesem Tutorial bereits erwähnten Prozess und erstellen Sie eine Maven-basierte REST-API mit dem Namen „CustomRest“. Nach Abschluss finden Sie eine Klasse mit dem Namen "MyResource.java". Aktualisieren Sie diese Klasse mit dem folgenden Code.

package com.tutorialspoint.customrest;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("myresource")
public class MyResource {
   @GET
   @Produces(MediaType.TEXT_PLAIN)
   
   public String getIt() {
      return "IND|INDIA|27.7.65.215";
   }
}

Wenn alles abgeschlossen ist, führen Sie diese Anwendung auf dem Server aus. Sie sollten die folgende Ausgabe im Browser erhalten.

Dies ist der Webserver, der nach dem Aufruf ein Zeichenfolgenobjekt zurückgibt. Dies ist der Eingabedienst, der Eingaben bereitstellt, die von anderen Anwendungen zum Generieren von Datensätzen verwendet werden können.

Step 3: Configure another Rest API- Verwenden Sie in diesem Schritt einen anderen Webdienst, der unter services.groupkt.com verfügbar ist. Dies gibt beim Aufrufen ein JSON-Objekt zurück.

Step 4: Create JAVA application - Erstellen Sie eine normale Java-Anwendung, indem Sie "Neues Projekt" -> "JAVA-Projekt" auswählen und auf "Fertig stellen" klicken (siehe folgenden Screenshot).

Step 5: Add the SOAP client- In Schritt 1 haben Sie die Client-Datei für den SOAP-Webdienst erstellt. Fügen Sie diese Client-Dateien Ihrem aktuellen Projekt hinzu. Nach dem erfolgreichen Hinzufügen der Client-Dateien sieht Ihr Anwendungsverzeichnis wie folgt aus.

Step 6: Create your main app- Erstellen Sie Ihre Hauptklasse, in der Sie alle diese drei Webdienste nutzen. Klicken Sie mit der rechten Maustaste auf das Quellprojekt und erstellen Sie eine neue Klasse mit dem Namen "MicroServiceInAction.java". Die nächste Aufgabe besteht darin, andere Webdienste als diese aufzurufen.

Step 7: Call your custom web service - Fügen Sie dazu die folgenden Codes hinzu, um den Aufruf Ihres eigenen Dienstes zu implementieren.

try {
   url = new URL("http://localhost:8080/CustomRest/webapi/myresource");
   conn = (HttpURLConnection) url.openConnection();
   conn.setRequestMethod("GET");
   conn.setRequestProperty("Accept", "application/json");
   
   if (conn.getResponseCode() != 200) {
      throw new RuntimeException("Failed : HTTP error code : " + conn.getResponseCode());
   }
   
   BufferedReader br = new BufferedReader(new InputStreamReader(
      (conn.getInputStream())));
   while ((output = br.readLine()) != null) {
      inputToOtherService = output;
   }
   conn.disconnect();

} catch (MalformedURLException e) {
   e.printStackTrace();
} catch (IOException e) {
   e.printStackTrace();
}

Step 8: Consume SOAP Services- Sie haben Ihre Client-Datei generiert, wissen aber nicht, welche Methode in diesem gesamten Paket aufgerufen werden soll? Dazu müssen Sie erneut auf die WSDL verweisen, mit der Sie Ihre Client-Dateien generiert haben. Jede WSDL-Datei sollte eine "wsdl: service" -Tag-Suche für dieses Tag haben. Es sollte Ihr Einstiegspunkt für diesen Webdienst sein. Im Folgenden finden Sie den Service-Endpunkt dieser Anwendung.

Jetzt müssen Sie diesen Dienst in Ihrer Anwendung implementieren. Im Folgenden finden Sie den Java-Code, den Sie zum Implementieren Ihres SOAP-Webdiensts benötigen.

GeoIPService newGeoIPService = new GeoIPService();
GeoIPServiceSoap newGeoIPServiceSoap = newGeoIPService.getGeoIPServiceSoap();
GeoIP newGeoIP = newGeoIPServiceSoap.getGeoIP(Ipaddress);  
// Ipaddress is output of our own web service.

System.out.println("Country Name from SOAP Webserivce ---"+newGeoIP.getCountryName());

Step 9: Consume REST web service- Zwei der Dienste wurden bisher in Anspruch genommen. In diesem Schritt wird mithilfe Ihres benutzerdefinierten Webdienstes ein anderer REST-Webdienst mit angepasster URL verwendet. Verwenden Sie dazu den folgenden Code.

String url1="http://services.groupkt.com/country/get/iso3code/";//customizing the Url
url1 = url1.concat(countryCode);

try {
   URL url = new URL(url1);
   HttpURLConnection conn = (HttpURLConnection) url.openConnection();
   conn.setRequestMethod("GET");
   conn.setRequestProperty("Accept", "application/json");
   
   if (conn.getResponseCode() != 200) {
      throw new RuntimeException("Failed : HTTP error code : " + conn.getResponseCode());
   }
   
   BufferedReader br = new BufferedReader(new InputStreamReader(
      (conn.getInputStream())));
   while ((output = br.readLine()) != null) {
      System.out.println(output);
   }
   conn.disconnect();

} catch (MalformedURLException e) {
   e.printStackTrace();
} catch (IOException e) {
   e.printStackTrace();
}

Step 10: Consume all services - Wenn Ihr Webdienst "CustomRest" ausgeführt wird und Sie mit dem Internet verbunden sind, sollte Ihre konsolidierte Hauptklasse folgen, wenn alles erfolgreich abgeschlossen wurde.

package microserviceinaction;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.StringTokenizer;

import net.webservicex.GeoIP;
import net.webservicex.GeoIPService;
import net.webservicex.GeoIPServiceSoap;

public class MicroServiceInAction {
   static URL url;
   static HttpURLConnection conn;
   static String output;
   static String inputToOtherService;
   static String countryCode;
   static String ipAddress;
   static String CountryName;
   public static void main(String[] args) {
      //consuming of your own web service
      try {
         url = new URL("http://localhost:8080/CustomRest/webapi/myresource");
         conn = (HttpURLConnection) url.openConnection();
         conn.setRequestMethod("GET");
         conn.setRequestProperty("Accept", "application/json");
         
         if (conn.getResponseCode() != 200) {
            throw new RuntimeException("Failed : HTTP error code : " + conn.getResponseCode());
         }
         
         BufferedReader br = new BufferedReader(new InputStreamReader(
            (conn.getInputStream())));
         while ((output = br.readLine()) != null) {
            inputToOtherService = output;
         }
         conn.disconnect();
      
      } catch (MalformedURLException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
      
      //Fetching IP address from the String and other information
      StringTokenizer st = new StringTokenizer(inputToOtherService);
      countryCode = st.nextToken("|");
      CountryName = st.nextToken("|");
      ipAddress = st.nextToken("|");
      
      // Call to SOAP web service with output of your web service--- 
      // getting the location of our given IP address
      String Ipaddress = ipAddress;
      GeoIPService newGeoIPService = new GeoIPService();
      GeoIPServiceSoap newGeoIPServiceSoap = newGeoIPService.getGeoIPServiceSoap();
      GeoIP newGeoIP = newGeoIPServiceSoap.getGeoIP(Ipaddress);
      System.out.println("Country Name from SOAP Webservice ---"+newGeoIP.getCountryName());
      
      // Call to REST API --to get all the details of our country
      String url1 = "http://services.groupkt.com/country/get/iso3code/"; //customizing the Url
      url1 = url1.concat(countryCode);
      
      try {
         URL url = new URL(url1);
         HttpURLConnection conn = (HttpURLConnection) url.openConnection();
         conn.setRequestMethod("GET");
         conn.setRequestProperty("Accept", "application/json");
			
         if (conn.getResponseCode() != 200) {
            throw new RuntimeException("Failed : HTTP error code : " + conn.getResponseCode());
         }
      
         BufferedReader br = new BufferedReader(new InputStreamReader(
            (conn.getInputStream())));
         while ((output = br.readLine()) != null) {
            System.out.println(output);
         }
      
         conn.disconnect();
      } catch (MalformedURLException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Sobald Sie diese Datei ausgeführt haben, wird die folgende Ausgabe in der Konsole angezeigt. Sie haben Ihre erste Microservice-Anwendung erfolgreich entwickelt.