Master RESTful APIs with Spring Boot 2 in 100 Steps

Learn RESTful APIs using Spring Boot 2 with a Hands-on Step by Step Approach by building a User Management Service!

4.34 (1068 reviews)

Udemy

platform

English

language

Web Development

What you will learn

You will be able to develop RESTful web services with Spring Boot 2 from scratch.

You will build a real time project using Spring Boot Data JPA & H2 database wherein same project will be leveraged for learning all the modules in an incremental manner.

You will learn about using github to manage the incremental development process for SpringBoot applications both via git command line and using STS IDE.

You will understand how to implement Exception Handling using Spring 5 latest ResponseStatusException package.

You will be able to design and implement Global Exception handling and Validation for RESTful Services.

You will understand and implement JPA OneToMany Association

You will understand in depth of HATEOAS concepts and implement Self Linking and Relationship linking concepts using HATEOAS.

You will implement internationalisation feature for RESTful Services.

You will be able to understand and design filtering solutions for RESTful webservices with static, dynamic filtering methods and also using @JsonView.

You will understand DTOs concept (Data Transfer Objects) and implement Entity to DTO conversion using ModelMapper and MapStruct Dependencies.

You will understand the options available for RESTful APIs versioning and implement all the options available.

You will learn about importance of API Documentation for RESTful APIs and implement SWAGGER integration with UserManagement Service which you will build as part of this course.

You will understand and implement spring boot actuator and Spring Boot admin features for RESTful Services.

You will learn about Micrometer and how it can export metrics to multiple monitoring tools. You will implement exporting metrics via JMX and also to a SAAS solution named AppOptics and create dashboards, verify timeseries data, live metrics in AppOptics.

Why take this course?

******* Course Overview *******

Welcome to this Amazing course on Master RESTful API s using Spring Boot 2 in 100 Steps. The below are the list of modules covered in this course.

Course Modules

01. Introduction

02. Manage Spring Boot Projects via Github & HelloWorld REST service

03. Build RESTful APIs using Spring Data JPA and H2 Database

04. Exception Handling with ResponseStatusException - Spring 5 Latest

05. Validations & Global Exception Handling

06. SpringBoot - JPA OneToMany Association

07. SpringBoot - HATEOAS

08. SpringBoot - Internationalisation

09. SpringBoot - Filtering

10. SpringBoot - DTOS - Data Transfer Objects

11. SpringBoot - Versioning & Content Negotiation

12. SpringBoot - Swagger Integration

13. SpringBoot - Actuator & Admin

14. SpringBoot - Actuator & Micrometer

Each of my courses come with

Amazing Hands-on Step By Step Learning Experiences
Real Implementation Experience
Friendly Support in the Q&A section
30 Day "No Questions Asked" Money Back Guarantee!

***************Section wise course details**********************

Module 1: Introduction

Module 01: Introduction

01 Step 01: Course Introduction

01 Step 02: Introduction to RESTful API

Module 02: Manage Spring Boot Projects via Github & HelloWorld REST service

02 Step 00: Github & HelloWorld Introduction

02 Step 01: Create Spring Boot base project from spring initializer

02 Step 02: Introduction for managing Spring Boot projects via github

02 Step 03: Github Base Setup

02 Step 04: Add GIT Repository to Spring Tool Suite IDE

02 Step 05: Create a Simple Hello World RESTful Service which returns a String

02 Step 06: Create a Simple Hello World REST Service which returns a Bean (JSON)

02 Step 07: GIT Commit & Push Hello World RESTful service changes to Github

Module 03: Build RESTful APIs using Spring Data JPA and H2 Database

03 Step 00: Introduction to Build RESTful APIs with JPA

03 Step 01: Usecase Introduction

03 Step 02: Verify pom.xml for all Dependencies

03 Step 03: Update application.properties required for JPA based RESTful Services

03 Step 04 01: Create User Entity - Understand @Entity Annotation

03 Step 04 02: Create User Entity - Understand @Table Annotation

03 Step 04 03: Create User Entity - Define Variables, Getters & Setters

03 Step 05: Understand and Implement changes related to H2 Database

03 Step 06: Create User Repository - @Repository

03 Step 07: Implement getAllUsers RESTful Service - @Service, @RestController

03 Step 08: Test getAllUsers RESTful Service - Using REST Client POSTMAN

03 Step 09: Implement createUser RESTful Service - @PostMapping

03 Step 10: Implement getUserById RESTful Service - @GetMapping

03 Step 11: Implement updateUserById RESTful service - @PutMapping

03 Step 12: Implement deleteUserById RESTful Service - @DeleteMapping

03 Step 13: Implement getUserByUsername RESTful Service - @GetMapping

03 Step 14: GIT Commit, Push, Merge to Master and Push

Module 04: Exception Handling with ResponseStatusException - Spring 5 Latest

04 Step 00: Introduction to Exception Handling using ResponseStatusException

04 Step 00: Create git branch - local & remote

04 Step 01: Implement ResponseStatusException handling for getUserById

04 Step 02: Implement ResponseStatusException for updateUserById RESTful Service

04 Step 03: Implement ResponseStatusException for deleteUserById RESTful Service

04 Step 04: Implement ResponseStatusException for createUser RESTful Service

04 Step 05: Implement HTTP Status code & Location Header for createUser Service

04 Step 06: GIT Commit, Push, Merge to Master and Push

Module 05: Validations & Global Exception Handling

05 Step 00: Introduction to Spring Boot - Validations & Global Exception Handling

05 Step 00: Create git branch for Validations & Global Exception Handling

05 Step 01: Implement Bean Validation - @Valid

05 Step 02: Implement custom Global Exception Handler - @ControllerAdvice

05 Step 03: Implement HttpRequestMethodNotSupportedException in GEH

05 Step 04: Implement UserNameNotFoundException in GEH - @ExceptionHandler

05 Step 05: Path Variable Validation & ConstraintViolationException in GEH

05 Step 06: Implement Global Exception Handling using @RestControllerAdvice

05 Step 07: Switching between @ControllerAdvice and @RestControllerAdvice

Module 06: SpringBoot - JPA OneToMany Association

06 Step 00: Need for JPA OneToMany for HATEOAS

06 Step 00: Introduction to JPA OneToMany Association

06 Step 01: Create git branch for JPA OneToMany Association

06 Step 02: Create Order Entity and @ManyToOne Association

06 Step 03: Update User entity with @OneToMany Association

06 Step 04: Implement "getAllOrders" RESTful Service

06 Step 05: Implement "createOrder" RESTful Service

06 Step 06: Implement "getOrderByOrderId" RESTful Service

06 Step 07: GIT Commit, Push, Merge to Master and Push

Module 07: SpringBoot - HATEOAS

07 Step 00: Introduction to Spring Boot - HATEOAS

07 Step 00: Create git branch for HATEOAS

07 Step 01: Add HATEOAS Dependency in pom.xml

07 Step 02: Extend User and Order Entities with ResourceSupport

07 Step 03: Create new User and Order Controllers for HATEOAS Implementation

07 Step 04: Implement self link in getUserById Method

07 Step 05: Implement self and relationship links in getAllUsers Method

07 Step 06: GIT commit code, push to remote, merge to master

Module 08: SpringBoot - Internationalisation

08 Step 00: Introduction to Internationalisation

08 Step 00: Create git branch for Internationalisation

08 Step 01: Create LocaleResolver and ResourceBundleMessageSource Beans

08 Step 02: Implement RESTful Service with Internationalisation

08 Step 03: GIT Commit, Push, Merge to Master and Push

Module 09: SpringBoot - Filtering

09 Step 01: Implement Static Filtering using @JsonIgnore and @JsonIgnoreProperties

09 Step 02: Implement Dynamic Filtering using MappingJacksonValue

09 Step 03: Implement Dynamic Filtering with MappingJacksonValue & @RequestParam

09 Step 04: Dynamic Filtering - git Commit and Push code

09 Step 05: Introduction to Filtering using @JsonView

09 Step 06: Implement Filtering using @JsonView

Module 10: SpringBoot - DTOS - Data Transfer Objects

10 Step 01: ModelMapper Introduction

10 Step 02: ModelMapper Configuration Setup

10 Step 03: Implement Methods using ModelMapper

10 Step 04: MapStruct Introduction

10 Step 05: MapStruct Configuration Setup

10 Step 06: MapStruct - Create UserMapper and Implement getAllUsers Method

10 Step 07: MapStruct - Implement getUserById Method using MapStruct UserMapper

Module 11: SpringBoot - Versioning & Content Negotiation

11 Step 00: Versioning Introduction

11 Step 01: Create DTO's required for Versioning Implementation

11 Step 02: Implement URI Versioning

11 Step 03: Implement Request Parameter Versioning

11 Step 04: Implement Custom Header Versioning

11 Step 05: Implement Media Type Versioning

11 Step 06: Implement & Test Content Negotiation

11 Step 07: GIT Commit Code & Push for Content Negotiation branch

Module 12: SpringBoot - Swagger Integration

12 Step 00: Introduction to Swagger

12 Step 01: Add Springfox Dependencies to pom.xml and Create SwaggerConfig file

12 Step 02: Adding API Info to modify header part of our documentation

12 Step 03: Restrict scope of swagger document generation using API Base packages

12 Step 04: Auto populate documentation for JSR-303 Validations

12 Step 05: Adding Swagger Core Annotations to Model class

12 Step 06: Adding Swagger Core Annotations to Controller classes

Module 13: SpringBoot - Actuator & Admin

13 Step 00: SpringBoot Actuator Introduction

13 Step 01: Add Actuator Dependency in pom.xml

13 Step 02: Expose all Actuator Endpoints and discuss about them

13 Step 03: SpringBoot Admin Introduction

13 Step 04: SpringBoot Admin - Base Setup

13 Step 05: Point SpringBoot Client Application to SpringBoot Admin Server

13 Step 06: Test the features in SpringBoot Admin Server

Module 14: SpringBoot - Actuator & Micrometer

14 Step 00: Introduction to SpringBoot Micrometer

14 Step 01: Add Micrometer Dependency to pom.xml

14 Step 02: Integrate with JMX and view metrics in JConsole

14 Step 03: Integrate with AppOptics to export metrics and View metrics in AppOptic

14 Step 04: Verify Metrics in AppOptics and Create Metrics Dashboards.

Our review

--- **Overall Course Review** The global course rating stands at **4.37**, with recent reviews reflecting a mix of positive and constructive feedback. The majority of learners appreciate the comprehensive content and the detailed explanations provided in the course, which have effectively clarified doubts and filled knowledge gaps regarding Spring Boot and RESTful API development with Spring Data JPA. **Pros:** - **Comprehensive Content:** Many learners found the content to be in-depth and detailed, offering a solid understanding of Spring Boot and RESTful APIs. - **Step-by-Step Explanations:** The course is highly praised for its step-by-step approach, which is beneficial for beginners. - **Real-World Application:** Learners appreciated the practical application of concepts through the building of a real-world application. - **Detailed Instruction:** Excellent explanation with examples was a recurring positive note, highlighting the instructor's ability to convey complex ideas clearly. - **Value for Beginners:** The course is considered a good starting point for those new to Spring Boot and RESTful services. - **Audio Quality and Pace:** Some learners noted the audio could be better, but the slow pace was appreciated as it allowed for better understanding. **Cons:** - **Audio Recording:** A notable concern is the audio quality, with some learners finding it difficult to understand due to accents or speech speed. - **Redundancy and Repetition:** Some reviews suggest that the course material could be more concise, reducing redundancy in explanations and slides. - **Git Content Integration:** A few learners felt that git content was intertwined too much with Spring topics and suggested it should be offered separately. - **Latest Technologies:** Some reviews point out that the course content could be updated to include the latest dependencies, versions, and practices, such as the use of Hateoas for RESTful API design. - **Subtitle Accuracy:** Learners who are not native English speakers expressed difficulty with subtitles not matching the audio. - **Potential Misalignment with Expectations:** A few learners were disappointed that the course did not cover databases like MySQL or PostgreSQL and was limited to H2. - **Irrelevant Content:** Some reviews indicated that certain aspects of the course, such as git explanations, could be made optional or provided as supplementary material. - **Course Updates:** Questions were raised about whether the course content is kept up-to-date with the latest Spring Boot updates and best practices. - **Instructor Feedback:** A small number of learners were critical of the instructor's teaching methods and felt that the course did not meet their expectations, though this sentiment was not widespread. **Course Recommendation:** Despite a few areas for improvement, the course is generally well-received for its educational value, particularly among beginners looking to understand Spring Boot and RESTful APIs. With a focus on updating content to align with the latest technologies and improving audio quality, this course has the potential to be an even more valuable resource for learners. It is recommended for those interested in Spring Boot development, with the caveat that learners may need to supplement the course with additional resources for the most current practices.

Charts

Price

Rating

Enrollment distribution

Master RESTful APIs with Spring Boot 2 in 100 Steps - Distribution chart