Our next order of business is to integrate spring security with our user and

role entities.

In general what we'll need to do is to implement the user details service

interface.

If we open this interface in the spring docs when we go there now,

we open this interface we'll see by scrolling down,

that there is exactly one method to implement and it's this load ByUsername.

Method. It locates the user based on

the user name.

So when we implement this method we'll call upon our user DAO which we

haven't written yet to grab the user entity from the database via hibernate and

use it as the methods return value.

Let's start coding our service in dao now.

I'll switch back to IntelliJ and first I'll create the user service interface.

So in my service package I will create a new, I'll choose Java class,

user service and all select interface.

There we go, and I'll make this service,

extend user, details, service.

So that my implementation class will need to include that load by user name method.

And the one additional method that all include here is a find by user name

method, which is a method that's completely for our application purposes

and that doesn't have anything To do with spring security so let me add that now.

I'll say, findByUsername(String username).

And let's make sure to import the right user here.

Now, this is our users so if you choose one of the ones up top,

you're gonna be importing the wrong user.

It's the user that comes from com.teamtree house.

Right there, cool.

And that's it for our interface.

Let's now create the implementation.

So again in the service package I'll right-click New Java Class and

I'll call it UserServiceImpl.

And let me include that service annotation here.

As well as indicate that it should be implementing the user service.

And in doing so, we'll need to add all unimplemented methods.

There should be two, one that comes from that user detail service that

the user service extends, and one that comes from user service that

we explicitly coded in the user service interface.

Now before we dive into this class we'll first need a way to grab

user data from the database.

Of course this will require a da o.

for the user entity.

Let's go ahead and create that interface in the dao package right click.

New job a class I'll call it user dao and

I want this to be an interface there it is right there.

The cool thing here is how little work we have to do.

If you recall, we are using spring data JPA.

So all we have to do here is extend CrudRepository.

And when you extend CrudRepository,

you tell it the kind of entity that you're after in the database.

As well as the class used for the identifier again.

Make sure you are importing the correct

User com.teamtreehouse.todotoday.model.User.

And after this we intelligently code our query methods.

In our case it will suffice to include a findByUsername method.

So let's do that now here's how that looks.

I want it to return a single user and

will say findByUsername(String username).

And finally let's apply the repository annotation to this interface.

And this is to make sure spring picks this up as a DAO and

now when we boot the app spring data will generate the implementation of the DAO so

we don't have to code it that is.

It will see a method name FindByUsername.

And it includes a string parameter so

it will generate a method that will find a user in the database

that has a user name column that uses the method name right here.

It has a user name column equal to whatever value was passed in so

cool okay back to the user service amperes class.

We can now auto wire a user dao into our service which will

need to start combining our user database data that is users and rows So

that we can integrate it with spring security.

So lets auto wire that up top.

Auto wired, private, user DAO, user DAO.

Cool.

Let me make sure to import that class.

There we go.

User DAO is imported.

The find my username method will be fairly quick here since it only

involves calling upon the DAOs method of the same name.

So let's return whatever value.

The DAO returns.

By calling its method of.

The same name.

As for the load by user name method this one will involve barely more work

Here's what will need to do.

I'm gonna add some comments in here.

First we'll need to load the user from the database.

And we'll throw an exception if not found.

And then we'll return the user object.

So really, we're just doing one extra thing here.

And that is that we are throwing an exception if that specific username

is not found.

And that is expected by the load by user name method which, again, comes from that

user details service interface, which our user interface extended.

Let me go back and remind you of that.

So the load by user name method comes from the user details service interface.

Okay, so back to these comments.

For loading the user from the database we use the same approach we did

in the findByUsername method.

That is will use that userDao so let's create a user object.

And call upon the DAO to find the user by the username and

we'll pass in the username that we received here in this method.

Now, because this method should throw the username not found exception,

which will be detected by Spring Security,

if upon authenticating, a user is not found with the provided username.

Then we should do that now if the value that stored in user at this point

happens to be no.

So will say if the user is null then we'll throw that exception.

UsernameNotFoundException.

And will throw a message in there too.

User not found.

Cool, and let's not forget to return that user object instead of returning null.

All finished.

So we finished our service and DAO layers.

Next we'll add some application level configuration to our Spring app

that switches on all of our Spring security functionality.