Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

November Discount Launch 2022 – Top
We’re finally running a Black Friday launch. All Courses are 30% off until the end of this week:


November Discount Launch 2022 – TEMP TOP (NPI)
We’re finally running a Black Friday launch. All Courses are 30% off until the end of this week:



1. Overview

In this tutorial, we'll explore the basic functionality of the Apache Meecrowave framework.

Meecrowave is a lightweight microservices framework from Apache, which works very well with CDI, JAX-RS, and JSON API's. It's very simple to setup and deploy. It also eliminates the hassle of deploying heavy application servers like Tomcat, Glassfish, Wildfly, etc.

2. Maven Dependency

To use Meecrowave, let's define the dependency in pom.xml:


Check for the latest version on Maven Central.

3. Starting a Simple Server

I order to start a Meecrowave server all we need to do is write the main method, create a Meecrowave instance and invoke the main bake() method:

public static void main(String[] args) {
    try (Meecrowave meecrowave = new Meecrowave()) {

We don't need this main method if we package the application as a distribution package; we'll look into that in the later sections. The main class is useful while testing the application from an IDE.

As an advantage, while developing in an IDE, once we run the application using the main class, it reloads automatically with code changes, thus saving the hassle of restarting the server again and again to test.

Note that, if we are using Java 9, don't forget to add javax.xml.bind modules to the VM:

--add-module javax.xml.bind

Creating the server this way will start it with default configuration. We can programmatically update the default configurations using the Meecrowave.Builder class:

Meecrowave.Builder builder = new Meecrowave.Builder();

And use this builder instance while baking the server:

try (Meecrowave meecrowave = new Meecrowave(builder)) { 

There are more configurable properties here.

4. REST Endpoints

Now, once the server is ready, let's create some REST endpoints:

public class ArticleEndpoints {
    public Response getArticle() {
        return Response.ok().entity(new Article("name", "author")).build();      
    public Response createArticle(Article article) { 
        return Response.status(Status.CREATED).entity(article).build(); 

Notice that, we're mostly using JAX-RS annotations to create the REST endpoints. Read more about JAX-RS here.

In the next section, we'll see how to test these endpoints.

5. Testing

Writing unit test cases with for REST API's written with Meecrowave is simple as writing annotated JUnit test cases.

Let's add the test dependencies to our pom.xml first:


To see the latest version, check out Maven Central.

Also, let's add OkHttp as HTTP client for our tests:


Check out the latest version here.

Now with the dependencies in place lets go ahead and write the tests:

public class ArticleEndpointsIntegrationTest {
    private Meecrowave.Builder config;
    private static OkHttpClient client;
    public static void setup() {
        client = new OkHttpClient();
    public void whenRetunedArticle_thenCorrect() {
        String base = "http://localhost:" + config.getHttpPort();
        Request request = new Request.Builder()
          .url(base + "/article")
        Response response = client.newCall(request).execute();
        assertEquals(200, response.code());

While writing the test cases, make to annotate the test class with MonoMeecrowave.Runner class, also inject the configuration, to get access to the random port used by Meecrowave for the test server

6. Dependency Injection

To inject dependencies into a class, we need to annotate those classes within a particular scope.

Let's take the example of an ArticleService class:

public class ArticleService {
    public Article createArticle(Article article) {
        return article;

Now let's inject this into our ArticleEndpoints instance using the javax.inject.Inject annotation:

ArticleService articleService;

7. Packaging the Application

Creating a distribution package becomes very simple, with the Meecrowave Maven plugin:


Once we have the plugin in place let's use the Maven goal meecrowave:bundle to package the application.

Once packaged it will create a zip inside the target directory:


This zip contains the required artifacts to deploy the application:

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

Let's navigate to the bin directory and start the application:

./meecrowave.sh start

To stop the application:

./meecrowave.sh stop

8. Conclusion

In this article, we learned about using Apache Meecrowave to create a microservice. Also, we looked into some basic configuration about the application and to prepare a distribution package.

As always the code snippets could be found in the Github Project.


November Discount Launch 2022 – Bottom
We’re finally running a Black Friday launch. All Courses are 30% off until the end of this week:


REST footer banner
Comments are closed on this article!