Eclipse MicroProfile: Accelerating Cloud-Native Application Development with Java Microservices
5 min read
Leverage your existing enterprise Java skills for faster microservices app development with Eclipse MicroProfile
The Eclipse MicroProfile project is proud to announce the availability of their eBook, Eclipse MicroProfile: Accelerating Cloud-Native Application Development with Java Microservices. MicroProfilers have produced many presentations, blogs, and guides to help explain how to use the MicroProfile programming model for developing microservices.
Sometimes, however, the information needs to be raised up a level or two to help discuss this topic with the larger organization. That’s the point of this eBook—to facilitate the MicroProfile conversation:
To facilitate presenting the benefits of MicroProfile to a larger team, check out these charts:
MicroProfile supports the microservices architecture programming model
Microservices development is different from monolithic application development. If you have read or studied the Twelve-Factor App, you’ll understand that writing a service has a different set of requirements. A microservice is more self-contained and self-reliant. It has to be able to stand alone with no shared dependencies, no shared resources, no shared administration, and no shared configuration. That type of mindset requires a different line of thinking when developing your applications.
That does require some new ways of doing things and, thus, some extensions to the current, well-known programming models. Many organizations have a huge investment in Java EE™. They have spent countless resources on the development of Java EE-based applications for close to 20 years. All of that knowledge and experience does not have to be thrown out the window just because you are now looking to invest in microservices development.
Jakarta EE is the new home for Java EE™ development
Most of you know that Jakarta EE is the new home for Java EE™ development. In late 2017, Oracle announced that they would be moving future Java EE development to the Eclipse Foundation. That migration has made great strides in 2018, with the release of a Java EE 8-compliant Eclipse Glassfish 5.1 nearing completion. Any references to Java EE in this blog post imply future references to Jakarta EE.
From day one, the Eclipse MicroProfile project has been promoted as complementary to Java EE. It builds upon the solid foundation laid out by some of the Java EE technologies. Even the first MicroProfile 1.0 release only consisted of three Java EE 7 features: CDI (Contexts and Dependency Injection), JAX-RS (Java API for RESTful Web Services), and JSON-P (Java API for JSON Processing).
Subsequent MicroProfile releases have added the components to more fully support microservices development—capabilities such as resilient fault tolerance, configuration isolated from the application, tracing that spans multiple microservices, and an easy mechanism to document your microservice APIs, to name a few. Even while adding all of this new functionality, MicroProfile has stayed true to its origins and now supports both Java EE 7 and Java EE 8 environments.
MicroProfile extends the Java EE programming model
Just because MicroProfile states support for Java EE 7 and/or Java EE 8, this does not mean that all of the Java EE features are required in your microservices application. MicroProfile has been very prudent in its selection of the core Java EE technologies. MicroProfile has relied on CDI, JAX-RS, JSON-P, and most recently JSON-B (Java API for JSON Binding) to provide a solid base.
But, what about frontend user interfaces or backend resources? Aren’t those commonly required for microservices? Sure, but they don’t have to be defined as part of the MicroProfile programming model. For example, microservices could use any type of database for retrieving or persisting data—relational database (JDBC or JPA), NoSQL database, distributed cache, or even legacy systems such as CICS. MicroProfile is allowing freedom of choice instead of locking into one particular mechanism.
This is why we emphasize that MicroProfile extends the Java EE programming model. Although MicroProfile provides a fully-functional programming model for developing microservices, there may be additional capabilities that are provided by Java EE or other programming models. Many of the vendors that provide MicroProfile-compatible implementations also support this “fit for purpose” model and only the required features are configured for any given application. So, instead of bringing in all of Java EE like the old legacy application servers, only the required pieces of Java EE are brought into the final configuration.
Hopefully, this blog post has piqued your interest in microservices development and, specifically, how MicroProfile can complement your existing Enterprise Java skill base. To learn more about how MicroProfile can benefit your business case surrounding microservices, I welcome you to dive into more details by referencing either the ebook or chart version of Eclipse MicroProfile: Accelerating Cloud-Native Application Development with Java Microservices.
For a hands-on tutorial, check out the Open Liberty guides that cover creating RESTful microservices APIs and running Java MicroProfile apps on Docker.