Jakarta EE (formerly Java EE) Quick Start Course

Explore a Jakarta EE app template that demonstrates using Jakarta EE and MicroProfile APIs with a lightweight Docker-based server for cloud-ready, API-driven Java apps.

Deploy a Jakarta EE hello world, verify setup via logs and the context path, and prepare a simple to-do app that showcases the three canonical Jakarta EE APIs.

Discover the three canonical Jakarta EE APIs: persistence API, CDI API, and JAX-RS. Learn how they map POJOs to relational databases, enable loose coupling, and expose data via rest.

Model a todo entity in Jakarta EE as a pojo with task, due date, created date, completed and archive flags, then annotate it as a jpa entity.

Map a to-do class to a database table with an entity annotated class and a primary key column; fields task, due date, date created, completed, and archived map to columns.

Learn how to customize the mapping process between Java objects and database tables using the GOP API, including renaming the table and columns and excluding properties from persistence.

Learn how to mark a field as transient with the @Transient annotation to keep it out of database mapping, and model a one-to-many relationship between ToDo and user entities.

Explore JPA entity relationships such as one to one, many to one, one to many, and many to many, including collection valued associations.

Map Todo and TodoUser class relationships by converting to an entity relationship, illustrating many-to-one and one-to-many directions and building a bidirectional traversal between owner and todos.

Flesh out the todo user entity with name and email fields, implement getters and setters, and explore using a base class for the id field to reduce repetition via inheritance.

Map Java objects to relational database tables with JPA inheritance by using an abstract entity with common fields inherited by subclasses; avoid complex inheritance due to performance penalties.

Implement and map JPA inheritance with an abstract entity and map superclass to share audit fields, a common primary key, and persistence unit considerations across subclasses.

Create a persistence unit to group entity classes and define a data source, then access the entity manager interface via dependency injection, linked to a persistence context for operations.

Define the persistence unit in a Jakarta EE app by configuring persistence.xml with a JTA transaction type, exclude-unlisted-classes, and database creation properties, including an in-memory database for development.

Define a data source with a name, class, driver, user, password, and database details. Reference it in the persistence unit to connect to the database and note security implications.

Compare Jakarta EE business components: traditional EJB and CDI-based services, both transactional by default, and learn how the entity manager powers JPA operations.

Explore the entity manager interface in the Jakarta EE JPA API and its role in the persistence context, including operations like persist, find, merge, and create named or native queries.

Convert a POJO into a CDI bean with @ApplicationScoped and @Transactional to encapsulate business logic and manage transactions in the persistence service. Explain CDI's role in dependency injection and lifecycle.

Activate CDI in jakarta ee by configuring beans.xml to set discovery to all. This enables CDI injection for non-annotated classes and helps manage application-scoped beans.

Learn how to inject a container-managed JPA entity manager using @PersistenceContext, link it to a persistence unit, and perform operations within the transactional context.

Implement the PersistenceService class to persist entities within a transactional context created by CDI interceptors, using the persistence context to commit or roll back to the durable data store.

Explore how the entity manager's merge method reattaches a detached entity to the persistence context so updates reflect in the database after the transaction completes.

In the Jakarta EE quick start course, implement dynamic queries with JPQL using an entity manager to fetch to-do objects ordered by due dates, and compare dynamic and named queries.

Learn how to define and use named queries in Jakarta EE, including creating named queries, calling them via the entity manager, and using dynamic queries for flexibility as projects evolve.

Find entities by id using the entity manager’s find method with a class type and id, and understand bidirectional associations between todo and user for reliable persistence.

Learn how to link a todo to a TodoUser by ID, persist the association, and expose the result as RESTful web services with the Java API for RESTful web services.

Activate restful web services in a Java EE app by creating a config package and a class extending application, annotated with an application path like api/v1 to expose resources.

Define and expose a rest resource class for todos in Jakarta EE, inject a query service, and return a json list of todos at a configured path using producers.

Expose rest resources using the Java API for RESTful web services, define a base path with application path, implement a to do resource method, and inject with the CBI API.

Map HTTP methods to JAX-RS resources by annotating classes and methods, expose get, post, put, and delete handlers, and configure paths and JSON responses.

Implement a post endpoint to save a to-do object by injecting a persistence service, delegating to it, and returning a JAX-RS response in JSON.

Implement the save todo user resource method in a Jakarta EE REST service, persisting via the service layer. Return a minimal response built from the persisted user.

Define a public method to retrieve all todos and another to retrieve a user's todos, using an entity manager, JPQL queries, and parameter binding.

Learn how to pass parameters to JAX-RS REST resources using path parameters and query parameters, inject values at runtime, and choose the approach that best fits your use case.

Learn to build and deploy a jakarta ee application using maven, package as war, and test restful resources with insomnia rest client by creating a user and validating to-dos.

Learn to run a Jakarta EE app locally, post a json to-do user to rest service, and fetch the to-do list with a get request, demonstrating rest endpoints and persistence.

Jakarta EE quick start course walks through war Maven project with Java EE API and micro profile dependencies, running on Payara Micro, and exposing JAX-RS endpoints backed by JPA entities.