Gain insights into Oauth2 and Spring Security, learn about various grant types, and practice hands-on exercises to configure robust authentication systems effectively.

oauth.tar.gz

Oauth

If you’re curious about getting started with Oauth2 and Spring Security then you’re in the right place. This course will show you what Oauth2 is, why it’s important, and how to use it effectively. 

You’ll start with an overview of Oauth2 in general and then explore the different types of grants including password grants, authorization grants, refresh token grants, and more. All these concepts are backed by hands-on exercises, so you’ll get to practice creating cross-origin resource sharing policies, custom user-principal, and configuration of the authorization server to send login credentials via JSON. 

By the end of this course, you will have the foundations in place to add a proper authentication system to your application.

Oauth2 with Spring Security

## Let’s create a custom user-principal
A principal is a “corporation, a program thread, an individual, or anything that can have an identity”.

The user-principal implements a Spring Security Interface that is `UserDetails`. We prefer using the composition pattern rather than inheritance. In fact, if we decided to use inheritance, we would have had issues with the constructors, having to import all the required parameters so that the signatures of the methods match. It’s been deprecated as an approach in more recent versions. I did try that approach as well, and it was a no-go. Therefore, we prefer to inject the user into `CustomUserPrincipal` and, on class instantiation, we assign our user to the user attribute of our object.

If you have IntelliJ, you can just Command(Ctrl)+Click it and read info about `UserDetails`. The basic idea is that when we implement an interface, it is like a contract, and we need to honor it, which means we need to provide an implementation for its methods.









# Let’s create a custom user-principal
A principal is a “corporation, a program thread, an individual, or anything that can have an identity”.

The user-principal implements a Spring Security Interface that is `UserDetails`. We prefer using the composition pattern rather than inheritance. In fact, if we decided to use inheritance, we would have had issues with the constructors, having to import all the required parameters so that the signatures of the methods match. It’s been deprecated as an approach in more recent versions. I did try that approach as well, and it was a no-go. Therefore, we prefer to inject the user into `CustomUserPrincipal` and, on class instantiation, we assign our user to the user attribute of our object.

If you have IntelliJ, you can just Command(Ctrl)+Click it and read info about `UserDetails`. The basic idea is that when we implement an interface, it is like a contract, and we need to honor it, which means we need to provide an implementation for its methods.









Learn about the implementation of Oauth2 with Spring in this lesson. 

Introduction

Theory

Practice

Quiz

Conclusion

Back to the Core

Let’s create a custom user-principal