This morning, I was asked a question by a coworker that we both thought we knew
the answer to: if a method is
protected, can other classes see that method? The
answer surprised us: maybe. :) It’s a pretty simple, basic question, but I thought
I’d mention it in case there’s a beginner wondering, or more senior developers, such
as myself and my team mate, that just have it wrong. :)
Many times, one of the hardest parts of getting started with a particular piece of technology is figuring out how to get started. :) In this series, I’ve used an extremely simple project to show how to do just that with a number of MicroProfile implementations. Obviously, a real application will have many more concerns than we dealt with in this application, but what this effort gave us is working, runnable, and testable build for six different MicroProfile implementations. What I’d like to do in this final installment in the series, is give some closing thoughts.
Up next in our series comes an offering from, to me, a somewhat surprising source, Oracle, and that offering is Helidon. I first heard about in September 2018, and while it’s still pre-1.0, it looks extremely promising.
This time around, we’re going to start looking at a slightly different take on MicroProfile implemenations. Whereas Payara Micro, Thorntail, OpenLibery, and TomEE are all based on application servers (albeit stripped down versions), our implementation in this post, Hammock, is based on a CDI container. Rather than start what amounts to an app server under which a web is deployed, we’ll be spinning up a plain ol' CDI container, which will look for CDI beans to load/start/etc. That may sound weird, and I may not be describing it clearly, so let’s just jump in to the code and take a look.
In this installment of our series, we’re going to take a look at the last of what I think of as the more traditional, app-server-based/-spawned implementations, TomEE. TomEE is a fully Java EE-enabled distribution of the venerable workhorse Tomcat, and comes with support for creating MicroProfile applications, so let’s see what that looks like.
Having looked at Thorntail last time, we’ll take a look at OpenLiberty this time. OpenLiberty is the open source project under which, as I understand the state of things, IBM’s WebSphere Liberty is developed. In this installment, we’ll give its MicroProfile support a quick spin.
In the last installment, we talked about Payara Micro. In this, we’re going to look at Thorntail. Thorntail, née Wildfly Swarm, is based on Wildfly from Red Hat and is said to be "just enough app-server". Much like Payara Micro, Thorntail exposes a battle-tested application server platform, stripped down for microservices usage. Let’s a take a look at what it takes to deploy our application on Thorntail.
Payara Micro is a MicroProfile implementation from the good folks at Payara, based on Payara Server, which is itself based on GlassFish. Whew! If you’re familiar with either GlassFish or Payara, you should feel right at home with Payara Micro.
To start our investigation, we need an application to work with. Part of the problem with getting started applications is making sure that your example is complicated enough to be interesting, but not so complicated that the greater message is lost in the details of the app. MicroProfile 2.0 is made up of a number of components:
MicroProfile Config 1.3
MicroProfile Fault Tolerance 1.1
MicroProfile Health Check 1.0
MicroProfile JWT Authentication 1.1
MicroProfile Metrics 1.1
MicroProfile OpenAPI 1.0
MicroProfile OpenTracing 1.1
MicroProfile Rest Client 1.1
Common Annotations 1.3
To include all of those in this would probably be a bit too much technical weight for a getting started effort, so, for this example, I’ve leaned (probably too far) toward simple. Our application will have a single JAX-RS resource, into which is injected a single CDI bean. The point is to have a working REST endpoint, with an inject "service layer", to show a MicroProfile in action, allowing us to verify that our basic environment is configured and working correctly. From there you are free to load on all the complexity you find you need. That’s exactly what I’ll be doing in a separate project. :)
The Eclipse MicroProfile is a community-driven profile initially developed by Red Hat, IBM, TomiTribe, Payara and the London Java Community (LJC). Launched in 2016, it was intended to sit alongside Java EE’s Web and Full profiles, offering Java EE developers a smaller, lighter set of standards with which they could build microservices. Today, MicroProfile lives as an Eclipse project, and is being supported and actively developed by its creators as well as many more, including both corporations and individuals, giving us an embarassment of riches, if you will, when it comes to implementations.
By my count, there are at least 6 implementations from which to choose, leading to the question: Which one do I choose? While there are many aspects that factor in to such a decision, it is not my intent here to answer those questions. Rather, what I’d like to do is provided some small "getting started" projects to help you kick off your own investigation. With that in mind, here are the implementations (in no particular order) that we’re going to look at:
In Part 1, we’ll cover the (admittedly absurdly basic) application, and in subsequent parts, we’ll see what it takes to deploy that application using each of these MicroProfile implementations.
- Tips for Writing Pluggable Java EE Applications
- JSFTemplating and Woodstock: Component Authoring Made Easy
- Jason Lee in depth: Mojarra and Scales
- Jason Lee: Postmortem for JavaOne 2008
- International Environmental: A Cooling Company Which Prefers Hot Software
- IEC donates custom JSF component to Mojarra Scales