easylearn.ing
Easy Learning with Learn Spring GraphQL
Development > Software Engineering
20 h
£39.99 Free
5.0 ★★★★★
2092 students

Enroll Now

Language: English

Sale Ends: 16 Dec

Master Spring GraphQL: Build Modern APIs with Spring Boot 3

What you will learn:

  • Build GraphQL queries, mutations, and subscriptions with Spring
  • Integrate Spring Data JPA with GraphQL for database interactions
  • Implement custom validation logic using GraphQL instrumentation
  • Handle exceptions effectively at a global application level
  • Implement GraphQL pagination using multiple techniques
  • Integrate WebSockets for real-time capabilities
  • Create native images using GraalVM for optimized performance
  • Secure your GraphQL application as an OAuth2 resource server
  • Implement an Authorization Server (Client Credentials)
  • Convert GraphQL scripts into Java classes (POJOs)
  • Connect to external GraphQL servers using REST clients
  • Containerize your application using Docker
  • Deploy your application to Kubernetes
  • Implement CI/CD with GitHub Actions
  • Create custom exceptions and validations
  • Master GraphQL data types and schema design

Description

Ready to build robust, scalable GraphQL APIs with Spring? This course is your complete roadmap to mastering Spring GraphQL and its ecosystem.

Dive in and learn from the ground up, building real-world applications and tackling complex scenarios with hands-on projects. This pragmatic course emphasizes practical application, guiding you through each stage of development.

You will gain a deep understanding of GraphQL's communication patterns and how to leverage Spring's power for enhanced functionality.

Key skills you’ll acquire:

  • Extend basic GraphQL types to fit your application’s needs.
  • Implement robust validation using GraphQL instrumentation.
  • Secure your APIs using Spring Authorization Server (OAuth2) with Client Credentials Grant.
  • Establish a seamless CI/CD pipeline leveraging GitHub Actions.
  • Optimize performance and deployment with GraalVM native image generation.
  • Manage your application effectively within a Kubernetes cluster using kubectl.
  • Utilize WebSockets for real-time event broadcasting.
  • Employ Spring Data JPA repositories for efficient database interactions.
  • Write comprehensive integration tests using SpringBootTest, JUnit, and Hamcrest.
  • Master the art of effective integration testing.

Beyond the core concepts, you'll explore essential technologies such as:

  • Docker Containerization: Learn to containerize your application and manage it using Docker commands.
  • PostgreSQL Database Integration: Build robust database-driven GraphQL APIs.
  • Custom Exception and Validation Handling: Enhance the robustness and user experience of your applications.
  • Java Records: Learn how to effectively use Java records in your Spring projects.
  • Spring Boot Starter Docker Compose: Simplify local development and testing workflows.

Curriculum

Introduction

This introductory section sets the stage by explaining the reasons behind using Java 22, providing a comprehensive setup guide, introducing the clients that will be used throughout the course, and outlining the available course resources.

Dependencies

Learn how to initiate dependencies using IntelliJ and start.spring.io. The section explains each dependency, covers the Dgs code generation plugin, and details configuration and property setup for optimal plugin utilization.

GraphQL Data Types

Explore the fundamental building blocks of GraphQL, starting with basic types and progressing through more advanced concepts like interfaces, enums, and unions. This section lays the foundation for building complex GraphQL schemas.

Extended Scalar Types

Learn to extend the capabilities of GraphQL by defining custom scalar types, configuring them appropriately, and effectively utilizing them within your application's GraphQL schema.

Basic Endpoints Types

This section covers the creation of basic GraphQL endpoints: Query, Mutation, and Subscription types. Understand how these types function and their roles in defining API operations.

GraphQL Entities

This section delves into the construction of GraphQL entities, a crucial aspect of modeling data for your API. Learn how to define and manage these entities in multiple parts.

JPA Entity Type

Here, you'll learn how to integrate JPA entities with GraphQL, covering Company and other JPA entity types, and addressing the challenges of using JPA entity relationships. You'll learn about Enum Converters and how to efficiently use JPA repositories.

GraphQL Entity Scripts Implementation

Put theory into practice by implementing GraphQL queries and mutations for your entities, focusing on efficient coding practices and building robust API functionality.

Controller Chassis

Learn how to map HTTP verbs to GraphQL operations, constructing controller components to manage these mappings for improved API architecture and maintainability.

Mapper Util

This section focuses on efficiently mapping data between different layers using a Mapper utility, a key aspect of clean and maintainable code.

Service For Mutation

This in-depth section explains creating and managing services for mutations, a key component in handling API changes and data modifications. The lessons are split into multiple parts covering different aspects of mutation management.

Testing Mutation

Thoroughly testing mutations is crucial, and this section guides you through testing these operations with various techniques, including using Postman for effective mutation validation and confirmation.

Bootstrap Entities

Learn the effective techniques and processes used to load initial data into your application's entities in a robust and efficient manner, preparing your application for real-world operation.

Service For Query

This section teaches you the processes involved in managing services for queries, handling data retrieval and requests effectively and efficiently.

Testing Service For Query

Testing query services is essential, and this section guides you through effective testing approaches, including the usage of type names and fragments.

GraphQL Union

Explore the practical implementation and usage of GraphQL Unions, enhancing the flexibility and scalability of your GraphQL schema.

Headers With Arguments

Learn to use headers effectively within your GraphQL APIs for enhanced security, data transfer, and authentication mechanisms.

Pagination

Master GraphQL pagination techniques, which are crucial for handling large datasets efficiently and improving application performance. This section provides in-depth explanations and practical implementation examples.

Exception Handling

Robust exception handling is essential, and this section shows you how to create a comprehensive and effective exception handling mechanism for your GraphQL API.

Validation

This section introduces various techniques for validating data within your GraphQL application, ensuring data integrity and application robustness.

Websocket

Explore the power of WebSockets for real-time communication, enhancing your GraphQL API’s capabilities for dynamic data updates and efficient messaging.

Instrumentation

Learn to leverage GraphQL instrumentation for implementing custom logic, which allows for more control and customization within the GraphQL schema and execution pipeline.

Integration Testing

Comprehensive integration testing is critical; this section guides you through developing rigorous tests to ensure the different components of your application work together seamlessly.

Security

This comprehensive section covers securing your GraphQL API using OAuth2 as a resource server and implementing a complete authorization server with Client Credentials Grant for secure API access.

Local GraalVm Build

Optimize your application's performance by learning to build a native image using GraalVM, and this section details the process.

Kubernetes K8s (Important)

This section focuses on deploying your application to Kubernetes, providing comprehensive instruction on setting up your environment, managing pods, services, deployments, and configuration maps. It also explores port forwarding and other essential Kubernetes concepts.

CI-CD

Implement a complete CI/CD pipeline using GitHub Actions, enabling automated building, testing, and deployment of your GraphQL application.

GraphQL Client

This section guides you through creating and interacting with a GraphQL client, an essential aspect of consuming and testing your GraphQL APIs.

Deal Source: real.discount