Foreword
Businesses do not care about microservices, twelve-factor apps, or cloud native Java. They care about delivering business value to their customers, open and community-driven APIs, and runtime portability.
With a great developer experience comes increased productivity with “to the point” code—meaning high maintainability. The less code you have to write, the easier it is to spot bugs and implement new functionality. J2EE was designed as a “micro cloud” to host multiple, isolated applications. The EJB programming restrictions discouraged you from accessing the local filesystem, loading classes dynamically, or changing your isolated environment in any way. These formally unpopular, but now obligatory, programming restrictions are older than J2EE (EJBs came first) and are still a good idea today.
Java EE 5 greatly simplified the programming model, servers became leaner, and the transition from shared application servers to single microservice runtimes began. Between Java EE 5 and Java EE 8 the platform was extended with internet-related APIs for REST support, JSON, WebSockets, and asynchronous behavior out of the box. The build is as simple as the programming model is. All the Java EE APIs are bundled as a single, “provided” dependency in Maven’s pom.xml. Java EE/Jakarta EE is mature, stable, and therefore a genuinely boring runtime. Most Java EE APIs are iteratively refined for years, so expect no revolution. This is great news for businesses and pragmatic developers: demand for migrations is decreasing. The frequent Eclipse MicroProfile release cadence is quickly filling possible functionality gaps by delivering new APIs or extending existing ones on demand.
All popular runtimes are implementing Java EE/Jakarta EE and Eclipse MicroProfile APIs at the same time. You only have to download the Jakarta EE/MicroProfile runtime of your choice (a ZIP file), extract the archive, and define the Java EE/MicroProfile API as a “provided” dependency in Maven/Gradle (10 lines of code). In 10 minutes or less, the “Java Cloud Native Microservice Dream Team” is ready to deliver value to the customer with the very first iteration.
This book gives you a pragmatic introduction to cloud native Java, from the Java development kits and the open source ecosystem to a minimalistic coffee shop example. With MicroProfile and Jakarta EE, minimalism is the new best practice.
The Jakarta EE and Eclipse MicroProfile communities are significant new efforts that will be shaping the future of both Java and cloud computing for years to come. In particular, both of these communities are leading the industry in providing vendor-neutral specifications, coupled with multiple, liberally licensed, open source implementations for cloud native Java. In doing so, these two Eclipse Foundation-hosted communities are creating the safe choice in Java platforms for the new cloud-based systems being built today and tomorrow.
It is important to understand that Java remains a critically important technology in the cloud. Virtually all of the Fortune 1000 run significant portions of their business on Java. Just as importantly those same enterprises collectively have millions of developers with both knowledge of Java and of their businesses. The missions for Jakarta EE and MicroProfile are to provide paths forward for these enterprises and their developers as they rearchitect their applications to become cloud native.
Jakarta EE and MicroProfile represent two quite different paths to technological success. Jakarta EE is the successor to Java EE, the more than 20-year-old technology that laid the groundwork for Java’s enormous success in the enterprise. Java EE’s success was largely the result of careful evolutions of APIs and specifications, release-to-release compatibility that has lasted for years, and multi-vendor support and participation. MicroProfile only started in 2016 and is a demonstration of a truly open community’s ability to innovate quickly. With a cadence of three releases per year, MicroProfile has rapidly evolved to a complete set of specifications for building, deploying, and managing microservices in Java.
Eclipse community projects are always driven by great developers, and at the Eclipse Foundation the cloud native Java community has had many important contributors. I would like to recognize (in no particular order) the contributions of just a few: Bill Shannon, Dmitry Kornilov, Ed Bratt, Ivar Grimstad, David Blevins, Richard Monson-Haefel, Steve Millidge, Arjan Tijms, John Clingan, Scott Stark, Mark Little, Kevin Sutter, Ian Robinson, Emily Jiang, Markus Karg, James Roper, Mark Struberg, Wayne Beaton, and Tanja Obradović are but a few individuals who have been leaders among this community. My apologies in advance for forgetting someone from this list!
I have known, or known of, the authors for many years, and during that time they have been tireless champions of Java technologies. This book will hopefully raise the profile of Java’s important role in cloud native technologies, and lead to broader knowledge and adoption of the APIs, frameworks, technologies, and techniques which will keep Java relevant for this new generation of cloud-based systems and applications.