A guide to Java microservice frameworks
You’ll find Java at the top of any list of the best programming languages. Its functionality, stability, and versatility are just some of the reasons it’s been around for over 25 years, and its robust community is why Java continues to evolve. Given the popularity and scalability of Java, it makes sense that many organizations are using it as they shift to a microservices architecture.
No matter what it is that appeals to you about Java, if you’ve decided that it’s the language of the future, you’re going to need a framework to build from. Because Java has such a significant community, there are a lot of options out there, and a few things you’ll want to keep in mind before you adopt a framework.
Java microservice frameworks
Frameworks save your engineering team valuable time by providing a a set of conventions and functionality that can be easily built upon. Each framework pulls from different libraries and allows engineers different levels of flexibility, so make sure you’re familiar with the strengths and weaknesses of each.
Java’s legacy Spring framework has undergone a facelift with Spring Boot. Spring Boot, provides all the features of Spring but eliminates the boilerplate code and configuration that typically comes with developing legacy Spring web applications, so it’s a lot easier to use. Spring Boot and Spring Cloud were designed specifically for Java microservices, which makes them ideal for those transitioning from a monolithic architecture. Large organizations and start-ups alike will find Spring Boot easier to adopt because of its scalability and flexibility, especially when it comes to running complex code with multiple dependencies – Spring Boot’s dependency injector is especially helpful in that regard. Spring’s maturity and versatility make it ideal for organizations of any size, so it’s no surprise that Netflix has moved to Spring Boot for building microservices.
While it might not be as lightweight as other frameworks out there, Spring’s open source status, extensive documentation (especially when it comes to tutorials), and diehard community make it a competitive and versatile choice that continues to improve with time.
Micronaut was released in 2018, making it one of the newer available frameworks. It is incredibly lightweight and claims a quick startup time with a minimal memory footprint. There’s a relatively easy learning curve, as Micronaut is a polyglot framework that leverages familiar annotation tools. Micronaut embraces the cloud-native approach, making this a dynamic choice adopted by Minecraft, Target, and a number of other organizations.
Because Micronaut is less mature than other Java frameworks, your engineering team will need to do more work upfront than with a fully-loaded framework. If running your microservices in a serverless environment where startup time and spin-up time are important to you, though, it may be worth the extra legwork.
Dropwizard strikes the balance between Spring and Micronaut – it offers stability and maturity, while remaining relatively lean. Dropwizard has its own metrics library, offering out-of-the-box operational tools and application metrics that allow you to monitor your systems and perform health checks. This kind of readiness extends to config, logging, and much more – Dropwizard pulls from popular libraries like Jersey, Jackson, and Jetty, so your developers will have everything they need to hit the ground running.
Because Dropwizard so heartily embraces convention over configuration, your developers may feel more limited when working with this framework. For some teams and organizations, Dropwizard’s greatest strength, its simplicity, may be a weakness.
Play is a framework designed for building mobile and web apps, and is one of the most flexible, user-friendly options available. Like Dropwizard, Play takes the convention-over-configuration approach, but is non-opinionated, making it easier to work with from the start and giving your engineers more flexibility. Play has been around for 15 years, so it has a considerable ecosystem and active community of users, making it easy to find tutorials and troubleshooting help when you need it. It’s been adopted by organizations like LinkedIn, Verizon, Samsung, and iHeart Media.
Play is excellent for rapid development and testing, but its simplicity may be limiting to some engineers. Like Dropwizard, the speed and lightweight nature come at the cost of some resources, but it may be worth the price.
The Spark framework was designed specifically for the rapid development of web apps, and is primarily used to develop REST APIs, though a quarter of its users are creating websites and it supports other template engines. Spark bills itself as a micro framework, ideal by nature for building microservices – according to Spark, your API can serve JSON in less than ten lines of code with this framework. It aims for simplicity and while maintaining flexibility by engaging with the best of JVM without the verbose code.
Because it’s a micro framework, Spark is lightweight with a quick spin-up time, but that also means it may not be the best fit if you’re developing more substantial web services with complex code and multiple dependencies.
Eclipse Vert.x runs on JVM, and is the only member of this list that isn’t actually a framework – Vert.x is a modular toolkit ideal for microservice architecture and building reactive web apps. Because modules are totally independent, your engineering teams can decide which ones to use and which ones not to, giving them more freedom and flexibility.
Because Vert.x is so unopinionated, and isn’t actually a framework, it may be more difficult or tedious to work with than other options. It is incredibly fast and lightweight, though, so it may be worth any extra labor.
Considerations for selecting a framework
There are a number of other Java frameworks that work well for a microservice architecture – Struts, Grails, GWT, and Vaadin are some popular ones. Before you start experimenting with frameworks or decide to adopt one, you should take some time to evaluate what your needs are, and choose a framework accordingly.
Spin-up and memory footprint
Depending on how you’re constructing your microservice architecture, spin-up time and memory footprint may make a difference. Java comes with a significant memory footprint, especially compared to programming languages like Golang, but it also consumes less memory than Python.
If you’re using Kubernetes or a similar standard stack, spin-up time will be less of a concern because of rolling deployments, so you can opt for a more heavyweight option complete with all the features and tools. On the other hand, if you’re using AWS Lambda or a similar, event-driven platform, a lightweight framework with a faster spin-up time and greater scalability will be a better fit – this way, your application can continue to run smoothly as traffic increases.
As we’ve seen with frameworks like Spring (Spring Boot and Spring Cloud) and Dropwizard, JVM comes with robust monitoring capabilities, offering you valuable insight into your software, like memory consumption and server startup times. Spring Boot comes with production-ready features for auditing and metrics gathering, allowing you to implement health checks from the start.
Consider what monitoring tools are already at your disposal, and whether those provide enough of a look into the performance of your applications and team. If metrics are important to you, a framework with powerful, built-in monitoring capabilities will be a good fit.
Community and documentation
The size of a framework’s ecosystem is arguably the most important consideration. Well-established, open source frameworks like Spring and Play have significant and well-maintained ecosystems, complete with large libraries and considerable documentation. This allows for quicker adoption and standardization across and among teams.
Mature frameworks also tend to come with active communities, which has two primary benefits. Communities create resources and tutorials, and can provide creative solutions when troubleshooting, so you’re never really on your own. A framework with active users is also one that evolves by engaging with users’ needs, so you can trust that your framework will advance as best practices change.
Microservices with Cortex
It’s evident that programming with Java has a lot of advantages, and the considerable number of available frameworks mean there’s an option out there that will work well for your organization, especially organizations transitioning from a monolithic architecture.
No matter which framework you adopt, keep in mind that your tools are only as good as your team allows them to be. With a microservice architecture, teams tend to be more dispersed, so it’s crucial that you have systems in place to keep everyone on the same page.
With Cortex, you can bring your teams together by using Scorecards and creating a culture of accountability. You can set goals for your teams and track performance over time, and you can make sure that you’re getting the most out of whichever framework you choose.