Tuesday Mar 24, 2015

JMS 2.0 Revision A

The JMS 2.0 errata has passed the JCP executive committee ballot approval! This simple maintenance release was necessary to correct a few errors in the original JMS 2.0 specification. And now that ‘JMS 2.0 Revision A’ is done and approved, the focus is shifting towards the next version of the JMS specification, i.e. JMS 2.1.

Resources :

Monday Feb 23, 2015

Rakuten: Java EE Adoption in One of the World’s Largest Online Financial Systems

One of the most important things to do at this stage of the life-cycle of Java EE is highlight successful adoption stories. We have been doing just that for a long time through our adoption stories blog as well as JavaOne. JavaOne 2014 was particularly good in this regard and JavaOne 2015 looks to be even better. Indeed we hope the folks with great adoption stories that submitted last year but did not get accepted will resubmit next year. We will highlight some of those sessions from JavaOne 2014 in the next few months and the best place to start is the Java EE adoption story from Rakuten.

Rakuten is one of the largest online financial systems in the world. It is the number one e-commerce platform in Japan generating over 51 billion dollars of yearly revenue and growing on a global scale. It is easily one of the most technically adept companies in Japan and perhaps the world. They had a legacy system build around J2EE and a hodgepodge of various non-standard frameworks such as Spring, Apache Axis and iBatis. They chose to adopt Java EE over these technologies including alternatives such as .NET. They cited vendor neutrality, choice, simplicity, community, ease-of-learning, ease-of-use and productivity as great reasons for selecting Java EE for their next generation platform. They fully leverage Java EE including key APIs such as JSF, CDI, EJB, JPA, JTA and JMS. Along with Java EE they also chose WebLogic as well as Oracle DB/Exadata. They cited performance, scalability, reliability, productivity and support for choosing WebLogic, Oracle DB and Exadata. They also use best-of-breed tools such as NetBeans, Maven, Jenkins and the Atlassian suite of solutions. They achieved the astounding technical feat of completely overhauling their 24/7, extremely high volume online transactional system in just six months including training!

You can see Hirofumi Iwasaki and Arshal Ameen's awesome JavaOne 2014 presentation below (if you are having trouble seeing the embedded video it is available here).

The slide deck from the talk is posted below (if you are having trouble seeing the embedded slideshow it is available here).

Hirofumi Iwasaki and Arshal Ameen have been great advocates of Java EE, especially in Japan. We hope to continue to see great things from them and Rakuten. Rakuten is looking forward to learning and applying Java EE 7 in the real world as soon as possible.

If you have a great Java EE adoption story to share, please do drop us a note (particularly migration stories from other technologies). In the spirit of Java EE centric vendor neutrality, what Java EE implementation or tool set you choose does not matter at all and neither does which part of the globe you are in.

Tuesday Jan 27, 2015

JMS 2.0 Errata - Public Review has now started!

As announced a few weeks ago, the JMS 2.0 specification (JSR 343) is going through a simple update process, i.e. an errata update. An errata is a simple kind of maintenance release intended purely to correct errors in the specification. The draft of this effort has just been published by the JCP (see Change Log and Issue List here) for a formal maintenance review period that will close on February 21st. That means that you have a little bit more than 3 weeks to submit your comments (see here). After that, the JMS 2.0 errata will go the JCP executive committee for ballot approval. Once 'JMS 2.0 Rev. A' is approved, the actual (and technical) work on JMS 2.1 (JSR 386) will start.

Thursday Jan 15, 2015

JavaOne Replay: 'JMS 2.0 Best Practices in 50 Minutes'

'50 xxx Best Practices (or Tricks) in 50 minutes' is a trendy thing in conferences (*). As the title suggest, the idea is simple: cover a lot of technical tips in a given timeframe. This is an interesting format for attendees as if you are new to the presented subject; you will high likely learn a lot of things.  And if you are already familiar with the topic, chances are high that you will also learn a few tricks here and there.  It is however a difficult exercise for the person delivering the session as there is a lot of technical content to deliver in a well-defined (and relatively short) time frame. And if the speaker got distracted by anything (e.g. beamer issue, long question), it will be very difficult to recoup the lost time.

Anyway, Nigel Deakin (JMS Specification Lead) did this challenging exercise during last JavaOne. By having attended Nigel's 'JMS 2.0 Best Practices in 50 Minutes' session, I can say that this was a very good (and technical) session on JMS! The content should be useful for JMS newcomer but also for people with good JMS knowledge. You can watch the replay below and download the slides here.

(*) That also work with '45' and '55' but nobody ever dared to try with '42'! 

Tuesday Jul 08, 2014

It's time to begin JMS 2.1!

Nigel Deakin has just posted a draft proposal for JMS 2.1. Nigel is the Maintenance Lead for JMS 2.0 and is the prospective Specification Lead for JMS 2.1.  He plans to submit his proposal to the JCP soon and is looking for feedback and comments before he do so.  JMS 2.1 is one of the potential APIs for inclusion in Java EE 8. 

The proposed improvements for JMS 2.1 are :
  • Continue the 'ease-of-use' efforts that were started in JMS 2.0
  • Improve the portability of JMS providers within Java EE servers
  • Enhance the JMS API to leverage some of the Java SE 8 features (eg. repeatable annotations)
  • Clarify some of the optional aspects of the specification 
  • Improve and clarify some of the transactional behaviours
  • Additional features as decided by the Expert Group ...

On the  'ease-of-use' front, one of the big feature that Nigel would like to have addressed by the Expert Group is the definition of an easier-to-use and more general alternative to JMS message-driven beans (MDB). But you should really read Nigel's draft proposal for a more complete description of the JMS 2.1 plans.

You can send your feedback via the usual channels. At JavaOne, the following 2 BoFs will also be a good venue to discuss the JMS 2.1 plans: "What Do We Want in JMS 2.1?" and "Meet the Java EE Specification Leads".

Finally, make sure to follow @jms_spec on Twitter to get the latest news on this important API!

Thursday Jun 19, 2014

JMS over WebSocket

Any application server which conforms to the Java EE Full Profile needs to include a messaging provider which supports the JMS API. Open Message Queue (aka Open MQ), the world first JMS 2.0 compliant MOM (Message Oriented Middleware), is the JMS provider for GlassFish. As GlassFish, Open MQ is open source too. Currently, GlassFish 4.0 is using Open MQ 5.0. In GlassFish 4.0.1, we plan to move to Open MQ 5.0.1. The 5.0.1 release comes with a set of fixed issues (see here) but also introduces new features such as WebSocket and STOMP support. 

The JMS specification is a messaging API and as such, it doesn't define the protocol to use on the wire. It is up to the JMS implementer to decide how to handle this. Open MQ supports socket TCP connections, it also supports HTTP/S tunnelling to make JMS messages easily flows through firewalls (See Annex C of the Open Message Queue Administration Guide).

With Open MQ 5.0.1, it is now possible to use WebSocket as the communication protocol between a client and an Open MQ JMS broker. Under the hood, Open MQ uses Grizzly and Tyrus.

A Java client will continue to use the JMS API so this is transparent. The only thing you have to take care is to specify, in your connection factory, the WebSocket URL of the Open MQ JMS Broker (imqAddressList=mqws://<broker-host>:<broker-ws-port>/<ws-service-name>). 

In addition, Open MQ 5.0.1 introduces 2 additional types of WebSocket clients, i.e. 'non JMS' clients that can be used to exchange messages with applications that do use JMS : 

  • mqstomp : Any (WebSocket) client that support STOMP 1.2 protocol
  • mqjsonstomp : Any (WebSocket) client that can sends JSON formatted STOMP 1.2 protocol
Those new types of clients are particularly interesting as they open the space for new scenarios (e.g.. simple JavaScript clients). The only thing the client need to have, in order to exchange messages with JMS applications, is STOMP and WebSocket support.

To find out more about this, you can check the 'JMS and WebSocket for Lightweight and Efficient Messaging' session that was presented during last JavaOne. You can also download and try Open MQ 5.0.1 today.

Tuesday Dec 10, 2013

Want to work on JMS? We are hiring!

The Oracle Java Messaging Group is looking for a talent to help build enterprise-class standards-compliant messaging infrastructure (such as WebLogic JMS) and engineered messaging implementations. This job position is based either in Santa Clara, CA or Liberty Corner, NJ.

If you are interested, check out this job posting for more details.

Tuesday Jul 16, 2013

What's New in JMS 2 - Part 2

JMS 2 is one of the most significant parts of Java EE 7. Clearly, the principal goal of JMS 2 is to streamline and modernize the API by adopting programming paradigms like higher level abstractions, dependency injection, annotations, runtime exceptions, the builder pattern and intelligent defaults. However, a limited number of important new features were also added to JMS 2. In a recent OTN article, JMS 2 specification lead Nigel Deakin covers the new features such as shared subscriptions, delivery delays, asynchronous sends and delivery counts in detail. The article is the second of a two part series on JMS 2. For more visual folks, there is also Nigel's brief 15 minute video on JMS 2 on the YouTube GlassFish videos channel as well as is my JMS 2 slide deck below:

You can also check out the official specification yourself or try things out with the newly released Java EE 7 SDK.

Wednesday Jun 26, 2013

What's New in JMS 2 - Part 1

JMS 2 is one of the most significant parts of Java EE 7. One of the principal goals of the JMS 2 API is improving developer productivity by reducing the amount of code to work with JMS by adopting programming paradigms like higher level abstractions, dependency injection, annotations, runtime exceptions, the builder pattern and intelligent defaults. In a recent OTN article, JMS 2 specification lead Nigel Deakin covers the ease-of-use changes in detail. The article is the first of a two part series on JMS 2. For more visual folks, there is my JMS 2 slide deck:

You can also check out the official specification yourself or try things out with the newly released Java EE 7 SDK.

Friday Jun 21, 2013

JAX-RS 2.0, JTA 1.1, JMS 2.0 Replay: Java EE 7 Launch Webinar Technical Breakouts on YouTube

As stated previously (here) (here), the On-Demand Replay of Java EE 7 Launch Webinar is already available. You can watch the entire Strategy and Technical Keynote there, and all other Technical Breakout sessions as well.

We are releasing the next set of Technical Breakout sessions on GlassFishVideos YouTube channel as well. In this series, we are releasing JAX-RS 2.0, JTA 1.1, and JMS 2.0.

Here's the JAX-RS 2.0 session:

Here's the JTA 1.1 session:

Here's the JMS 2.0 session:

Enjoy watching them over the next few days before we release the next set of videos!

And don't forget to download Java EE 7 SDK and try numerous bundled samples.

Tuesday May 28, 2013

Nigel Deakin on JMS 2

The 131st episode of the Java Spotlight podcast features an interview with JMS 2 specification lead Nigel Deakin. JMS 2 is one of the key parts of the Java EE 7 platform and a long awaited update to the very popular API. Nigel talks with Roger Brinkley about the motivation for the JSR, the simplified API, the new features, MDB alignment, portable JMS resource definitions in Java EE 7, current status of the JSR as well as what's in the future.

You can listen to the full podcast here. It's really a great starting point for learning about JMS 2. You can certainly give the official specification a read yourself (the API recently had it's final release). At a hundred and fifty some pages, it is not too bad of a read and Nigel does a great job of summarizing the changes towards the beginning of the document in the section titled What is new in JMS 2.0?. You can also try the API out with a GlassFish promoted build.

Thursday May 16, 2013

10 Ways JMS 2 == Less Code

JMS 2 is one of the most significant parts of Java EE 7. One of the principal goals of the JMS 2 API is improving developer productivity by reducing the amount of code to work with JMS by adopting programming paradigms like higher level abstractions, dependency injection, annotations, runtime exceptions, the builder pattern and intelligent defaults. In a brief write-up JMS 2 specification lead Nigel Deakin highlights these changes by demonstrating ten concrete ways the JMS 2 API means less code as compared with JMS 1.1.

JMS 2 recently passed it's final approval ballot. You could check out the proposed final draft yourself. At 150 some pages, it is a pretty digestible specification. You can also try the API out with a GlassFish promoted build.

Friday May 10, 2013

Java EE@JavaOne Russia 2013

JavaOne Russia 2013 was held at the Crocus Expo Center in Moscow on April 23-24. The conference was a resounding success with a great vibe, excellent technical content and numerous world class speakers. Some notable speakers included Werner Keil, Joonas Lehtinen, Heather VanCura, Paul Bakker, Bert Ertman, Talip Ozturk, Anil Gaur, Geertjan Wielenga, Arun Gupta, Jim Weaver, Stephen Chin and David Delabassee. Topics covered included the JCP/JUGs, Java SE 8, Java EE 7, HTML 5/WebSocket, JSF, JMS 2, JAX-RS 2, Java EE Concurrency, JBatch, JSON-P, NetBeans, MySQL, Vaadin, the Oracle Java Cloud, OpenShift, OSGi, JavaFX and Coherence.



I delivered the Java EE technical keynote, two technical sessions (one on JSM 2 and the other on JAX-RS 2) and three lighting talks (on Java EE Concurrency, JBatch and JSON-P). I also helped deliver two hands-on-labs (on Java EE 7 and the Java Cloud Service). More details on the sessions and JavaOne Russia 2013, including the slide decks and code, posted on my personal blog.

Monday May 06, 2013

Integrating WebSockets and JMS with CDI Events in Java EE 7

One of the first things you will want to know about Java EE 7, is how you can integrate some of the new APIs like WebSockets, with existing ones like JMS. That's why I decided to write this article "Integrating WebSockets and JMS with CDI Events in Java EE 7". What I try to demonstrate here, is how two distinct APIs can be used together to deliver something that is not explicitely defined in the specifications, but with some cool integration using CDI Events, an async server-side data push can be implemented with no more than the standards at your hand.

The article will show you how to code your first WebSocket server endpoint, then how by using a Stateless SessionBean you can send messages to a JMS Queue, and finally, how to receive them again by using a MessageDriven Bean that fires CDI events with the payload back to the WebSocket. Simple, straightforward and small code, that takes you through several specifications and releases available starting from now, the Productivity++ Java EE 7.

Tuesday Apr 09, 2013

JMS 2, Bean Validation 1.1, JBatch, JSON-P Go Final!

Java EE 7 is almost to the finish line! The first slew of Java EE 7 JSRs have successfully passed their Final Approval Ballots and are now final. JMS 2 (JSR 343), Bean Validation 1.1 (JSR 349), JBatch (JSR 352), and JSON-P (JSR 353) all passed with near unanimous support from the JCP Executive Committee. Please join me in congratulating spec leads Nigel Deakin of Oracle, Emmanuel Bernard of Red Hat, Chris Vignola of IBM, and Jitendra Kotamraju of Oracle on the fruition of all their hard, often thankless work.

We expect more Java EE 7 JSRs to follow suit shortly, so stay tuned. This is a great time to read the final specs and start experimenting with them in the GlassFish 4 builds.