
Paths
Java EE Foundations
The Java Enterprise Edition (Java EE) is a Java platform built on top of the Java Standard Edition (Java SE). It provides a Runtime environment and an API. Java EE is the popular... Read more
What you will learn
- Java EE’s place and purpose
- Java EE Fundamentals
- Java Persistence API (JPA)
- Context and Dependency Injection (CDI)
- Enterprise JavaBeans
- Bean Validation
- RESTful Services
- Servlets
- Asynchronous RESTful Services
- Jersey
Pre-requisites
It is recommended that you have basic Java knowledge.
Beginner
In this section, you will explore Java EE, how it fits into the Java software development landscape, and how you could use it to build your own large-scale applications.
Java EE: The Big Picture
1h 13m
Description
What is Java EE, how does it compare to the Java language, should you transition to it, and which type of application would benefit from it? This course answers those questions by exploring an overview of the Java EE landscape as well as showing some details of its programming model.
Table of contents
- Course Overview
- Java EE: The Big Picture
- What Is Java EE?
- Is Java EE Right for Your Organization?
Java Web Fundamentals
3h 21m
Description
Many Java web frameworks, such as Struts, are built on top of the Servlet and JavaServer Page specifications and base libraries. To fully understand how these frameworks operate, and to be able to take full advantage of the facilities they offer, you should understand the foundations such frameworks are built on. This course takes you through building a web application using the base Servlet and JavaServer Page libraries. The course discusses the Model-View-Controller pattern using Servlets as the Controller and JavaServer Pages as the View. You will also learn how to hide complex UI interaction inside tag libraries. The course will show you how it is possible to build a web application using these fundamental technologies, and how other frameworks are built.
Table of contents
- Course Overview
- Introduction
- Writing Servlets
- JavaServer Pages
- The Expression Language
- The Java Standard Tag Library
- Writing Tag Libraries
- Event Listeners
- Writing Filters
- Asynchronous Programming
Java: Creating a Basic Web App
2h 35m
Description
Learn how to create a basic web application with the Java Language. In this interactive course, you'll learn how to create a Java Servlet, display dynamic data in a JSP page, organize your data with a Model class, and connect your application to a database to read and write data.
Table of contents
- Creating Our First Java Web App and Servlet9 Videos - 6 Challenges
- Creating Our First JSP Page7 Videos - 5 Challenges
- Creating A Java Book Class6 Videos - 5 Challenges
- Connecting to Our Model8 Videos - 5 Challenges
- Installing4 Videos - 0 Challenge
Java EE: Getting Started
4h 59m
Description
Turn a blank page into a web application! In this course, Java EE: Getting Started, you'll learn how to develop a distributed web application based on two complementary technologies: Java EE and Angular. First, you'll begin by covering how to setup your development environment, design your domain model, map it to a relational database, bring transaction management, and then expose the business domain through a REST API. Along the way, you'll make sure the integration tests always pass. Finally, once the REST API is tested, documented, and up-and-running, you'll build an Angular front-end to interact with it through HTTP and JSon. By the end of this course, you'll have the fundamental knowledge to start building REST API's with Java EE and consuming them with Angular.
Table of contents
- Course Overview
- Java EE: Getting Started
- Setting up the Java EE Environment
- Bootstrapping the Java EE Application
- Defining the Domain Model
- Adding a Transactional Repository
- Testing the Java EE Application
- Validating Data
- Injecting Beans
- Exposing a REST Service
- Documenting the REST Service
- Setting up the Angular Environment
- Bootstrapping the Angular Application
- Designing the User Interface
- Navigating Through Components
- Invoking the REST Service
- Revisiting the Application
Intermediate
Now that you have a good grasp of what Java EE enables you to do, it’s time to move to the next step. You will get up close and personal with the design of Java EE applications, JPA, Bean Validation, and dependency injection with the courses in this section.
Java EE 7 Fundamentals
5h 25m
Description
Java EE 7 has established itself as the preeminent Java stack for web and back-end developers. This code-focused course shows how to build a complete application covering most of the Java EE 7 specifications. You'll learn about how the Java EE platform has progressed through its history to the modern platform it is today, the foundations of building a web application in Java EE, and how to interoperate Java EE applications with external services. You'll also learn about architectural best practices when building a Java EE application. By the end of this course, you'll have a solid foundational for building Java EE applications of your own.
Table of contents
- Course Overview
- Introduction
- Understanding Java EE
- Creating a Common Application Tier
- Addressing Business Concerns
- Implementing Web Applications
- Interoperating with External Services
- Putting It All Together
Java Persistence API 2.2
4h 15m
Description
Applications are made up of business logic, interaction with other systems, user interfaces . . . and data. Most data manipulated by our Java applications have to be stored in databases, retrieved, and analyzed. In this course, Java Persistence API 2.2, you will learn the principle of object-relational mapping (ORM) and use Java Persistence API (JPA) to map your Java objects into relational databases.
Table of contents
- Course Overview
- Introduction
- Understanding Java Persistence API
- Managing Elementary Entities with JPA
- Relationships and Inheritance
- Querying Entities
- Entity Lifecycle, Callbacks, and Listeners
- JPA 2.2 within Java EE 7
Context and Dependency Injection (CDI 1.1)
3h 43m
Description
Context and Dependency Injection takes its roots from injection frameworks and today has become a common ground for several Java EE specifications. In this course you will discover the CDI programming model and its concept of "loose coupling, strong typing." You will see that decoupling goes further by bringing interceptors and decorators to the entire platform.
Table of contents
- Course Overview
- Introduction
- Understanding Context and Dependency Injection
- Injection With CDI
- Producers and Disposers
- Interceptors, Decorators, and Events
- Bringing the Web Tier and Service Tier Together
- CDI 1.1 Within Java EE 7
Bean Validation 1.1
2h 30m
Description
Processing, storing, and retrieving valid data is crucial for an application, that's why validation is a common task that needs to be done in several layers of your application. In this course you will learn how Bean Validation allows developers to write constraints in a standard way and apply them everywhere (bean, properties, constructors, method parameters, and return value). You will also see how Bean Validation can be integrated in other Java EE specifications.
Table of contents
- Course Overview
- Introduction
- Understanding Bean Validation
- Validating Built-in Constraints
- Defining our own Constraints
- Messages, Groups and Payloads
- Advanced Topics
- Bean Validation 1.1 within Java EE 7
Advanced
Go further with Java EE by learning how to build RESTful web services and make use of the Java Messaging System (JMS) with the courses in this section
Building Asynchronous RESTful Services With Jersey
3h 11m
Description
At the start of the course we establish a basic "Books" API -- an API that we continually improve and build upon throughout the course. We begin by deploying to Grizzly, and then implement a series of tests with JerseyTest. These tests are also continually expanded throughout the course. We explore Jersey's built-in dependency injection, and improve our API to take advantage of Jersey's async support. We switch from the built-in MOXy library in favor of Jackson to render our highly-tailored JSON and XML, and build a custom MessageBodyWriter along the way. We explore mapping exceptions to responses, and supporting conditional GET requests. We implement our own PATCH verb, and along with it, support for conditional updates as well. Finally we explore Jersey's support for filters and implement our own custom filter.
Table of contents
- GET-ing Started With Grizzly
- Testing with JerseyTest
- Dependency Injection and POST Support
- Asynchronous RESTful Resources
- Jackson for JSON and XML
- Validation, Exceptions, and Conditional GET Support
- Adding PATCH and If-Match Support
- Filters in Jersey
Practical Enterprise JMS Playbook
1h 38m
Description
At the core of a lot enterprise grade Java applications is a JMS compliant messaging system. In this course, Practical Enterprise JMS Playbook, you'll learn how to use JMS within an enterprise, not only focusing on on the JMS APIs themselves, but also what other tools can aide you. First, you'll examine some techniques for creating performant and scalable JMS applications. First, you'll see examples of how to use some of the more advanced techniques and JMS features. Next, you'll discover how to avoid lots of boiler plate code and use existing frameworks such as Spring and JEE. When you've completed this course you will have the foundational knowledge of JMS that will help you as you apply your skills in an enterprise environment. Software required: Apache Maven, Apache ActiveMQ, Wildfly
Table of contents
- Course Overview
- Should We Be Using JMS?
- Setting up ActiveMQ
- Basic JMS Use Cases
- Designing Your JMS Solution for Production
- Using JMS with the Spring Framework
- Using JMS in a JEE Environment
- Administering and Monitoring Your JMS Environment