TOC

Introduction aux microservices Java avec MSF4J

Introduction aux microservices Java avec MSF4J

1. Vue d'ensemble

Dans ce tutoriel, nous allons présentermicroservices development using the MSF4Jframework.

Il s’agit d’un outil léger qui offre un moyen simple de créer une grande variété de services axés sur la haute performance.

2. Dépendances Maven

Nous aurons besoin d’un peu plus de configuration Maven que d’habitude pour créer un microservice basé sur MSF4J. La simplicité et la puissance de ce framework ont ​​un prix:basically, we need to define a parent artifact, ainsi que la classe principale: 


    org.wso2.msf4j
    msf4j-service
    2.6.0



    
        com.example.msf4j.Application

La dernière version demsf4j-service est disponible sur Maven Central.

Ensuite, nous montrerons trois scénarios de microservices différents. Tout d'abord, un exemple minimaliste, puis une API RESTful et enfin un exemple d'intégration Spring.

3. Projet de base

3.1. API simple

Nous allons publier une ressource Web simple.

Ce service est fourni avec une classe utilisant des annotations dans lesquelles chaque méthode traite une demande. A travers ces annotations, nous définissons la méthode, le chemin et les paramètres requis pour chaque requête.

Le type de contenu renvoyé est simplement du texte brut: 

@Path("/")
public class SimpleService {

    @GET
    public String index() {
        return "Default content";
    }

    @GET
    @Path("/say/{name}")
    public String say(@PathParam("name") String name) {
        return "Hello " + name;
    }
}

Et rappelez-vous que toutes les classes et annotations utilisées ne sont que des élémentsstandard JAX-RS, que nous avons déjà couvertsin this article.

3.2. Application

We can launch the microservice with this main class où nous définissons, déployons et exécutons le service défini précédemment: 

public class Application {
    public static void main(String[] args) {
        new MicroservicesRunner()
          .deploy(new SimpleService())
          .start();
    }
}

Si nous le voulons, nous pouvons enchaîner ici les appelsdeploy pour exécuter plusieurs services à la fois: 

new MicroservicesRunner()
  .deploy(new SimpleService())
  .deploy(new ComplexService())
  .start()

3.3. Exécution du microservice

Pour exécuter le microservice MSF4J, nous avons plusieurs options:

  1. Sur un IDE, s'exécutant en tant qu'application Java

  2. Exécution du package jar généré

Une fois démarré, vous pouvez voir le résultat àhttp://localhost:9090.

3.4. Configurations de démarrage

We can tweak the configuration de nombreuses façons simplement en ajoutant des clauses au code de démarrage.

Par exemple, nous pouvons ajouter n’importe quel type d’intercepteur pour les requêtes: 

new MicroservicesRunner()
  .addInterceptor(new MetricsInterceptor())
  .deploy(new SimpleService())
  .start();

Ou, nous pouvons ajouter un intercepteur global, comme un pour l'authentification: 

new MicroservicesRunner()
  .addGlobalRequestInterceptor(newUsernamePasswordSecurityInterceptor())
  .deploy(new SimpleService())
  .start();

Ou, si nous avons besoin d'une gestion de session, nous pouvons définir un gestionnaire de session: 

new MicroservicesRunner()
  .deploy(new SimpleService())
  .setSessionManager(new PersistentSessionManager())
  .start();

Pour plus de détails sur chacun de ces scénarios et pour voir quelques exemples de travail, consultez lesofficial GitHub repo de MSF4J.

4. Créer un microservice d'API

Nous avons montré l'exemple le plus simple possible. Nous allons maintenant passer à un projet plus réaliste.

Cette fois, nous montrons comment construire une API avec toutes les opérations CRUD typiques pour gérer un référentiel de repas.

4.1. Le modèle

Le modèle est juste un simple POJO représentant un repas: 

public class Meal {
    private String name;
    private Float price;

    // getters and setters
}

4.2. L'API

Nous construisons l'API en tant que contrôleur Web. En utilisant des annotations standard, nous définissons chaque fonction avec les éléments suivants:

  • Chemin de l'URL

  • Méthode HTTP: GET, POST, etc.

  • type de contenu d'entrée (@Consumes)

  • type de contenu de sortie (@Produces)

Alors, créons une méthode pour chaque opération CRUD standard: 

@Path("/menu")
public class MenuService {

    private List meals = new ArrayList();

    @GET
    @Path("/")
    @Produces({ "application/json" })
    public Response index() {
        return Response.ok()
          .entity(meals)
          .build();
    }

    @GET
    @Path("/{id}")
    @Produces({ "application/json" })
    public Response meal(@PathParam("id") int id) {
        return Response.ok()
          .entity(meals.get(id))
          .build();
    }

    @POST
    @Path("/")
    @Consumes("application/json")
    @Produces({ "application/json" })
    public Response create(Meal meal) {
        meals.add(meal);
        return Response.ok()
          .entity(meal)
          .build();
    }

    // ... other CRUD operations
}

4.3. Fonctions de conversion de données

MSF4J offers support for different data conversion libraries tels que GSON (qui vient par défaut) et Jackson (via la dépendancemsf4j-feature). Par exemple, nous pouvons utiliser GSON explicitement: 

@GET
@Path("/{id}")
@Produces({ "application/json" })
public String meal(@PathParam("id") int id) {
    Gson gson = new Gson();
    return gson.toJson(meals.get(id));
}

En passant, notez que nous avons utilisé des accolades dans les annotations@Consumes et@Produces afin de pouvoir définir plusieurs types mime.

4.4. Exécution du microservice API

Nous exécutons le microservice comme nous l'avons fait dans l'exemple précédent, via une classeApplication qui publie lesMenuService.

Une fois démarré, vous pouvez voir le résultat àhttp://localhost:9090/menu.

5. MSF4J et Spring

We can also apply Spring in our MSF4J based microservices, à partir duquel nous obtiendrons ses fonctionnalités d'injection de dépendances.

5.1. Dépendances Maven

Nous devrons ajouter les dépendances appropriées à la configuration précédente de Maven pour ajouter la prise en charge de Spring et Moustache: 


    
        org.wso2.msf4j
        msf4j-spring
        2.6.1
    
    
        org.wso2.msf4j
        msf4j-mustache-template
        2.6.1

La dernière version demsf4j-spring etmsf4j-mustache-template est disponible sur Maven Central.

5.2. API de repas

Cette API est un simple service utilisant un référentiel de repas simulé. Notice how we use Spring annotations for auto-wiring et pour définir cette classe comme composant de service Spring. 

@Service
public class MealService {

    @Autowired
    private MealRepository mealRepository;

    public Meal find(int id) {
        return mealRepository.find(id);
    }

    public List findAll() {
        return mealRepository.findAll();
    }

    public void create(Meal meal) {
        mealRepository.create(meal);
    }
}

5.3. Manette

Nous déclarons le contrôleur en tant que composant et Spring fournit le service via un câblage automatique. La première méthode montre comment servir un modèle Moustache et la seconde une ressource JSON: 

@Component
@Path("/meal")
public class MealResource {

    @Autowired
    private MealService mealService;

    @GET
    @Path("/")
    public Response all() {
        Map map = Collections.singletonMap("meals", mealService.findAll());
        String html = MustacheTemplateEngine.instance()
          .render("meals.mustache", map);
        return Response.ok()
          .type(MediaType.TEXT_HTML)
          .entity(html)
          .build();
    }

    @GET
    @Path("/{id}")
    @Produces({ "application/json" })
    public Response meal(@PathParam("id") int id) {
        return Response.ok()
          .entity(mealService.find(id))
          .build();
    }

}

5.4. Programme principal

Dans le scénario Spring, voici comment démarrer le microservice: 

public class Application {

    public static void main(String[] args) {
        MSF4JSpringApplication.run(Application.class, args);
    }
}

Once started, we can see the result at http://localhost:8080/meals. Le port par défaut diffère dans les projets Spring, mais nous pouvons le définir sur le port de notre choix.

5.5. Beans de configuration

Pour activer des paramètres spécifiques, y compris les intercepteurs et la gestion de session, nous pouvons ajouter des beans de configuration.

Par exemple, celui-ci change le port par défaut pour le microservice: 

@Configuration
public class PortConfiguration {

    @Bean
    public HTTPTransportConfig http() {
        return new HTTPTransportConfig(9090);
    }

}

6. Conclusion

Dans cet article, nous avons présenté le framework MSF4J, en appliquant différents scénarios pour créer des microservices Java.

Il y a beaucoup de buzz autour de ce concept, maissome theoretical background has been already set et MSF4J fournissent un moyen pratique et standardisé d'appliquer ce modèle.

Aussi, pour plus de lecture, jetez un œil àbuilding Microservices with Eclipse Microprofile, et bien sûr à notre guide surSpring Microservices with Spring Boot and Spring Cloud.

Et enfin, tous les exemples ici peuvent être trouvésin the GitHub repo.

Related