Construindo um microsserviço com o Apache Meecrowave

1. Visão geral

Neste tutorial, vamos explorar a funcionalidade básica da estrutura do ApacheMeecrowave.

Meecrowave is a lightweight microservices framework from Apache, que funciona muito bem com CDI, JAX-RS e APIs JSON. É muito simples de configurar e implantar. Também elimina o incômodo de implantar servidores de aplicativos pesados como Tomcat, Glassfish, Wildfly, etc.

2. Dependência do Maven

Para usar o Meecrowave, vamos definir a dependência empom.xml:


    org.apache.meecrowave
    meecrowave-core
    1.2.1

Verifique a versão mais recente emMaven Central.

3. Iniciando um Servidor Simples

Para iniciar um servidor Meecrowave, tudo o que precisamos fazer é escrever o métodomain ,create a Meecrowave instance and invoke the main bake() method:

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

Não precisamos desse método principal se empacotarmos o aplicativo como um pacote de distribuição; veremos isso nas seções posteriores. A classe principal é útil ao testar o aplicativo a partir de um IDE.

Como vantagem, durante o desenvolvimento de um IDE, uma vez que executamos o aplicativo usando a classe principal, ele é recarregado automaticamente com alterações de código, economizando o trabalho de reiniciar o servidor repetidamente para testar.

Observe que, se estivermos usando Java 9, não se esqueça de adicionar módulos javax.xml.bind à VM:

--add-module javax.xml.bind

Criar o servidor dessa maneira o iniciará com a configuração padrão. Podemos atualizar programaticamente as configurações padrão usando a classeMeecrowave.Builder:

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

E use estabuilder instance enquanto assa o servidor:

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

Existem mais propriedades configuráveishere.

4. Endpoints REST

Agora, quando o servidor estiver pronto, vamos criar alguns endpoints 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();
    }
}

Observe que estamos usando principalmenteJAX-RS annotations to create the REST endpoints. Leia mais sobre JAX-RShttps://www.example.com/jax-rs-spec-and-implementations. [Aqui].

Na próxima seção, veremos como testar esses terminais.

5. Teste de Unidade

Escrever casos de teste de unidade com a API REST escrita com Meecrowave é tão simples quanto escrever casos de teste JUnit anotados.

Vamos adicionar as dependências de teste ao nossopom.xml primeiro:


    org.apache.meecrowave
    meecrowave-junit
    1.2.1
    test

Para ver a versão mais recente, verifiqueMaven Central.

Além disso, vamos adicionarOkHttp como cliente HTTP para nossos testes:


    com.squareup.okhttp3
    okhttp
    3.10.0

Verifique a versão mais recentehere.

Agora, com as dependências implementadas, vamos em frente e escreva os testes:

@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());
    }
}

Ao escrever os casos de teste, faça anotações na classe de teste com a classeMonoMeecrowave.Runner, injete também a configuração, para obter acesso à porta aleatória usada pelo Meecrowave para o servidor de teste

6. Injeção de dependência

Parainject dependencies into a class, precisamos anotar essas classes dentro de um escopo particular.

Vamos pegar o exemplo de um sclassArticleService :

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

Agora vamos injetar isso em nossa instânciaArticleEndpoints usando a anotaçãojavax.inject.Inject:

@Inject
ArticleService articleService;

7. Empacotando o aplicativo

Criar um pacote de distribuição se torna muito simples, com o plugin Meecrowave Maven:


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

Assim que tivermos o plugin instalado, vamosuse the Maven goal meecrowave:bundle to package the application.

Uma vez empacotado, ele criará um zip dentro do diretório de destino:

meecrowave-meecrowave-distribution.zip

Esse zip contém os artefatos necessários para implementar o aplicativo:

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

Vamos navegar até o diretório bin e iniciar o aplicativo:

./meecrowave.sh start

Para parar o aplicativo:

./meecrowave.sh stop

8. Conclusão

Neste artigo, aprendemos sobre o uso do Apache Meecrowave para criar um microsserviço. Além disso, analisamos algumas configurações básicas sobre o aplicativo e preparamos um pacote de distribuição.

Como sempre, os trechos de código podem ser encontrados emGithub Project.

TOC

Construindo um microsserviço com o Apache Meecrowave