Construire un microservice avec Apache Meecrowave

1. Vue d'ensemble

Dans ce didacticiel, nous allons explorer les fonctionnalités de base du framework ApacheMeecrowave.

Meecrowave is a lightweight microservices framework from Apache, qui fonctionne très bien avec les API CDI, JAX-RS et JSON. C'est très simple à configurer et à déployer. Il évite également le déploiement de serveurs d'applications lourds tels que Tomcat, Glassfish, Wildfly, etc.

2. Dépendance Maven

Pour utiliser Meecrowave, définissons la dépendance enpom.xml:


    org.apache.meecrowave
    meecrowave-core
    1.2.1

Recherchez la dernière version surMaven Central.

3. Démarrer un serveur simple

Je commande pour démarrer un serveur Meecrowave, tout ce que nous avons à faire est d'écrire la méthodemain ,create a Meecrowave instance and invoke the main bake() method:

public static void main(String[] args) {
    try (Meecrowave meecrowave = new Meecrowave()) {
        meecrowave.bake().await();
    }
}

Nous n'avons pas besoin de cette méthode principale si nous conditionnons l'application en tant que package de distribution; nous examinerons cela dans les sections suivantes. La classe principale est utile lors du test de l'application à partir d'un IDE.

En tant qu’avantage, lors du développement dans un environnement de développement intégré (IDE), une fois que nous exécutons l’application à l’aide de la classe principale, celle-ci se recharge automatiquement avec les modifications de code.

Notez que, si nous utilisons Java 9, n'oubliez pas d'ajouter les modules javax.xml.bind à la VM:

--add-module javax.xml.bind

La création du serveur de cette façon le lancera avec la configuration par défaut. Nous pouvons mettre à jour par programmation les configurations par défaut en utilisant la classeMeecrowave.Builder:

Meecrowave.Builder builder = new Meecrowave.Builder();
builder.setHttpPort(8080);
builder.setScanningPackageIncludes("com.example.meecrowave");
builder.setJaxrsMapping("/api/*");
builder.setJsonpPrettify(true);

Et utilisez cette instancebuilder lors de la cuisson du serveur:

try (Meecrowave meecrowave = new Meecrowave(builder)) {
    meecrowave.bake().await();
}

Il y a plus de propriétés configurableshere.

4. Points de terminaison REST

Maintenant, une fois que le serveur est prêt, créons des points de terminaison REST:

@RequestScoped
@Path("article")
public class ArticleEndpoints {

    @GET
    public Response getArticle() {
        return Response.ok().entity(new Article("name", "author")).build();
    }

    @POST
    public Response createArticle(Article article) {
        return Response.status(Status.CREATED).entity(article).build();
    }
}

Notez que nous utilisons principalementJAX-RS annotations to create the REST endpoints. En savoir plus sur JAX-RShttps://www.example.com/jax-rs-spec-and-implementations. [Ici].

Dans la section suivante, nous verrons comment tester ces points de terminaison.

5. Tests unitaires

Ecrire des cas de test unitaires avec les API REST écrites avec Meecrowave est simple comme écrire des cas de test JUnit annotés.

Ajoutons d'abord les dépendances de test à notrepom.xml :


    org.apache.meecrowave
    meecrowave-junit
    1.2.1
    test

Pour voir la dernière version, consultezMaven Central.

Ajoutons égalementOkHttp comme client HTTP pour nos tests:


    com.squareup.okhttp3
    okhttp
    3.10.0

Découvrez la dernière versionhere.

Maintenant, avec les dépendances en place, allons de l'avant et écrivons les tests:

@RunWith(MonoMeecrowave.Runner.class)
public class ArticleEndpointsTest {

    @ConfigurationInject
    private Meecrowave.Builder config;
    private static OkHttpClient client;

    @BeforeClass
    public static void setup() {
        client = new OkHttpClient();
    }

    @Test
    public void whenRetunedArticle_thenCorrect() {
        String base = "http://localhost:" + config.getHttpPort();

        Request request = new Request.Builder()
          .url(base + "/article")
          .build();
        Response response = client.newCall(request).execute();
        assertEquals(200, response.code());
    }
}

Lors de l'écriture des cas de test, faites pour annoter la classe de test avec la classeMonoMeecrowave.Runner, injectez également la configuration, pour accéder au port aléatoire utilisé par Meecrowave pour le serveur de test

6. Injection de dépendance

Pourinject dependencies into a class, nous devons annoter ces classes dans une portée particulière.

Prenons l'exemple d'une classeArticleService :

@ApplicationScoped
public class ArticleService {
    public Article createArticle(Article article) {
        return article;
    }
}

Maintenant, injectons ceci dans notre instanceArticleEndpoints en utilisant l'annotationjavax.inject.Inject:

@Inject
ArticleService articleService;

7. Emballage de l'application

Créer un paquet de distribution devient très simple, avec le plugin Meecrowave Maven:


    ...
    
        
            org.apache.meecrowave
            meecrowave-maven-plugin
            1.2.1

Une fois le plugin en place, nous allonsuse the Maven goal meecrowave:bundle to package the application.

Une fois empaqueté, il créera un zip dans le répertoire cible:

meecrowave-meecrowave-distribution.zip

Ce zip contient les artefacts requis pour déployer l'application:

|____meecrowave-distribution
| |____bin
| | |____meecrowave.sh
| |____logs
| | |____you_can_safely_delete.txt
| |____lib
| |____conf
| | |____log4j2.xml
| | |____meecrowave.properties

Accompagnons le répertoire bin et démarrons l'application:

./meecrowave.sh start

Pour arrêter l'application:

./meecrowave.sh stop

8. Conclusion

Dans cet article, nous avons appris à utiliser Apache Meecrowave pour créer un microservice. Nous avons également examiné certaines configurations de base de l’application et préparé un package de distribution.

Comme toujours, les extraits de code peuvent être trouvés dans lesGithub Project.

TOC

Construire un microservice avec Apache Meecrowave