Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Subscribe
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
Microservice Development with Java EE 8: 2-in-1
Rating: 4.2 out of 5(81 ratings)
454 students

Microservice Development with Java EE 8: 2-in-1

Build Java EE projects with microservices, and deploy them on AWS and Azure.
Created byPackt Publishing
Last updated 5/2018
English

What you'll learn

  • Decompose and refactor monolithic applications into microservices
  • Monitor, test, secure, and integrate microservices with each other and existing monoliths
  • Use MicroProfile and Payara Micro to build independent REST services
  • Dockerize the microservices in preparation for cloud deployment
  • Deploy containers on Microsoft’s platform Azure
  • Configure both AWS and Azure clouds for high availability

Course content

2 sections • 52 lectures • 4h 29m total length

  • The Course Overview5:22

    This video provides an overview of the entire course.

  • What are Microservices?6:17

    You will get familiar with the microservice architecture, what it is and what does it bring to the table.

  • Microservices Architectural Advantages and Enhancements5:58
    In this video, we will take a look at the common problems of the monolithic architecture and how the microservice architecture strives to solve them or reduce their effect.
  • Breaking the Monolith into Microservices5:09
    In this video, we will learn how to begin the process of decomposing existing Java EE monoliths into microservices. Both design wise and technology wise.
  • Java (EE) Microservice Frameworks Overview4:22
    In this video, we will get familiar with various Java (EE or otherwise) microservice frameworks.
  • Installing and Configuring Java, Maven and the IDE5:12

    In this video, we will set up the minimal development environment to start creating Java microservices.

  • Creating and Running the First Microservice Using Payara Micro8:36

    In this video, we will create a new maven microservice project configured with Payara Micro.

  • Building Basic RESTful APIs with JAX-RS 2.19:44

    In this video, we will build a CRUD REST API for the customer’s microservice data model backed by a standard database.

  • Configuring JAX-RS3:59
    In this video, we will configure JAX-RS to use a different JSON implementation.
  • Adding Error Handling, Filters and Interceptors with JAX-RS6:48

    In this video, we will add a generic authentication and CORS filter, with the ability to create custom responses for errors in the API.

  • Microprofile Overview Using CDI and JSON-P8:24

    In this video, we will introduce a better structure and separation of concerns to our microservice with CDI.

  • Decomposing an Existing Monolith Application6:28
    In this video, we will decompose and split an existing monolithic application into microservices.
  • Stateless Versus Stateful Highly Available Microservices5:48

    In this video, we will learn the impact of stateless vs. stateful microservice design in a highly scalable environment.

  • Finishing the First Microservice with Payara Micro7:38

    In this video, we will replace the database JDBC access with JPA to complete the first microservice.

  • Creating and Running the Second Microservice Using Dropwizard10:33

    In this video, we will create and build the orders microservice with the basic required functionality using Dropwizard and JPA for database access.

  • Monitoring Microservices with Dropwizard Metrics5:49

    In this video, we will define system and custom metrics and expose them through the REST API.

  • Integrating with JAX-RS and HTTP7:53
    In this video, we will complete the create order operation by integrating the required external microservice and monolith using HTTP with JAX-RS and JAX-WS.
  • Integrating with OpenID Connect8:59
    In this video, we will use OpenID Connect to implement a cross platform SSO stateless solution.
  • Automatically Testing Microservices6:04

    In this video, we will reduce bugs and failures by adding and implementing automatic testing of microservices.

  • Introduction to Spring and Spring Boot7:42

    In this video, we will get familiar with the Spring and the Spring Boot Java ecosystem.

  • Integrating Spring into a Java EE Environment5:54

    In this video, we will learn about the differences and similarities between Spring and Java EE as well as how to integrate the strengths of both of the ecosystems.

  • Creating the Microservice with Spring Boot and JAX-RS8:12
    In this video, we will create and build the payments microservice with the basic required functionality using Spring Boot and JPA with Spring Data for database access.
  • Creating the Microservice with Spring Boot and Spring MVC6:28

    In this video, we will reimplement the payments microservice JAX-RS REST API with Spring MVC REST and enable metrics with health checks.

  • Complete the Application Using All Three Created Microservices7:43

    In this video, we will integrate the payments microservice with the orders microservice and add custom health checks in order to finish the application.

  • Introduction to Containers and Docker8:47
    In this video, we will get familiar with modern containers and Docker.
  • Building, Packaging and Running Java Microservices8:50

    In this video, we will take existing microservices and package and run them with Docker Images and Containers.

  • Scalable Fault Tolerant Container Management Systems7:52
    In this video, we will Learn about scalable fault tolerant container management systems and why they’re needed, specifically Apache Mesos with DC/OS.
  • Preparing Java Microservices to Run in Highly Scalable Platforms8:00
    In this video, we will use existing Docker Images of microservices and deploy them on Mesos and DC/OS.

Requirements

  • Good knowledge on java is assumed
  • Basics of Java EE is required

Description

Java EE application model represents one of the best available design models on which to base the design of your enterprise application.

This 2-in-1 training course will address the problems that Java EE developers have been facing for years – breaking the monolith! By the end of this training program, you’ll learn how to build microservices in Java EE 8, enabling you to create highly extendable, scalable, fault tolerant applications that are cloud-ready.

Contents and Overview

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

The first course, Java EE 8 Microservices, begins with an introduction to microservices, you’ll learn how to start setting up your development environment and toolset. Use tools such as Dropwizard, Payara Micro, and Spring Boot while you build RESTful services with the latest JAX-RS 2.1 standard. Understand how to use Microprofile to optimize Java EE for microservices development. You’ll learn how to break down and refactor monolithic applications into microservices, as well as integrate both architectures in a fail-proof way. Integrate tools such as Docker with Java EE to give you a foundation to build Cloud Native applications. Finally, you’ll find out how to integrate Spring into your development environment and how to apply the best design patterns to build robust microservices.

The second course, Building and Deploying Java EE Microservices on the Cloud, shows how to build microservices in Java EE using REST APIs in an event driven approach and you’ll build the web layer. You’ll learn to build microservices in Java EE using microprofile and the Payara Micro server. Next, you’ll learn about interacting data services and building web views with JSF, after which we will take a look at application security and performance. From there, we’ll move on to focusing on continuous integration and continuous delivery, and you’ll also learn how to Dockerize your services. Finally, you’ll learn how to deploy the application on the AWS and Azure platforms.

By the end of this training program, you will be confident with the tools and techniques that will help you build robust and resilient cloud native applications in Java EE.

About the Authors

Tilen Faganel is the main developer of the frame KumuluzEE, and he received the Java Duke's Choice Award Winner 2015. He is 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.  This is also represented at national and international conferences. 

Vasilis Souvatzis is a passionate Java developer focusing on the enterprise world. His university thesis was a Java EE 7 full-stack e-commerce application. He participated in the first NetBeans Day Greece in Athens 2005, where he spoke about his Java EE 7 journey. Loyal NetBeans fan and user, took part in the last NetCAT testing the Java Editor and Glassfish integrations. Interested in new software development trends, making his steps into cloud technologies with a battle-hardened platform proving that Java EE fits the cloud just fine.

Who this course is for:

  • Java EE developers who are eager to build and deploy enterprise applications with the JEE 8 microservices architecture on the cloud.

Report abuse