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.

Wednesday Mar 20, 2013

A Gentle Introduction to JMS 2

My well-respected colleague and good friend Arun Gupta continues his admirable effort to provide some very early coverage of Java EE 7 features. I thought I'd highlight his blog entry on the core of the JMS 2 API written in this vein.

The primary goal of JMS 2 is to modernize the extremely widely used but very dated JMS API. The core of these changes is the aptly named simplified API founded upon injectable JMS contexts. The JMS context essentially represents the JMS API reimagined (without any feature loss) using up-to-date API design constructs like dependency injection, automatic life-cycle management, annotations, the builder pattern, unchecked exceptions and intelligent defaults.

In his blog entry, Arun does a good job of explaining the basic concepts of the JMS context. He explains through downloadable code examples sending and receiving messages in the brave new world of JMS 2. He also shows the very powerful capability of defining JMS resources inside your application through annotations. The blog entry is a great starting point for beginning to explore the changes in JMS 2.

Friday Mar 15, 2013

AutoCloseable JMS 2 Resources

As the Java EE 7 release date draws closer, blogs and articles covering the new features are beginning to roll in. In a brief blog entry, John Ament, a key independent member of the JMS 2 expert group talks about AutoCloseable JMS 2 Resources. This feature takes advantage of Java SE 7 try-with-resources to significantly simplify the cleanup of JMS resources such as connections, sessions, message consumers and message producers. This is particularly important in non-Java EE environments where you are not using the new JMSContext API via @Inject. The blog entry includes downloadable JMS 2 code samples. John expects to write many more blog entries covering JMS 2, so stay tuned.

For those unaware, JMS 2 is now in the proposed final draft stage. Feel free to download the draft and take a look at it yourself. There is a very handly What is new in JMS 2.0? section towards the beginning of the document.

Monday Jan 14, 2013

Java EE 7 in Public Review!

Java EE 7 has turned the last lap and is racing towards the finish line! The Java EE 7 JSR itself (JSR 342) very recently published it's official Public Review Draft. The review closes on February 11th so act fast, read the draft spec and send your feedback. The draft is available here. After the review is over, the JSR will go to the EC ballot.

And Java EE 7 is not the only one. As this JSR update from the JCP indicates, the review periods for JMS 2, Java EE Concurrency, WebSocket, JPA 2.1 and JSON-P are still open but will be coming to an end rapidly in the next few weeks.

Thursday Jan 03, 2013

JMS 2 Public Review Draft Published

JMS 2 is arguably one of the most important parts of Java EE 7. The JMS 2 EG officially published it's Public Review Draft today. Characteristic to the great work JMS 2 spec lead Nigel Deakin always seems to pull off, he created a pretty detailed page for the Public Review Draft on the Java.net project for JMS 2.

Nigel invites you to read the draft/Javadocs, download the reference implementation (standalone or with GlassFish), take the JMS 2 example code for a spin and send either him or the EG your feedback. The page also neatly summarizes the actual changes in JMS 2. The formal review period began on January 3rd and ends on February 4th, so act now!

Sunday Apr 15, 2012

Configuring JMS and Message Queues in GlassFish - Sample Chapter

PacktPub released Java EE 6 with GlassFish 3 Application Server a few months after the first version in GlassFish 3 train was released.

This book is a practical guide to install and configure the GlassFish 3 Application Server and develop and deploy Java EE 6 applications on this server. Recently they released a sample chapter on how to configure JMS and message queues in GlassFish. The chapter provide complete snapshots from the web-based admin console and working sample code.

Java EE 6 with GlassFish 3 Application Server Book

The Table of Contents shows that all major Java EE 6 APIs and the details of the GlassFish 3 server are covered followed by examples of its use. This book is a practical guide with a very user-friendly approach.

Read about other books on Java EE and GlassFish here.