Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Subscribe
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
The Complete Guide to Java EE 8: 3-in-1
Rating: 4.0 out of 5(120 ratings)
764 students

The Complete Guide to Java EE 8: 3-in-1

Explore the Java EE platform to build enterprise-ready Java applications
Created byPackt Publishing
Last updated 8/2018
English

What you'll learn

  • Get the most out of this guide to learn the Java EE APIs
  • Get hands-on with best practices and patterns in Java EE 8
  • Develop microservice applications that runs in highly scalable cloud environments
  • Demonstrate how to implement application business logic with minimal boilerplate code
  • Explore and apply various patterns to achieve enhanced performance in application development
  • Create microservices using Java’s best microservice frameworks

Course content

3 sections • 87 lectures • 8h 41m total length

  • The Course Overview3:52

    This video will give you an overview about the course.

  • Implementing domain business logic in Java EE8:59

    The video shows how to implement business domain logic in Java EE and plain Java. It covers how Java EE encourages business-oriented solutions. Basic Java EE APIs is introduced.

  • EJBs and CDI managed beans6:34

    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.

  • CDI producers2:55

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

  • Qualifiers3:31

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

  • Scopes4:59

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

  • Events4:45

    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.

  • JAX-RS resources7:05

    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.

  • Integrating JSON-B2:02

    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.

  • Integrating JSON-P4:37

    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.

  • Custom HTTP responses6:11

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

  • Validating communication5:19

    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.

  • Exception handling5:25

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

  • Mapping domain entities with JPA6:05

    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.

  • Entity relations7:04

    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.

  • Datasources2:42

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

  • Transactions5:07

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

  • Interceptors3:16

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

  • Binding custom interceptors5:48

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

  • Configuring Java EE applications5:40

    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.

  • Caching6:22

    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.

  • Logging7:10

    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.

  • Asynchronous EJBs4:28

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

  • Asynchronous CDI events3:15

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

  • Managed threads3:48

    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.

  • Timers4:35

    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.

  • Asynchronous JAX-RS resources7:03

    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.

  • Accessing HTTP using JAX-RS8:46

    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.

  • Extended client usage4:33

    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.

  • Making HTTP clients resilient5:10

    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.

  • Asynchronous, reactive clients7:26

    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.

  • Implementing SSE resources with JAX-RS8:26

    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.

  • Server-sent event clients3:58

    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.

  • Implementing WebSocket server endpoints6:45

    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.

  • Accessing WebSocket endpoints5:41

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

  • Asset 1- Learning Java EE 8

Requirements

  • Familiarity with Java is assumed.
  • Basic knowledge of Java EE will be helpful for this course.

Description

Java EE provides a standard set of specifications that can be used to develop standardized applications, independent of the vendor. Enterprise applications do not change that often, and hence we need a robust platform such as Java EE to ensure sustainability. To learn features and APIs in Java EE for building enterprise-ready applications, you’ll need to be familiar with programming in Java.

This  comprehensive 3-in-1 course teaches you how to develop enterprise applications using the Java Enterprise platform and modern APIs. It covers each and every concept of the Java EE platform with the help of practical examples making it easy for you to understand and implement in your own applications.

This training program includes 3 complete courses, carefully chosen to give you the most comprehensive training possible.

The first course, Learning Java EE 8, course starts off by exploring the core Java EE components. You will then learn about HTTP endpoints. You will also learn how to map domain entities with JPA. Next, you will understand how interceptors realize technical cross-cutting concerns. You will learn to access external systems. Finally, you will learn about the asynchronous communication protocol.

The second course, Design Patterns and Best Practices in Java EE 8, starts off with exploring various design patterns. You will then learn to work with categorizing design patterns. You will also work with creational patterns. Next, you will explore different types of behavioural patterns. Finally, you will learn the implementation of key patterns such as Façade, Singleton, Factory, Decorator, and Observer in Java EE.

The third course, Java EE 8 Microservices, begins with explaining the benefits of using the microservice architecture. You will then learn to decompose and refactor monolithic applications into microservices. You will also learn to create microservice with the best Java microservice frameworks such as Payara Micro, Dropwizard, and Spring Boot. Next, you will learn to implement RESTful services using JAX-RS 2.1 and Java EE 8. You will learn to monitor, test, secure, and integrate microservices with each other and existing monoliths. Further, you will learn to integrate Spring into a Java EE ecosystem. Finally, you will learn to package microservices into Docker containers making it suitable to run in a highly scalable cloud environment.

By the end of this Learning Path, taking the challenge of building a cloud-ready, enterprise application in the microservice architecture will be a walk in the park.

Meet Your Expert(s):

We have the best work of the following esteemed author(s) to ensure that your learning journey is smooth:

Sebastian Daschner is a Java freelancer working as a consultant, author, and a trainer. He is enthusiastic about programming and Java (EE). He is the author of the book Architecting Modern Java EE Applications. He participates in the JCP, helping to form the future standards of Java EE such as serving in the JAX-RS, JSON-P, and Config Expert Groups, and collaborating on various open source projects. For his contributions to the Java community and ecosystem, he was recognized as a Java Champion, Oracle Developer Champion, and double 2016 JavaOneRockstar. He is a regular speaker at international IT conferences such as JavaLand, JavaOne, or Jfokus.

Sekhar Srinivasan (Microsoft Certified Trainer) is a highly reputed trainer. He is well known for imparting unique techniques in training for the past 22 years. He has trained students on various Java technologies such as Core Java, JDBC, Servlets, JSP, JSF, Spring, Hibernate and also various Microsoft technologies and JavaScript frameworks. He is a firm believer of being constantly up to date with the upcoming technologies to deliver the best possible training he can. He provides extensive training programs such as classroom training, online training programs and is also an author with Pluralsight and Packt Publishing.

Tilen Faganel is the main developer of the frame KumuluzEE. He received the Java Duke's Choice Award Winner 2015. He is the head of development of integration solutions in high-tech start-ups Sunesis, and has worked on numerous projects developing advanced cloud applications for enterprises in Slovenia and abroad.

Who this course is for:

  • This Learning Path targets software developers who are keen to explore the Java EE platform to build enterprise-level applications.

Report abuse