Microservices in Java – types, building, developing

Marlena Walburg
Microservices in Java - types, building, developing

When thinking about today’s technology, its complexity and size, many still cannot get over how much we have developed over the past few decades. Moreover, the trend is that applications will become more and more complicated and extended. It is obvious, therefore, that we need tools that will not only help developers seamlessly create software but also make the code, even huge and intricate in its structure, still readable and easily accessible. In the software development industry, newer frameworks and approaches are emerging that promise great results. Indeed, there is a lot to choose from. We will discuss an extremely popular solution, especially among huge players on the market.

Microservices are increasingly used precisely because of the size and characteristics of currently emerging systems. The combination of smaller services working together, in this case, is a way to achieve greater efficiency during development and better functionality of the entire application. Today we take a closer look again at the matter of microservices, but this time with a special emphasis on frameworks that you can use for developing for Java. 

What are microservices?

Microservices, or microservice architecture, is a kind of the service-oriented architecture (SOA) structural style that organizes an application as a collection of individual services.

Such a construction implies some characteristics of services:

  • independently deployable, autonomously developed and implemented using different technologies each, depending on what is the best solution;
  • fine-grained and the protocols are lightweight;
  • small in size, messaging-enabled, bounded by contexts and decentralized;
  • built and released with automated processes;
  • organized around business capabilities;
  • use technology-agnostic protocols such as HTTP.

We’ve described at detail how microservices work in our Introduction to microservices. In short, they propose building an application as a set of services. In this architecture, all functionality is broken down into independently deployable modules that communicate with each other using defined methods called API. 

What are the Benefits of Microservices?

This approach offers many benefits to both the application itself and the development team. Applications built in this way are easier to understand, test and maintain. It allows you to achieve much greater flexibility, and significantly reduce the time needed to implement improvements and development, and better manage bug fixes and feature versions. Services can be scaled independently, and updated without having to redeploy the entire application and roll back the update if something goes wrong. It enables the development of each service by one team, thus focusing solely on the functionality of this service. It visibly speeds up coding, increases agility and productivity and lowers costs, also because you can reuse single service code on other projects.

When you may need to use microservices?

Perhaps this will surprise you, but microservices should not be the default choice. Instead, consider the features of your project before opting for this approach. However, microservices will be a good solution when: 

  • you need fast and high scaling for every aspect of your system; 
  • modularity and decentralization are important from the very beginning of the project;
  • the application will have high volume transactions or traffic;
  • you want to rewrite poorly designed monolith application to microservices;
  • you have a team of developers with extensive experience in microservices, or you intend to hire such specialists.

Businesses like Google, Amazon, Twitter, PayPal, eBay and Netflix have had very good experiences with the transition to a microservice architecture. It has enabled them to scale-up on a large scale, increased code scalability and ease of maintenance, stimulated rapid business innovation, created faster product delivery, and even enhanced security.

Types of microservices in Java

Let’s move on to the main topic and focus on microservices in Java. This programming language is extensively used in this case, with many enterprise applications using it, and Spotify is at front. There are several frameworks of this kind, and we will discuss the most significant of them.

Spring Boot

For a large number of developers, Spring Boot is the best structure. Let’s start with what Spring itself is – it’s a platform that is currently the most popular Java solution. Spring makes programming faster and easier and focuses on efficiency and flexibility. Spring has many extensive libraries, the management of which requires developers to understand the dependencies between them. Using it also required an external server, which allowed us to upload the application and verify its correct operation, which extended the time of configuration, startup and testing. 

Consequently, the Spring Boot, convention-over-configuration solution, was made. Spring Boot allows creating stand-alone, production-grade Spring-based applications that you can readily run. It has all the infrastructure your applications need and uses the embedded Tomcat server. It’sfor a starter thanks to which you can avoid spending many hours creating a basic configuration. Thanks to the simplicity of configuration, the flexibility of operation and quick commissioning, without unnecessary external application servers, Spring Boot can constantly provide customers with newer functionalities. It does not require any additional tools, nor are we tied to one technology. Creating Java microservices with Spring Boot is a great option to simplify work in an extensive programming environment.


Dropwizard is an open-source Java platform for rapidly building REST-compliant high-performance web services. Collects popular libraries to create a lightweight package. The main libraries it uses are Jetty, Jersey, Jackson, JUnit, Guava, and its dedicated library, Metrics. Dropwizard was created by Coda Hale at Yammer to power the company’s distributed systems architectures – which are microservices. It started its career as a code that linked powerful libraries for writing REST web services together. It has been more elaborate since then but is still a minimalist, production-ready, and easy-to-use framework.

This framework is more dogmatic than the Spring Boot. Some components are just part of the framework and cannot be easily changed. Also, it doesn’t come with a dependency-injection container. In software engineering, dependency injection is a technique in which an object receives other objects that it depends on. You can add such an element, but the point of Dropwizard is keeping the development of microservices simple. The framework has out-of-the-box support for refined configuration, application metrics, logging, operational tools, and much more, allowing developers to deliver a production-quality web service in the shortest time possible.


Another framework to build Java-based microservices is Restlet. It’s fully open-source and can be used under the terms of the Apache Software License. Restlet aids to create faster, better and more scalable web APIs that follow the REST architecture style, thanks to strong routing and filtering capabilities, unified client and server Java API. It offers numerous extensions that enable developers to save time by not writing many lines of code. It can be deployed for all major platforms, such as Java EE, Android or Google AppEngine. 

Restlet provides a flexible set of reusable classes and interfaces that serves as the basis for building API-based applications more efficiently. The framework mapped to the REST and HTTP concepts can be used for both client and server-side development using the same Java API, which reduces both the learning curve and the software load.


Spark is a free, open-source, lightweight and expressive Java web framework for rapid development. Like another framework, Ruby-based Sinatra, Spark does not follow the model-view-controller pattern used in other frameworks such as Spring and allows to structure an application as the developers want.  It runs on an embedded Jetty web server by default but can be configured to run on other web servers. 

Spark was created for those who use JVM, one of the largest development ecosystems in the world but want to write code less tediously. It was designed not only to make working with code more productive but also to make code better thanks to Spark’s clean, declarative and distinct syntax. Spark has a consistent, simple, understandable, and flexible API to handle requests, responses, filters, and so on. It’s great for creating small web applications. It does not complicate the code too much, which allows you to avoid strange behaviour of the application and errors. Moreover, it’s extendable and enables the plugging of any templating library. 

What is Java EE Containers

Many solutions want to facilitate code creation and reduce its amount, such as the above frameworks. When it comes to building java microservices project for large businesses, Java EE is a very significant player here. 

Java EE (Enterprise Edition) is a set of specifications that extend Java SE 8 to include specifications for enterprise features such as distributed computing and web services. Java EE applications running in reference runtime environments, which can be microservices or application servers that handle transactions, security, scalability, concurrency, and management of deployed components. The component-based and platform-independent Java EE architecture makes these apps easy to write as business logic is organized into reusable components. Besides, the Java EE server provides the basic services in the form of a container for each type of component. Because there is no need to develop these services yourself, they allow focus on solving a given business problem.

Container Services

Containers are the interface between a component and the low-level platform-specific functionality that runs the component. Before it can be run, the web client, enterprise bean, or application component must be assembled into a Java EE module and deployed in its container.

In the assembly process, it’s required to specify container settings for each component in the Java EE application and for the application itself. The container settings customize the basic support provided by a Java EE server, including services such as security, transaction management, Java and Directory Name APIs (JNDI) lookup, and remote connectivity. Java EE architecture provides configurable services and manages some of the nonconfigurable ones, such as enterprise bean and servlet lifecycles, database connection resource pooling, data persistence, and access to the Java EE platform APIs. Because of these configuration options, components within the same application can behave differently based on where they are deployed. Here are some of the essentials worth knowing.

  • The Java EE transaction model allows you to define relationships between methods that make up a single transaction. Thanks to that, all methods in one transaction are treated as one unit;
  • The Java EE security model allows you to configure the web component or enterprise bean so that only authorized users can access system resources;
  • The Java EE remoting model manages low-level communication between clients and enterprise beans. After the enterprise bean is created, the client calls methods on it as if it were in the same virtual machine;
  • JNDI Discovery Services provides a unified interface to many enterprise naming and directory services and as a result, the application components can access these services.

Container Types

There are several types of containers:

  • Enterprise JavaBeans (EJB) container: Manages the execution of enterprise beans for Java EE applications. Enterprise seeds and their container run on the Java EE server.
  • Web container: Manages the execution of JSPs and servlet components for Java EE applications. The web components and their container run on the Java EE server.
  • Application client container: Manages the execution of application client components. Application clients and their containers run on the client.
  • Applet container: Manages the execution of applets. It consists of a web browser and a Java plug-in running together on the client.
  • Java EE server: Part of the Java EE runtime. Java EE server provides EJB and web containers.

Best Practices for Microservices

When creating software, you often have to make a compromise. Sometimes gaining independence of operation, simplicity in writing and implementing code, you lose efficiency and good performance. It is the same with microservices. Therefore, in order for as few obstacles as possible to appear on the development path, it is worth following these good practices.

  • Organize your team around microservices – to deal with different microservices, you need to build separate teams. These teams should have sufficient authority to work with their microservices, but also aware of the overall project plan;
  • Turn CRUD operations into microservices –  microservices are particularly well-suited to units that are accessed with the creating, retrieve, update, delete (CRUD) pattern. You only need a single microservice call for the operation, and this is huge facilitation to this kind of operations;
  • Provide batch APIs – they provide good microservice performance for groups of entities;
  • Use Distributed Configuration – this allows saving time and not configuring everything separately;
  • Monitor everything regularly – a good monitoring solution should take into account the ongoing changes in resource allocation and store the data collected from monitoring in a central database;
  • Introduce APM (Application performance management) – APM tries to detect and diagnose complex application performance problems to maintain the expected level of service;
  • Remember about logging – it’s not very important during development, but is a crucial point in maintenance. Record the most important events;
  • Transparency – since continuous delivery is one of the most important reasons for migrating to a microservice architecture, it is significant to know the current version, where it was released, and what changes it contains;


Microservices can be a great solution for large enterprises. Implementing this, however, is a process that requires prudent planning and weighing up the pros and cons. It should not be automatic, but a well-thought-out decision. Remember that we have covered all the features, perks and drawbacks in our Introduction to Microservices. Writing microservices in Java may bring a lot of benefits for your business, though. Completing development teams is also easier due to the popularity of this programming language. When properly implemented, microservices bring amazing results. Not only do they help break down large systems and problems into smaller parts that are easier to deal with, but also make the corporate culture more open, ready for change, and more independent. The experience gained by leading companies like Netflix and Amazon is a good lesson for other companies considering whether to go in this direction.

Read more about Java in our related blog posts: 

You may also be interested in...

Let's bring your project to life

Request a consultation