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
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 9m
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 taking a 10,000 foot view of the Java EE landscape as well as showing some details of its programming model.
Table of contents
- Course Overview1m
- Java EE: The Big Picture21m
- What Is Java EE?26m
- Is Java EE Right for Your Organization?19m
Java EE: Getting Started
5h 0m
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 Overview2m
- Java EE: Getting Started11m
- Setting up the Java EE Environment17m
- Bootstrapping the Java EE Application14m
- Defining the Domain Model17m
- Adding a Transactional Repository22m
- Testing the Java EE Application18m
- Validating Data13m
- Injecting Beans15m
- Exposing a REST Service31m
- Documenting the REST Service20m
- Setting up the Angular Environment15m
- Bootstrapping the Angular Application18m
- Designing the User Interface27m
- Navigating Through Components18m
- Invoking the REST Service22m
- Revisiting the Application11m
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 Overview2m
- Introduction16m
- Understanding Java EE27m
- Creating a Common Application Tier1h 4m
- Addressing Business Concerns1h 15m
- Implementing Web Applications49m
- Interoperating with External Services1h 15m
- Putting It All Together13m
What's New in Java EE 8
1h 59m
Description
There are many new features Java EE 8. In this course, What's New in Java EE 8, you'll learn about Java's completely new Security API, improving upon the hard-to-use and often container-specific security mechanisms. First, you'll discover the brand-new JSON-B, an API for binding Java objects to JSON, and vice versa. With very little code, you'll explore how you can generate and consume JSON without any third-party libraries. Besides new technologies, many existing Java EE technologies got updated with Java EE 8 as well. Servlet 4.0, for example, now supports HTTP/2 and Server Push. JAX-RS 2.1, the technology for RESTful endpoints in Java EE, now also implements the Server-sent Events web standard. Additionally, you'll see all major updates to Java EE technologies in this release such as JPA 2.2, CDI 2.0 and JSF 2.3. Finally, you'll learn about the future of Java EE. Oracle is moving Java EE to an open-source foundation, which means the future of Java EE will be more open, and at the same time maybe less predictable. By the end of this course, you'll be ready to explore and use Java EE 8 all on your own.
Table of contents
- Course Overview1m
- Java EE 8 Introduction 16m
- Web Technologies33m
- JAX-RS 2.127m
- Data Technologies21m
- CDI 2.0 and the New Security API18m
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 JPA, Bean Validation, and RESTful Services in this section.
Java Persistence API (JPA) 2.1
3h 43m
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, you will learn the principle of object-relational mapping (ORM) and how to use Java Persistence API (JPA) to map your Java objects into relational databases.
Table of contents
- Course Overview1m
- Introduction22m
- Understanding Java Persistence API16m
- Managing Elementary Entities With JPA40m
- Relationships and Inheritance41m
- Querying Entities37m
- Entity Lifecycle, Callbacks, and Listeners26m
- JPA 2.1 Within Java EE 736m
Bean Validation 1.1
2h 31m
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 Overview1m
- Introduction14m
- Understanding Bean Validation10m
- Validating Built-in Constraints16m
- Defining our own Constraints17m
- Messages, Groups and Payloads15m
- Advanced Topics39m
- Bean Validation 1.1 within Java EE 734m
Java EE: Programming Servlets
4h 26m
Description
Web application development can be made easier by using Java servlets. In this course, Java EE: Programming Servlets, you will begin with a complet overview of servlet architecture and lifecycle. First, you'll see the configuration of a Tomcat webserver in Eclipse and you'll learn how to read the request and response headers. Next, you'll learn how filters are applied to servlets and see many details about tracking session data, web annotations, and globalizing servlets. Finally, you'll go over asynchronous programming in servlets, debugging, packing, and deployment of servlets. By the end of this course, you will have a much more complete understanding of how web development using Java servlets works. Software required: Tomcat and Eclipse.
Table of contents
- Course Overview1m
- Introduction22m
- Building and Deploying Your First Servlet11m
- Working with Form and Query String Data26m
- Handling HTTP Requests and Responses33m
- Intercepting HTTP Request with Filters23m
- Handling Exceptions in Servlets8m
- Tracking Session Data45m
- Receiving and Processing File Uploads10m
- Packaging Servlets for Deployment13m
- Debugging Servlets13m
- Globalizing Servlets25m
- Providing Servlet Metadata Using Annotations19m
- Understanding Asynchronous Servlet Processing12m
Advanced
This section contains some of the more advanced concepts. Learning about Servlets, CDI, Asynchronous RESTful services will make your Java EE skills complete.
Context and Dependency Injection (CDI 1.1)
3h 44m
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 Overview1m
- Introduction17m
- Understanding Context and Dependency Injection20m
- Injection With CDI38m
- Producers and Disposers31m
- Interceptors, Decorators, and Events51m
- Bringing the Web Tier and Service Tier Together30m
- CDI 1.1 Within Java EE 732m
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 Grizzly23m
- Testing with JerseyTest17m
- Dependency Injection and POST Support18m
- Asynchronous RESTful Resources18m
- Jackson for JSON and XML51m
- Validation, Exceptions, and Conditional GET Support25m
- Adding PATCH and If-Match Support14m
- Filters in Jersey22m
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.
Register for FREE. Get your Pluralsight IQ.
You’ll get unlimited access to adaptive skill assessments that help you validate your skills in as little as 5 minutes, and you'll get to see the Pluralsight platform first-hand.