Okay.

So we have some shared functionality between our entities at the moment.

Mainly, the handling of how our system generates unique IDs.

All entities are going to identify the same way and

require that no argument constructor.

So it sounds to me like what we want to do is create a class that are entities

should extend.

But wait.

We probably wanna make sure that nobody creates that superclass.

I mean, what would that even map to in the database.

When you have functionality that you wanna share but you don't wanna allow

object creation of that superclass using an abstract class is the way to go.

Let's use an abstract class to solve our woes.

Okay. So let's create a new package.

And it's gonna handle all of the shared items between our features.

It'll deal with features core to our application.

So the typical name for this sort of thing is core.

So let's go ahead and do the same.

Right? So we'll make a new Java class.

We'll make a new package called core.

And let's name this entity, BaseEntity.

That should help make things clear.

Okay, so now let's add the abstract keyword here.

Okay, now with this in place, nobody can create a BaseEntity.

They must extend it if they want to use.

They'll get a compile time error.

Or they'll be prompted to create an anonymous inner class.

If they attempt to use it with the new keyword.

So the first thing that we need to do, is to tell.

J P A that this is a mapped superclass.

So we'll say mapped superclass.

And now we can use it with our other entities.

Now let's flip over to one of our entities and grab our duplication perpetrator.

So here you go, let's grab this ID, I am gonna go ahead and cut this app,

wanna flip over to the base entity.

I'm going to add that and we will do these imports.

Here we go and it is complaining about not having a constructor.

So let's initialize in the constructor.

And it automatically did,

just what we needed, made a protected base entity, set the ID to null.

Let's flip back to course and what we're gonna do is,

we're gonna say is extends BaseEntity.

Now unfortunately we still need to have a no argument constructor in our entity

classes.

That's just the J.P.A rules but what we can do is instead

of doing this again here we can just call super().

This way in case we want something special to happen in

all of our entities we can just change the single constructor in base entity.

If we want to change something specifically,

we can add it after the call here to super, right?

We could come in here, and we can add whatever we want specifically for courses.

Now the terms super class and parent class are interchangeable, and

you'll hear both used.

In this case, our course entities super and or parent class is BaseEntity.

So it's kind of like Jor-El.

You know, a super parent.

Sorry that was a dumb Superman's dad joke.

Okay.

And now let's do the same thing for review.

We'll come in here and we will

come in here and we will get rid of the ID, and

we will make a review called super.

And make it extend BaseEntity.

Here we go.

All right so now that we've got that all out of the way, what do you

say we spin up our server and make sure our entities are working as we expect.

So let's go ahead and make a new class

in the root here right under com.teamTreeHouse.

Let's make a new class called Application.

The name doesn't matter.

So first things first, we will mark this as a SpringBootApplication.

And we were going to add public static void main and for

the body we're going to call SpringApplication.run and

pass in our class, and pass in whatever our args were passed to the main function.

This is SpringApplication.

Okay, so if we go ahead now and run,

we try to run this, we will see everything.

Wait a second, you say, we haven't made any controllers yet

that will respond to these actions.

Well get this, our repositories are exposed.

Look, check this out in the log here.

Scroll this up here.

Scroll over.

See this mapped slash repository ID?

It went ahead and built things when our app started up.

So simply by having repositories around, routes got created and it will respond.

Pretty cool right?

Now, if you've never used a restful AP before you might not know

how to go about discovering these routes.

One emerging standard is to have your API respond with HAL or

Hype media Application Language.

Well by default spring date arrest works with HAL formats.

So in order to discover our API all you do is hit the route and so

let's see the route is mapped here at 8080.

Okay, so, let's go ahead.

And we'll come over here and we'll go to localhost:8080 and forward slash.

So if you look here we have these links defined and its underscore links.

So that's that's a HAL format to make sure that you know that this is

coming from HAL.

And there's more on HAL in my teacher's notes, and

we'll explore it as we go through, but

they've given you links to the resources that are available.

Hey look, there's courses and

reviews, these are representing the repositories that we built.

By default, it's using a plural version of the entity

that's being represented by the repository.

That's pretty cool, right?

It automatically figured out that course was courses and reviews was reviews or

review was reviews.

Pretty cool, isn't it?

We'll go over and change this if it's wrong but

first let's navigate to the /courses.

Let's see what happens.

Courses is empty.

It's not very fulfilling without data, is it?

We should do something about that.

Nice job on getting the abstract entity all set up and

removing that code duplication.

It's pretty impressive that the API just worked, isn't it?

Now I know we need to get some data in there to make you even more impressed.

But one thing that you might have caught from those mappings that we saw in the log

at boot up is that we can actually send a POST request and

this will create a new course.

But before we dive into that work,

let me show you a pretty great way to prepopulate your app with data.