The video shows the differences between the EJB and CDI APIs. It covers when to use which and what needs to be done in order to setup the managed beans.

• Comprehend the main differences between EJBs and CDI managed beans
• Comprehend the similarities in the usage of EJBs and CDI managed beans
• Setup a basic beans.xml to configure CDI for injection of all beans 

The video shows CDI producers, their power and how to define and use them.

• Inject a component that is not a managed bean or that needs more flexibility
• Define CDI producer methods or producer fields
• Comprehend the similarity in using and injecting beans and produced values 

The video shows the necessity of and how to define and use CDI qualifiers. It covers how to define custom qualifier annotations.

• Identify that an injected value cannot be identified unambiguously
• Bind CDI producers to injection points using qualifiers
• Define custom qualifier annotations that allow type-safety 

The video explains the different scopes or managed beans. It covers both EJB and CDI, their differences and similarities.

• Comprehend the EJB stateless, stateful and singleton scope
• Injecting CDI managed beans without scope definitions results in the dependent scope
• Define CDI scopes on the bean or producer definitions to modify the bean’s scope and life cycle 

The video explains how to model and implement domain events using CDI. CDI comes with a powerful eventing mechanism which allows to decouple event creation from event handling.

• Define business-motivated domain events as plain Java classes
• Inject and fire the event during the business process execution using CDI
• Define an event handling mechanism that processes the fired events 

This video shows how to define JAX-RS resources that make an Java EE application accessible via HTTP. It covers how JAX-RS applications are bootstrapped and how Java types are translated into HTTP payloads.

• Set up the JAX-RS application by configuring the base application path
• Define a JAX-RS resources, a facade to the business boundary using the JAX-RS annotations
• Produce and accept the HTTP payloads in the desired content types. JAX-RS will automatically marshal the Java types 

This video shows how to declaratively marshal Java types to JSON definitions and back. It covers how JAX-RS integrates with JSON-B definitions out of the box.

• Customize the default Java type to/from JSON mapping via JSON-B annotations
• Use JSON-B to marshal Java types by defining JAX-RS resources to produce or accept JSON
• Declaratively enhance or change the Java type definitions if required 

This video shows how to programmatically marshal Java types to JSON definitions and back using JSON-P. It covers how JAX-RS integrates with JSON-P.

• Identify JSON mappings that are not sufficiently covered by JSON-B
• Define JSON structure creation programmatically using the JSON-P builder API
• Integrate JSON-P types with JAX-RS resources for both request and response bodies. 

This video shows how to send custom HTTP responses with JAX-RS. Examples for custom responses are HTTP status codes or header fields.

• Use the Response type from JAX-RS to build custom HTTP responses.
• Send different status codes if the default statuses don’t match your requirements
• Use the UriInfo context object to build URIs that point to your resources 

This video shows how to validate HTTP messages using Bean Validation and JAX-RS. It covers how to define custom validation constraints that match the application business logic.

• Use the @Valid annotation to instruct JAX-RS to validate Java objects
• Define Bean Validation annotations on the Java types that need to be validated
• Define custom validation constraint annotations to implement custom validation logic 

This video shows how to handle exception that occur within our application in JAX-RS.

• Implement the ExceptionMapper type with the custom exception mapping logic
• Define the ExceptionMapper for a specific exception and activate it via @Provider
• Define a ConstraintViolationExceptionMapper to map a failed validation to a custom HTTP response 

This video shows how JPA is used to map domain entities to the database. It covers how to bootstrap JPA for enterprise applications and how to declaratively define persistence mappings.

• Define a persistence.xml mapping file and a one or more persistence units for your application
• Map domain entities using JPA annotations such as @Entity
• Use the EntityManager type to persist and acquire persisted entities 

This video shows how to define entity relations that are part of the business domain. It covers which JPA definitions are required to specify the relation mapping in the database tables.

• Define the relation to enum values using @Enumerated
• Define the relation to other entities using @OneToOne, @OneToMany, @ManyToOne and @ManyToMany
• Define join columns and their properties via the annotation properties 

This video shows how to define and use application server datasources. The datasources are used to access relational databases.

• Use the default datasource of the application server if only one database is required
• Define persistence units with datasource JDNI names for multiple databases
• Specify the datasource properties in the application server configuration 

This video shows how to use technical transaction that handle database queries. It covers how exceptions that occur during the active transaction are handled.

• Use the default EJB mechanism that starts technical transactions for business methods
• Use the transaction type definition to control the logical flow of transactions
• Define rollback behaviors for specific exception types 

This video shows how to define and bind interceptors. Interceptors are used to interrupt the execution of methods and inject custom logic.

• Define an Interceptor class and bind it to a business method using @Interceptors
• Implement the custom interception logic in the interceptor method
• Inject and use managed beans in the interceptor class 

This video shows how custom interceptors are bound and activated via custom interceptor binding annotations. This approach minimizes coupling in our application.

• Define an interceptor binding annotation with @InterceptorBinding
• Annotate the interceptor and the business method or bean with the interceptor binding
• Activate the bound interceptor via beans.xml or a specified priority 

This video shows how to configure Java Enterprise application via CDI. It covers how CDI producers fulfill to define custom configuration requirements. The example configuration load the configured values from an application properties file.

• Identify and inject configured values into managed beans
• Define CDI producer methods that lookup and expose configuration values
• Specify custom qualifiers to further qualify the desired configuration values 

This video shows how and when to use caching. It covers how to build a simple yet effective custom cache and includes an outlook to the JCache API.

• Identify and evaluate the requirements for caching first
• Define custom caches via application scoped or singleton beans
• Use JCache or vendor-specific solutions if custom implementations are not sufficient or become too complex 

This video shows how and when to include logging in enterprise applications. It covers the shortcomings of traditional logging, which other solutions are reasonable and possible.

• Identify and evaluate the motivation for logging and look for potential different solutions
• Identify and simplify log invocations using custom log facades
• Log errors that can not be recovered from using the custom log facade 

This video shows how to define asynchronous EJB methods. It covers the possibilities and implications of asynchronous execution within EJBs.

• Annotate EJB business methods with @Asynchronous to invoke them asynchronously
• Define Future return types if a direct result is required
• Beware of scopes of managed beans in asynchronous methods 

This video shows how to define and fire asynchronous CDI events with both asynchronous EJB methods and CDI definitions.

• Use asynchronous EJB methods to handle CDI events asynchronously
• Define and fire CDI events using the fireAsync method
• Observe events that are fired via the fireAsync method with @ObservesAsync 

This video shows what container-managed threads are, what the threading requirements for enterprise applications are and which Java EE functionalities support developers. It covers the required APIs to use container-managed threads.

• Acquire and use the ManagedExecutorService to execute functionality within its own thread
• Avoid using application-managed threads or functionality that starts own threads, such as parallel streams
• Use CompletableFutures with the acquired ManagedExecutorService to implement more complex functionality 

This video shows how to define application timers via EJBs and CDI managed beans. It covers which APIs to use to define timers and scheduled jobs.

• Use the @Schedule annotation to define cron-like method invocations
• Beware of bean scopes when defining application timers
• Acquire and use the ManagedScheduledExecutorService to define scheduled jobs on CDI managed beans 

This video shows the motivations behind asynchronous JAX-RS resources and how to make use of them. It covers common use cases for this functionality.

• Define a @Suspended AsyncResponse to suspend the HTTP request thread
• Acquire and use the ManagedExecutorService to execute the business logic
• Alternatively, use asynchronous EJB methods or define JAX-RS resources with a CompletionStage return type 

This video shows how to access HTTP resources using the JAX-RS client. It covers how web targets are defined and used to send requests and read responses from and to Java types, respectively.

• Create an instance of the JAX-RS client using the ClientBuilder functionality
• Define a WebTarget that accesses the HTTP resources
• Use the invocation builder functionality to invoke targets and read responses 

This video shows how to use the JAX-RS client to retrieve collection resources and automatically map them to corresponding Java collection types. It also covers path templates.

• Use the JSON-P JsonArray type to conveniently map JSON collection responses
• Use JAX-RS’es GenericType to retrieve Java collection response types
• Use the path template functionality of WebTargets to define and resolve path variables 

This video shows how to handle client exceptions and potential errors. It also covers how to make client invocations more resilient by defining different type of timeouts.

• Beware of potential runtime exceptions that can occur on client invocations
• Potentially use Interceptors to catch client exceptions
• Define connection and read timeouts to make HTTP invocations resilient 

This video shows how to use the asynchronous and reactive JAX-RS client functionality. It covers how to use the CompletableFuture type in client invocations and the rx invocation builder.

• Use CompletableFutures to manually wrap client invocations into separate execution paths
• Use JAX-RS’es rx invocation builder to conveniently receive a CompletionStage return type
• Combine the CompletionStage or CompletableFuture types to compute the desired results 

This video shows how to use the JAX-RS API to define and implement Server-Sent Events (SSE) resources. It covers the required JAX-RS types and APIs.

• Define SSE JAX-RS resource methods using the SSE Java types
• Use the Sse, SseBroadcaster and SseEventSink types to send SSE messages to connected clients
• Manually resend events using the last event ID, if required 

This video shows how to consume Server-Sent Events (SSE) resources both on the command line and by using the JAX-RS SSE client. It also cover the last event ID HTTP header that controls which data is being resent.

• Use the SseEventSource type to access SSE resources from web targets
• Register an event consumer that will be invoked on arriving events
• Open the connection to the created SseEventSource 

This video shows how to use the Java EE’s WebSocket API to define server endpoints. It also covers how to define MessageDecoders and Encoders.

• Define a ServerEndpoint that will be invoked for WebSocket connections
• Define corresponding MessageDecoders and Encoders for the message Java types
• Use the bidirectional remote object to respond to messages 

This video shows how to access WebSocket endpoints by the WebSocket API. It also covers how client connections are bootstrapped.

• Define a ClientEndpoint that will be invoked for WebSocket connections
• Define corresponding MessageDecoders and Encoders for the message Java types
• Programmatically create a client to initialize the WebSocket connection 

Java EE has come a long way. In the past it has been considered heavy weight, but these times are long over. Java EE is the most lightweight enterprise framework currently out there. This video explains why.

• Understand the industry standard with a widespread knowledge base
• Integrate specifications with a lightweight programming model
• Discuss on no external dependencies, thin deployment artifacts, and modern app servers

What is required to develop, build and run your first Java EE 8 powered microservice? This is the question we are going to answer in this video by developing a small Hello World web service.

• Add Java EE 8 API dependency to Maven POM
• Add a JAX-RS configuration class and specify application path
• Add a REST resource implementation with a @GET resource method

Docker is the de-facto standard when it comes to packaging web services. This video shows you how to build a Java EE 8 based microservice image using Payara and run it as a container.

• Write a Dockerfile using Payara Server
• Write a Dockerfile using Payara Micro
• Build and run the Docker image

Proper REST APIs allow for the navigation to related resources using the URI. Usually, this is achieved by nesting the path.

In JAX-RS, you can use sub-resource locators to return nested REST resource implementations. This video shows different approaches to using sub resources.

• Define @Path annotated sub resource locator method
• Either construct and return resource instance or resource class directly
• Use @Inject ResourceContext to obtain fully managed resource instance

According to the REST maturity model, you should make use of HTTP status codes to signal erroneous behavior. This video shows different approaches to error handling in JAX-RS.

• Explicitly set the HTTP status code on the Response instance
• Throw a WebApplicationException on its subclasses
• Implement ExceptionMapper interface for custom error handling

When working with web services, you also need to be able to call them from within your program or service.

This video shows how to implement the client-side of a web service using the JAX-RS client APIs.

• Construct and configure a JAX-RS client instance
• Create a web target instance for the web service base URI
• Invoke the REST endpoints and obtain the response

Automated testing is an essential part in professional software engineering. This video gives an overview of different test strategies and shows to web service APIs using the Jersey Test Framework and the Test Containers Framework.

• Add dependencies to Jersey Test Framework and Test Containers Framework
• Implement the JerseyTest base class and add simple REST test case
• Construct test container from Dockerfile and implement integration test

Content-types and content negotiation play a central role in your REST APIs. It can be used to accommodate different clients and also different API versions. This video will focus on the basics of using content types and smart content negotiation.

• Use @Produces and @Consumes to specify content types
• Specify custom content types for API versioning
• Smart content negotiation using quality from server factor

JSON-B is the new API to marshall and unmarshall POJOs to and from JSON. This video will show how to use the API implicitly in your REST resources, customize the marshalling behavior using annotations and also how to use JSON-B programmatically.

• Implicit JSON marshalling and unmarshalling in REST resources
• Look at custom JSON marshalling using JSON-B annotations
• Explicit usage of JsonbConfig and Jsonb instance using JsonbBuilder 

Sometimes more control over generating and parsing JSON structures is required. This is what the JSON-P API is for. In this video we show the basics of using JSON-P as well the additions made in Java EE 8 such as the JSON Pointers, Patch and Diff APIs.

• Use JSON-P builders to construct JSON arrays and objects
• Use JSON Pointers to access JSON structures
• Use JSON Patch and Diff to modify JSON structures

Sophisticated use cases require traversing the relations between your REST resources. This video will demonstrate how a hypermedia-driven REST API can be constructed using JSON-P and JAX-RS.

• Use JSON-P to construct hypermedia enabled JSON structures
• Use @Context UriInfo to construct resource URIs programmatically
• Set link headers with URIs on the HTTP response

Usually request processing on the server works in a synchronous mode. Under high load with lots of concurrent connections, there are a lot of wasted resources and the server does not scale that well. In this video, we will see how asynchronous processing addresses this.

• Separate request I/O threads from processing threads using thread pools
• Free request threads to accept new connections
• Improve overall performance and throughput

The JAX-RS APIs support asynchronous processing of requests. This video shows the basic server-side implementation of async REST resources.

• Implement a public void method in the JAX-RS resource class
• Add an @Suspended AsyncResponse method parameter
• Call the resume method on AsyncResponse in separate thread

The Java EE Concurrency API can be used nicely in conjunction with the JAX-RS async APIs. This video shows how it is done.

• Inject and use ManagedExecutorService in resource class
• Use a TimeoutHandler to customize timeout response
• Use CompletableFuture to run processing and apply response

Asynchronous processing can also be used at the client-side. This video shows the basic usage of the asynchronous JAX-RS Client API.

• Use the async() method for a Future to return value
• Implement InvocationCallback to respond to completed and failed events
• Use CompletableFuture for fluent request chaining

Traditional web services usually apply a request-response style communication approach. This video shows how Server-sent Events can be used to send data from the server to the client, maybe for a stock ticker or to display live telemetry data.

• SSE is a HTTP based API dedicated to Push
• SSE allows for one way communication between server and client only
• Stream of text data encoded as UTF-8 separated by newline

This video shows how SSE can be implemented on the server-side using the new Java EE 8 JAX-RS APIs.

• Use content type text/event-stream to connect to stream
• Inject SseEventSink as @Context method parameter
• Use @Context Sse instance to build event instances

In order to receive Server-sent Events, the client has to issue a GET request using the text/event-stream media type. This video shows how to implement a SSE client using the JAX-RS API as well as using JSP, HTML, and JavaScript.

• Construct SseEventSource instance from JAX-RS WebTarget for endpoint URL
• Register consumer for inbound SSE event with event source
• Open event source to start receiving events

SSE also allows to broadcast events to all registered event sinks. This video shows how SSE broadcasts are implemented on the server-side using JAX-RS as well as on the client-side using JSP, HTML, and JavaScript.

• Build SseBroadcaster instance using injected Sse @Context instance
• Register @Context SSE event sink instance with broadcaster
• Construct SSE event and send instance using broadcaster instance

Good REST APIs validate the requests they accept and return HTTP status code 400 BAD_REQUEST if invalid. This video shows how to implement this behavior easily by combining Javax.Validation and JAX-RS.

• Combine JAX-RS APIs and Javax.Validation to implement DbC
• Use validation annotations to validate parameter values
• Use @Valid to validate POST request body POJOs

Token-based authentication and authorization is becoming popular when implementing webservices. JSON Web Tokens (JWT) are a way to represent public claims using JSON. This video shows how to extract and validate JWT for your REST resources using a JAX-RS request and response filter.

• Implement container request and response filter to extract JWT token
• Use 3rd party library to decode extracted JWT token
• Enable filter on JAX-RS resource with custom @NameBinding annotation

In a highly distributed environment, the diagnosability triangle of logging, metrics, and tracing play a crucial role. Java EE 8 and JAX-RS provides a lot of extension points for third-party open source components to retrofit these features. This video shows how you can add logging, metrics, health checks, and tracing to your Java EE 8 webservice with minimal code.

• Use Jersey LoggingFeature for request-response logging
• Use Eclipse MicroProfile for metrics and health checks
• Use OpenTracing APIs and Jaeger for tracing