A hands-on practical guide disclosing all areas of Enterprise development , covering details about Jakarta EE with lots of examples to be run on either the newest WildFly application server or on Thorntail environment.
The first part of the book covers everything from the foundation components (EJB, Servlets, CDI, JPA) to the new technology stack defined in Java Enterprise Edition (now Jakarta EE 8), including the new Batch API, JSON-P Api, the Concurrency API,Web Sockets, the JMS 2.0 API, the core Web services stack (JAX-WS, JAX-RS). The testing area with Arquillian framework and the Security API is also fully covered in this part.
The second part of the book discusses how to integrate the Jakarta Enterprise API wiith the Microprofile specification, to provide essential services to develop robust microservices such as the Configuration API, the Health API, the Fault tolerance API, the OpenAPI and Tracing API, the Metrics API, JWT Authentication API and REST Client API.
Finally, the third part of the book covers how to build Microservices using Thorntail fractions for both Enterprise API and Microprofile API
What you will learn from this book:
- Everything you need to know about Java EE, Jakarta EE 8 and MicroProfile API
- How to set up your development environment to build Enterprise applications and Microservices on the top of WildFly or using Thorntail.
- How to use Maven plugin to simplify your project scaffolding
- Learning the foundation components that constitute the backbone of your applications: EJB, CDI 2.0, JPA, JAX-RS, JAX-WS
- Learn how to build loosely coupled applications using the straightforward JMS 2.0 API
- Learn how to test your applications with Arquillian in a managed environment, remote environment and even on the cloud!
- Discover how to develop Concurrent and Compliant Java EE applications using the Concurrency API and how to define Batch Jobs using WildFly’s implementation of JSR
- Secure all kind of applications (Web/EJB) with standard and custom login modules. How to encrypt the communication of EJB applications and Web applications.
- How to enhance your Jakarta EE stack with Microprofile API to build robust Microservices
- How to turn Jakarta EE applications into Thorntail Microservices
Part I: Developing Jakarta EE applications on WildFly
Getting started with WildFly covers the installation of the server platform and introduces the Java EE 8 platform most significant changes. You will learn as well how to install the tools required for developing applications
Getting ready for development discusses the basic steps for configuring the foundation of your Maven projects using the available WildFly archetypes.
Programming Servlet is a first access to application development using the long-lived Servlet API. The chapter spans from the basics to the new Java EE 7 non-blocking I/O feature and Java EE 8 new Servlet Push.
Developing Enterprise Java Beans, is about developing applications using the available EJB types, thus including the basic Stateless and Stateful beans, and the other variants (EJB Timers and Singleton EJB).
Context Dependency Injection discusses about the CDI API starting from the basics and then diving into more advanced concepts like Interceptors, Decorators, Alternatives, Events and the new Transactional option.
Java Server Faces covers the Java Server Faces API with particular focus on building applications using Facelets, shaping navigation between JSF views and the new exciting features of Java Server Faces 2.2
Learning the Java Persistence API after a quick introduction to Java Persistence API, describes how to set up a proof of concept project, how to spice it up using JPA 2.1 new features. Finally, this chapter describes some advanced development strategies such as Caching data and Listeners.
Testing applications using Arquillian is a deep dive into the application server integration testing framework. You will learn how to test our application across several different contexts, including a managed environment, a remote environment and an OpenShift cloud-hosted environment.
Developing applications with WebSockets teaches you how to leverage a full client-server WebSockets application including advanced examples using Encoders/Decoders and Asynchronous communication.
Developing SOAP based Web services discusses about creating, deploying, and testing web services using the JBoss JAX-WS implementation (Apache CXF) and avanced features such as JAX-WS Handlers.
Developing RESTful Web services covers concrete examples of REST Web services including the new JAX-RS client API and some advanced topics such as Interceptors and Filters.
Developing applications with JMS introduces the basics of the messaging service, showing off how to use the new JMS 2.0 API to code producers and consumers and how to create remote WildFly JMS clients.
JSON Processing discusses, after a quick introduction to JSON Structure, some practical aspects of JSON such as creating and parsing JSON models using the Object Model API and the JSON Streaming API.
Batch Processing covers Batch jobs and its specification language as specified by JSR-352. In this chapter, you will learn the two core components of batch jobs: Chunks and Batchlets and some advanced concepts such as Flows and Decision flows.
Java EE Concurrency introduces the Java EE Concurrency API (JSR 236) which outlines a standard way for executing more tasks in parallel on a Java EE Container using a set of Managed resources.
Securing WildFly applications gets you quickly to know WildFly security subsystem, showing how to set up login modules to Web applications and EJB applications and how to use the Secure Sockets Layer (SSL) to encrypt their communication.
Part II: Extending Jakarta EE with the Microprofile API
The second part of the book shows how to develop robust and resilient Microservices on WildFly using the following Microprofile extensions:
- Configuration: to develop portable configurations for your services
- Health: to receive health checks about the status of the application server
- OpenAPI: this API can be used to document your REST endpoint using annotations or a pre-generated JSON in a standard way.
- OpenTracing: which defines behaviors and an API for accessing an OpenTracing-compliant Tracer object within your JAX-RS application
- Metrics: to provide an unified way to export application metrics
- Fault Tolerance: to leverage resilience in your services
- JWT Authentication: to allow systems to authenticate, authorize and verify identities based on a security token.
Part III: Building lean Microservices using Thorntail
The third part of the book will teach you how to create Microservices using the so-called “just enough” application servers to support each component of your system. Includes:
- Getting started with Thorntail
- Coding Enterprise applications as Microservices
- Securing and Harnessing your Microservices
- Leveraging the Microprofile API with Thorntail fractions