Architecture de microservice - SOA pratique

Dans ce chapitre, nous développerons une application basée sur CRUD avec une architecture SOA. Plus tard dans les chapitres suivants, nous décomposerons ce service en microservice et nous apprendrons la différence fondamentale entre l'architecture SOA et microservice.

Configuration et installation du système

Dans cette section, nous allons créer un exemple d'application CRUD, qui renverra un objet JSON en tant que réponse chaque fois que nous appelons notre service. Nous utiliserons le framework Jersey pour développer le même. Voici les étapes de configuration de votre environnement système local.

Développement d'une application CRUD

Step 1- Nous utiliserons NetBeans comme IDE de développement. Veuillez télécharger et installer la dernière version disponible sur le site officiel de NetBeanshttps://netbeans.org/downloads/.

Step 2- Ouvrez votre IDE NetBeans. Allez dans «Fichier -> Nouveau projet». La capture d'écran suivante apparaît. Choisissez «Maven» comme catégorie et sélectionnez «Projet d'ArchType» comme projet et cliquez sur Suivant.

Cela téléchargera tous les fichiers jar requis pour créer votre tout premier projet Maven et service Web RESTful.

Step 3- En appuyant sur le bouton Suivant à l'étape précédente, la capture d'écran suivante apparaît. Ici, vous devrez spécifier l'archétype Maven.

Dans la zone de recherche, recherchez «Jersey-archType-Webapp (2.16)» et cochez la case «Afficher les anciens».

Step 4- Une fois que vous avez sélectionné le même, vous serez redirigé vers l'écran suivant. Sélectionnez le pot préféré dans la liste et appuyez sur Suivant pour continuer.

Step 5- Dans cette étape, vous devez fournir le nom de votre projet et son identifiant de groupe ainsi que les détails du package. Après avoir fourni toutes ces informations, appuyez sur Terminer pour continuer.

Step 6- Vous avez terminé la configuration de votre espace de travail. Le répertoire du projet ressemblera à ce qui suit.

Consultez votre dossier «Dépendances» et vous constaterez que Maven a automatiquement téléchargé tous les fichiers jar requis pour ce projet.

Step 7- Votre espace de travail est configuré et vous pouvez commencer par le codage. Allez-y et créez quatre classes et packages comme indiqué dans la capture d'écran suivante. Vous pouvez constater que MyResource.java est déjà créé par Maven, car Maven est suffisamment intelligent pour détecter que vous allez créer votre propre service Web.

Step 8 - Une fois l'étape ci-dessus terminée, nous allons construire notre classe POJO qui est UserProfile.java comme suit.

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- Nous allons maintenant créer notre classe Database. Comme cela fait partie du matériel d'apprentissage, nous n'utiliserons aucune base de données comme base de données. Nous utiliserons une mémoire Java intégrée pour fonctionner comme mémoire temporaire. Comme vous pouvez le voir dans l'ensemble de code suivant, nous utiliserons MAP comme base de données. Toutes les opérations de service Web que nous effectuons, nous travaillerons sur cette MAP définie dans la classe.

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- Construisons maintenant notre classe de service. Allez-y et copiez-collez l'ensemble de code suivant dans la classe «ProfileService.java». C'est la classe dans laquelle nous déclarerons toutes nos méthodes de service Web qui doivent être exposées pour le monde extérieur. Nous devons créer une référence de notre DatabaseClass afin que notre base de données temporaire soit accessible dans cette classe.

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 - Dans cette étape, nous allons créer notre classe Resource qui sera liée à l'URL et le service correspondant sera appelé.

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- Nettoyez le projet et exécutez-le. Si tout se passe bien, vous devriez obtenir la sortie suivante dans le navigateur, tout en accédanthttp://localhost:8080/UserProfile/webapi/Profile” URL.

Vous pouvez voir que différentes entrées sont remplies à l'aide d'une représentation XML.

Différentes méthodes peuvent être testées à l'aide de Postman en appliquant une URL de méthode appropriée.

@GET method - La capture d'écran suivante montre comment nous pouvons obtenir le résultat souhaité pour get request, qui renvoie tous les détails de l'utilisateur.

@POST- La requête suivante peut être utilisée pour tester notre méthode Post. Remarquez comment le proId a été généré automatiquement.

@PUT- Cette méthode mettra à jour les entrées. La capture d'écran suivante montre comment Jersey prend le proId de l'URL de la demande et met à jour la même réponse de profil utilisateur.

De la même manière, vous pouvez rechercher d'autres méthodes disponibles dans vos services Web.

Dans la section précédente, nous avons développé un service qui exposera la fonctionnalité CRUD. Désormais, chaque fois que nous essayons d'implémenter ce service dans notre application, nous devons créer un client de cette application et le joindre à notre application. Dans ce chapitre, nous allons apprendre à créer cette fonctionnalité en utilisant le concept de Microservice. Voici une représentation schématique de notre application créée à l'aide des étapes ci-dessus.

L'acteur doit être le point d'entrée de notre service. Dans ce cas, «ProfileResource.java» assume la responsabilité d'un acteur. Cette classe appellera différentes méthodes pour effectuer différentes opérations telles que l'ajout, la mise à jour et la suppression.

Décomposition de l'application CRUD

Selon le principe de base du microservice, nous n'avons besoin que d'une seule tâche métier pour chacun des modules, par conséquent un acteur ne doit pas être responsable des quatre fonctionnalités CRUD. Prenons l'exemple suivant dans lequel nous avons introduit de nouveaux rôles de telle sorte qu'il sera clair sur le plan conceptuel pour vous que Microservice est une représentation architecturale de SOA.

«L'utilisateur principal» est l'utilisateur qui communique avec le «contrôleur d'application» pour répondre à ses besoins. Le «contrôleur d'application» est celui qui appelle simplement différents «gestionnaires de ressources» en fonction de la demande de l'utilisateur final. «Resource Manager» fait le travail qui doit être fait. Jetons un coup d'œil sur les différents rôles des différentes unités de l'application.

  • End User/Main Users - Demandes de certaines ressources à Application Controller.

  • Application - Reçoit la demande et la transmet à un gestionnaire de ressources spécifique.

  • Resource Manager - Effectue le travail réel de mise à jour, de suppression et d'ajout d'utilisateurs.

Voyez comment la responsabilité totale d'une classe est répartie entre différentes autres classes.

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved