Reza Rahman

This is a hands-on workshop to introduce the Java EE 7 platform.

The main theme of Java EE 7 is boosting productivity and embracing HTML 5. The changes include APIs like JAX-RS 2, JMS 2, Java Batch, Java EE Concurrency, WebSocket, JSON-P and JSF 2.2. The workshop will introduce these changes in a step-by-step fashion using a realistic end-to-end application deployed on GlassFish 4 using NetBeans.

Although the primary focus will be on the new APIs and features, we will take a holistic approach to the workshop and also cover the features introduced in Java EE 5 and Java EE 6 such as the ones in EJB 3, CDI, JPA, Bean Validation and JSF focused on annotations, intelligent defaults, type-safe, powerful, fluent APIs.

At the end of the workshop, you will have a broad introduction to Java EE 7 and will be ready to write your own applications having already written quite a bit of code in the workshop.

Domain-Driven Design (DDD) promises to simplify enterprise application development and is gradually gaining traction as an alternative to traditional four-tier architectures originally popularized by J2EE. As the name implies, DDD is an architectural approach that strongly focuses on materializing the business domain in software. This session demonstrates first-hand how DDD can be implemented using Java EE via a project named Cargo Tracker.

Part of the Java EE Blue Prints, Cargo Tracker seamlessly maps concepts like bounded contexts, layered architectures, entities, value objects, aggregates, services, repositories and factories to realistic code examples. The Cargo Tracker project also embraces popular practices adopted by the DDD community such as Object Oriented Analysis, Domain Models, Test Driven Development, Agile Refactoring, Continuous Integration, Object Relational Mapping, Dependency Injection and Cross-Cutting Concerns, incorporating these concepts into a realistic Java EE application.

This workshop is your opportunity to hack some code using the much anticipated JMS 2 API in cool TDD style :-).

JMS 2 (JSR 343) is the first update in more than a decade for the widely used Java messaging standard and is easily the longest-awaited component of Java EE 7. The biggest new feature of JMS 2 is a powerful new API that makes JMS a lot easier to use, especially in a Java EE application. JMS 2 also includes some additional messaging features and a long list of more minor enhancements.

With JMS 2 final along with Java EE 7 now is an ideal time to find out more about it first hand by getting introduced to the basics and writing some unit tests covering the major changes in JMS on the fly!

Microservices seems to have become the new kid of the buzzword block in our ever colorful industry. In this session we will explore what microservices really within the relatively well established context of distributed computing/SOA, when they make sense and how to develop them using the lightweight, simple, productive Java EE programming model.

We'll explore microservices using a simple but representative example using Java EE. You'll see how the Java EE programming model and APIs like JAX-RS, WebSocket, JSON-P, Bean Validation, CDI, JPA, EJB 3, JMS 2 and JTA aligns with the concept of microservices.

It may or may not surprise you to learn in the end that you already know more about microservices than you realize and that it is an architectural style that does not really require you to learn an entirely new toolset beyond the ones you already have. You might even see that Java EE is a particularly powerful and elegant toolset for developing microservices.

With a strong focus on annotations, minimalist configuration, intelligent defaults and Java centric type-safety, Java EE is one of the most productive full-stack development platforms around today. This very code centric workshop is a quick tour of the Java EE platform as it stands today. If you haven't seen Java EE for a while and want to catch up, this session is definitely for you.

We will start with the basic principals of what Java EE is and what it is not, overview the platform at a high level and then dive into each key API like JSF, CDI, EJB 3, JPA, JAX-RS, WebSocket and JMS. This is your chance to look at Java EE 7 in the context of a realistic application named Cargo Tracker, available with an MIT license at http://cargotracker.java.net.

We will also briefly take a look at the emerging horizons of Java EE 8.

HTTP is very easily the most important standard in server-side Java. The much awaited HTTP 2 standard is now complete, was fifteen years in the making and promises to radically speed up the entire web through a series of fundamental protocol optimizations.

In this session we will take a detailed look at the changes in HTTP 2 and discuss how it may change the Java EE ecosystem including the foundational Servlet 4 specification slated to be included in Java EE 8.

Bring your thinking caps!

For anyone familiar with the Java language but without direct Java EE experience, the capabilities and APIs in Java EE can be a serious transition. Documentation is helpful, and well-written books can make it easier to come up to speed, but isn’t the best way to learn something to actually do it? This lab hopes to smooth the path for anyone curious about Java EE by offering a gentle, yet useful, introduction to four key concepts in the platform: JSF, CDI, JPA and EJB 3.

Using NetBeans and the bundled GlassFish application server, we will explore each new concept with live code and then complete some hands-on exercises.

The sea change in HTML 5 is likely to shift the pendulum away from today's thin-client based server-side web frameworks like Struts 2 and JSF to JavaScript powered next generation rich clients. With strong support for REST, WebSocket and JSON, Java EE 7 is well positioned to adapt to this change.

In this heavily code driven session, we will show you how you can utilize today's most popular JavaScript rich client technologies like AngularJS, Backbone, Knockout and Ember to utilize the core strengths of Java EE using JAX-RS, JSR 356/WebSocket, JSON-P, CDI and Bean Validation.

Java SE 8 brings a bounty of improvements - Lambda Expressions, the new Date Time API, Completable Futures, streams and the fork/join common pool. In this code intensive session we will explore how these Java SE 8 features can be utilized inside Java EE 7 applications with APIs such as Servlet, JAX-RS, WebSocket, CDI, EJB 3, JPA, JMS and Java EE Concurrency Utilities.

We will also explore how Java SE 8 features could be effectively incorporated into Java EE 8 and beyond.

Java EE 7 is around the corner and the horizons for Java EE 8 are emerging. This session looks into the key changes the community can expect. The goal of this session is to foster interest and discussion around these changes.

Some of the changes discussed include retiring EJB 2 entity beans and JAX-RPC, greater alignment with CDI, WebSocket/HTML 5 support, a standard API for JSON processing, the next version of JAX-RS, an overhaul of JMS, long-awaited concurrency utilities, batch processing in Java EE and much, much more.

The Java Community Process (JCP) plays a critical role in Java by developing the Java SE and Java EE specifications. Unfortunately most developers have very little understanding about how the JCP works let alone how they can contribute to it. In fact there are numerous misconceptions about the JCP.

This session takes an in-depth look into the JCP including its purpose, structure, governance, operations as well as how you can participate, observe or comment on the development of Java industry standards as an individual, company or JUG.

We will also discuss an innovative new program named Adopt-a-JSR and major initiatives such as Java EE 8.

This session explores how NoSQL solutions like MongoDB, Cassandra, Neo4j, HBase and CouchDB can be used in a Java EE application with or without a JPA centric facade.

Although the primary focus is on EclipseLink NoSQL, we will also cover Hibernate OGM, EasyCassandra, Morphia, etc as well as seeing how NoSQL can be used natively via basic CDI injection.

As our industry matures there is an increasing demand for high-throughput, low-latency systems heavily utilizing event-driven programming and asynchronous processing. This trend is rapidly converging on the somewhat well established but so-far not well understood term “Reactive”.

This session explores how Java EE as a whole aligns with this movement via features and APIs like JMS, MDB, EJB @Asynchronous, JAX-RS/Servlet/WebSocket async, CDI events, Java EE concurrency utilities and so on.

We will also see how these robust facilities can be made digestible even in the most complex cases for mere mortal developers through Java SE 8 Lambdas and Completable Futures.

This session outlines how to effectively test Java EE APIs like JSF, Servlet, CDI, EJB 3, JPA, WebSocket and JAX-RS. Java EE includes a number of new features that enhance testability like generic dependency injection, CDI @Alternative, portable extensions, embedded containers and JSF project stages. Using these features and best of breed tools like JUnit and Arquillian it is possible to perform unit, integration, system and functional testing for Java EE APIs at all layers of the application.

In addition to discussing tools and features, the session will also demonstrate testing techniques like designing for testability, mock objects, isolation and test configuration.

Words like standard, de-facto, de-jure and open are commonly traded around like cheap coins in our industry, ironically sometimes as a tool for overt or covert standards bashing. The reality is that few people really understand what these words actually mean or how these ideas effect their own professional lives in the long and short term.

This session will aim to clear the air on some of these terms and outline why open standards like Java and Java EE are critically important to you today and in the future. We will explore these concepts in the context of well-established economic theories on competition, monopoly power, the network effect, innovation, open source and open standards.

We will also discuss what being an open standard really means as well as why and how you should contribute to them yourself.