About the course
Enterprise Java remains vital for building robust, scalable business applications. To excel in this domain today, developers need a firm grasp of the latest standards and contemporary development practices. This course is designed to provide a comprehensive and practical guide to developing current enterprise applications using the powerful Jakarta EE platform.
You will explore the essential Jakarta EE specifications that are fundamental to modern application development. Learn how to effectively manage components and dependencies with Jakarta CDI, build standards-based RESTful APIs using Jakarta REST (JAX-RS), and handle data persistence efficiently with Jakarta JPA. The course also covers critical areas such as transaction management using Jakarta Transactions and securing your applications with Jakarta Security.
Moving beyond older Java EE approaches, you will understand how to apply Jakarta EE principles to build modern application components, develop backend services, and align your development with current enterprise standards suitable for various architectures, including those leading towards microservices.
Whether you are transitioning from older Java EE versions or acquiring skills in enterprise Java development for the first time with the latest platform, this course will equip you with the necessary knowledge and practical experience to build professional, standards-based enterprise Java applications with confidence.
Instructor-led online and in-house face-to-face options are available - as part of a wider customised training programme, or as a standalone workshop, on-site at your offices or at one of many flexible meeting spaces in the UK and around the World.
-
- Apply Jakarta CDI principles for effective component design and dependency injection.
- Design and build robust, standards-based RESTful APIs using Jakarta REST (JAX-RS).
- Implement data persistence solutions efficiently with Jakarta JPA.
- Manage application transactions correctly using Jakarta Transactions.
- Secure your enterprise applications using the Jakarta Security API.
- Develop maintainable enterprise Java applications following Jakarta EE standards.
- Understand how Jakarta EE fits into modern architectural patterns like microservices.
- Test and prepare Jakarta EE components for modern deployment environments.
-
This course is designed for Java Developers who want to acquire the skills needed to build modern, standards-based enterprise applications using the Jakarta EE platform. It is particularly relevant for:
Developers currently working with older Java EE versions who need to update their expertise to Jakarta EE.
Java developers new to enterprise application development looking to learn the current standard platform.
Developers interested in building robust RESTful APIs and backend services with Jakarta EE.
Teams adopting or considering Jakarta EE for new enterprise projects.
-
Participants should have attended our Java Programming training or have an equivalent solid working knowledge of Java SE. This includes:
Proficiency in Java language syntax and core APIs.
A good understanding of Object-Oriented Programming (OOP) principles.
Experience with building, compiling, and running Java applications.
Basic familiarity with web concepts such as HTTP requests and responses would be helpful.
No prior experience with Java EE or Jakarta EE is required, but a good foundation in Java fundamentals is essential to benefit fully from the course.
-
This Jakarta EE course is available for private / custom delivery for your team - as an in-house face-to-face workshop at your location of choice, or as online instructor-led training via MS Teams (or your own preferred platform).
-
Introduction to Jakarta EE & Modern Enterprise Java
Evolution from Java EE to Jakarta EE
Understanding the Jakarta EE platform and profiles (Web Profile, Core Profile, Platform)
Overview of modern enterprise application architecture (e.g., microservices, APIs)
Setting up a Jakarta EE development environment and choosing a runtime (e.g., GlassFish, Payara, Open Liberty, WildFly)
The Jakarta Namespace (jakarta.*)
Jakarta CDI: The Modern Component Model
Introduction to Contexts and Dependency Injection
Injecting Dependencies (@Inject)
Scopes (@RequestScoped, @ApplicationScoped, @Dependent, etc.)
Qualifiers
Alternatives and Producers
Events
Interceptors and Decorators
Jakarta REST (JAX-RS): Building APIs
Designing RESTful Web Services
Resources and Endpoints (@Path, @GET, @POST, etc.)
Request and Response Handling
Consuming and Producing Media Types (@Consumes, @Produces)
Path and Query Parameters
Building REST Clients
Introduction to Jakarta JSON Processing (JSON-P) and Jakarta JSON Binding (JSON-B)
Jakarta Persistence (JPA): Data Access
Overview of Object-Relational Mapping (ORM)
Defining Entities (@Entity)
Entity Relationships (@OneToOne, @OneToMany, @ManyToOne, @ManyToMany)
The Persistence Context and EntityManager
JPQL (Jakarta Persistence Query Language)
Using the Criteria API
Entity Lifecycle and Callbacks
Mapping Inheritance and Embeddables
Basic Caching
Transaction Management (Jakarta Transactions)
Understanding Transactions in Enterprise Applications
Declarative Transaction Management (@Transactional)
Transaction Attributes and Isolation Levels
Programmatic Transactions
Jakarta Security
Introduction to the Jakarta Security API
Authentication Mechanisms
Authorisation (@RolesAllowed, @PermitAll, etc.)
Integrating with Identity Stores
Messaging with Jakarta Messaging (JMS 2.0+) (Optional Module/Topic)
Messaging Concepts (Queues, Topics)
Sending and Receiving Messages
Message-Driven Beans (MDBs) revisited in a modern context (or alternative CDI-based messaging)
MicroProfile: Cloud-Native Jakarta EE (Optional Module/Topic)
Introduction to MicroProfile goals and specifications
Configuration (MicroProfile Config)
Health Checks (MicroProfile Health)
Metrics (MicroProfile Metrics)
Fault Tolerance (MicroProfile Fault Tolerance)
OpenAPI (for API documentation)
JWT Authentication (MicroProfile JWT Auth)
Testing Enterprise Applications
Strategies for testing Jakarta EE components
Unit testing with testing frameworks
Integration testing approaches
Modern Deployment & Operations
Packaging Jakarta EE applications (WAR, JAR)
Containerisation concepts with Docker
Deploying to Jakarta EE compatible runtimes (traditional and microservices-focused)
Basic monitoring and observability considerations
-
https://jakarta.ee/ - The official Jakarta EE website
https://jakarta.ee/specifications/ - Direct links to Jakarta EE specification documentation
https://microprofile.io/ - The official website for MicroProfile (for cloud-native Java)
https://www.payara.fish/downloads/payara-platform-community-downloads/ - Download a popular Jakarta EE runtime (Payara Community)
https://openliberty.io/downloads/ - Download another popular Jakarta EE runtime (Open Liberty)
https://maven.apache.org/download.cgi - Download Apache Maven (a common build tool for enterprise Java)
https://gradle.org/install/ - Install Gradle (another popular build tool)
https://openjdk.org/install/ - Get the latest OpenJDK (recommended for modern Java)
https://www.oracle.com/java/technologies/downloads/ - Get the Oracle Java JDK
https://www.jetbrains.com/idea/ - Popular Java IDE (IntelliJ IDEA)
https://www.eclipse.org/downloads/ - Another popular development environment (Eclipse IDE)
https://docs.docker.com/get-started/ - Get started with Docker (for containerisation)
Trusted by