A hands-on practical guide disclosing all areas of Enterprise development, covering details about Jakarta EE with lots of examples to be run on the full distribution of WildFly application server or using WildFly Bootable Jar as a Microservice.
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 (Jakarta REST Services, Jakarta SOAP Services). The testing area with Arquillian framework and the Security API is also fully covered in this part. At the end of this part, you will be able to create and deploy Enterprise applications on the top of Jakarta EE 8 runtimes (WildFly 21) and Jakarta EE 9 (WildFly 22 or newer).
The second part of the book discusses how to integrate the Jakarta Enterprise API with 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 book covers how to build Microservices using WildFly Bootable jar technology and how to deploy them on the cloud with Red Hat OpenShift.
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.
- How to use Maven plugin to simplify your project scaffolding
- Learning the foundation components that constitute the backbone of your applications: EJB, CDI, 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 your Jakarta EE applications in Microservices using WildFly bootable jar.
Part I: Developing Jakarta EE applications on WildFly
Getting started with WildFly covers the installation of the server platform and introduces the Jakarta EE platform. 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 archetypes or creating your custom archetype.
Programming Servlet is a first access to application development using the long-lived Servlet API. The chapter spans from the basics to advanced features such as non-blocking I/O and the Servlet Push.
Developing Jakarta Enterprise 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 the CDI API starting from the basics and then diving into more advanced concepts like Interceptors, Decorators, Alternatives, Events and the new Transactional option.
Jakarta Validation shows how constraints can be applied by means of annotations, with the ability to override and extend the metadata through the use of XML validation descriptors.
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
Developing Jakarta RESTful services covers concrete examples of REST Web services including the REST client API and some advanced topics such as Interceptors and Filters.
Learning the Persistence API describes how to set up a proof of concept project using data persistence, how to spice it up using JPA advanced features. Finally, this chapter describes some advanced development strategies such as caching data and Listeners.
Creating Front-end to REST services with Jakarta MVC shows how to create a MVC application using the Jakarta MVC API and how it can be integrated with the available MVC templates
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 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 creating, deploying, and testing SOAP web services and advanced features such as SOAP Handlers.
Coding applications with JMS introduces the basics of the messaging service, showing off how to code producers and consumers and how to create both local and remote WildFly JMS clients for ArtemisMQ.
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. 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.
Jakarta Concurrency outlines a standard way for executing more tasks in parallel on a Jakarta 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 a 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.
- Microprofile REST Client API provides a type-safe approach to invoke RESTful services over HTTP.
Part III: Building lean Microservices using WildFly Bootable Jar
The third part of the book will teach you how to turn our applications into bootable microservice-like components covering the following topics:
- Getting started with WildFly Bootable jar for your Enterprise applications
- How to create a custom runtime environment for your Bootable applications
- How to deploy a Bootable jar file on the cloud using OpenShift technology