Reactive GraphQL Masterclass [ Java + Spring Boot ]

Reactive GraphQL Masterclass [ Java + Spring Boot ], available at $84.99, has an average rating of 4.67, with 176 lectures, based on 116 reviews, and has 1488 subscribers.

You will learn about Learn GraphQL From Scratch & Become Super Confident With GraphQL Expose your Microservice APIs via GraphQL for the clients to consume in a more efficient way How to write Integration Tests for your APIs A lots of hands on!! Flexible Data Schema This course is ideal for individuals who are Any Java / Spring Developer It is particularly useful for Any Java / Spring Developer.

Enroll now: Reactive GraphQL Masterclass [ Java + Spring Boot ]

Summary

Title: Reactive GraphQL Masterclass [ Java + Spring Boot ]

Price: $84.99

Average Rating: 4.67

Number of Lectures: 176

Number of Published Lectures: 176

Number of Curriculum Items: 176

Number of Published Curriculum Objects: 176

Original Price: $19.99

Quality Status: approved

Status: Live

What You Will Learn

Learn GraphQL From Scratch & Become Super Confident With GraphQL

Expose your Microservice APIs via GraphQL for the clients to consume in a more efficient way

How to write Integration Tests for your APIs

A lots of hands on!!

Flexible Data Schema

Who Should Attend

Any Java / Spring Developer

Target Audiences

Any Java / Spring Developer

Master GraphQL and Spring WebFlux for Building Reactive Microservices

This comprehensive course equips you with the skills to build modern, reactive microservices using GraphQL and Spring WebFlux. You’ll gain a deep understanding of GraphQL’s query language, schema design, and seamless integration with Spring WebFlux. Explore advanced topics like real-time subscriptions, robust input validation, and effective testing strategies. Through hands-on exercises and practical examples, you’ll develop the expertise to architect powerful and efficient microservices.

Course Highlights:

GraphQL Fundamentals: Demystify GraphQL’s principles, query language, and schema design. Understand its advantages over traditional REST APIs.

Advanced GraphQL Concepts: Explore subscriptions for real-time updates, input validation, error handling, and effective testing strategies.

Building with Spring WebFlux: Learn how Spring WebFlux empowers the development of reactive GraphQL microservices.

Hands-on Learning: Develop practical skills through exercises and real-world examples.

Architecting Robust APIs: Gain expertise in designing and implementing robust GraphQL APIs, addressing the N+1 problem and optimizing data fetching.

Testing Strategies: Master the art of integrating testing for GraphQL APIs, covering queries, mutations, and subscriptions.

By the end of this course, you’ll be able to:

Confidently utilize GraphQL for building APIs.

Design and implement effective GraphQL schemas.

Leverage Spring WebFlux for reactive microservice development.

Build real-time data applications with GraphQL Subscriptions.

Implement robust input validation and error handling mechanisms.

Effectively test your GraphQL APIs, ensuring their functionality and performance.

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Lecture 2: *** Resource ***

Chapter 2: Getting Started With GraphQL

Lecture 1: GraphQL – Introduction

Lecture 2: GraphQL – Types

Lecture 3: Project Setup

Lecture 4: GraphQL – Spring Application Properties

Lecture 5: QueryMapping – Hello World – Part 1

Lecture 6: QueryMapping – Hello World – Part 2

Lecture 7: QueryMapping – Passing Arguments – Part01

Lecture 8: NonNull Arguments

Lecture 9: QueryMapping – Passing Arguments – Part02

Lecture 10: How GraphQL is different from REST?

Lecture 11: How GraphQL QueryMapping Works!?

Lecture 12: Project Restructure

Lecture 13: Creating Custom Type With GraphQL

Lecture 14: Customer Service

Lecture 15: Customer Controller

Lecture 16: Customer Service – Demo

Lecture 17: Input Type

Lecture 18: Nested Objects – Schema Design

Lecture 19: Nested Objects – Order Service

Lecture 20: How Fields Are Resolved – Part 1

Lecture 21: How Fields Are Resolved – Part 2

Lecture 22: Nested Objects Aggregation – Demo

Lecture 23: How Nested Objects Execution Works!?

Lecture 24: Quick Assignment

Lecture 25: N+1 Problem – Introduction & The Fix

Lecture 26: N+1 Problem – Demo

Lecture 27: N+1 Problem – Size Mismatch Issue

Lecture 28: N+1 Problem – Order Mismatch Issue

Lecture 29: N+1 Problem – Another Solution With Map

Lecture 30: Data Resolver – Overriding A Field

Lecture 31: Data Fetching From Multiple Controllers – Part 1

Lecture 32: Data Fetching From Multiple Controllers – Part 2

Lecture 33: Summary

Chapter 3: Structuring GraphQL Queries

Lecture 1: Altair / Postman Clients

Lecture 2: Field Alias

Lecture 3: Executing Same API With Different Arguments

Lecture 4: Fragments

Lecture 5: Operation Name

Lecture 6: Using Variables

Lecture 7: ** ASSIGNMENT **

Lecture 8: Directives – @Include / @Skip

Lecture 9: Directives – @Deprecated

Lecture 10: Summary

Chapter 4: GraphQL – Advanced

Lecture 1: Data Fetching Field Selection Set

Lecture 2: Data Fetching Environment

Lecture 3: Project Restructure

Lecture 4: Project Setup

Lecture 5: Nested Objects – Sequential Execution Problem

Lecture 6: REST Controller

Lecture 7: GraphQL vs REST – Nested Objects Execution

Lecture 8: Data Fetcher Implementation

Lecture 9: Data Fetcher Demo

Lecture 10: Run Time Wiring Bean

Lecture 11: Run Time Wiring Bean – Demo

Lecture 12: Field Glob Pattern

Lecture 13: ** MAVEN DEPENDENCY **

Lecture 14: Additional Scalar Types – Part 1

Lecture 15: Additional Scalar Types – Part 2

Lecture 16: Additional Scalar Types – Part 3

Lecture 17: Object / JSON Scalar

Lecture 18: What About Void?

Lecture 19: GraphQL Interface – Schema Design

Lecture 20: GraphQL Interface – Implementation

Lecture 21: GraphQL Interface – Demo

Lecture 22: Type Resolver Configuration

Lecture 23: GraphQL Interface – Real Life Use Cases

Lecture 24: GraphQL Union – Introduction

Lecture 25: GraphQL Union – Schema Design

Lecture 26: GraphQL Union – Implementation

Lecture 27: GraphQL Union – Demo

Lecture 28: Operation Caching – Introduction

Lecture 29: Operation Caching – Implementation

Lecture 30: Operation Caching – Demo

Lecture 31: Summary

Chapter 5: Mutation / CRUD Application with GraphQL

Lecture 1: Introduction

Lecture 2: Project Setup

Lecture 3: Mutation Mapping – Schema Design

Lecture 4: Entity / DTO / Repository

Lecture 5: CRUD Service – Part 1

Lecture 6: CRUD Service – Part 2

Lecture 7: CRUD Controller

Lecture 8: Data SQL

Lecture 9: GraphQL – CRUD Demo

Lecture 10: What If Item Is Not Found!?

Lecture 11: Multiple Mutation

Lecture 12: What About Query + Mutation ?

Lecture 13: Should We Fetch Only Selected Fields From Upstream?

Lecture 14: Summary

Chapter 6: Subscription

Lecture 1: Introduction

Lecture 2: Subscription – Schema Design

Lecture 3: Subscription – Event Service

Lecture 4: Subscription – Emitting Events

Instructors

Vinoth Selvaraj
Principal Engineer

Rating Distribution

1 stars: 0 votes

2 stars: 1 votes

3 stars: 2 votes

4 stars: 26 votes

5 stars: 87 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!