Well, it is that time again.

It is time to define our model.

So we know we will have a course model object, and

we also know we will have a review model object.

Now each course will possibly have many reviews.

Now you might recognize this type of model relationship as one to many.

One course, many reviews.

Let's do some modeling.

Okay so let's make a new IntelliJ project and let's make it Gradle based.

So I'm gonna click Create New Project and

I'm gonna make sure that Gradle is checked over here.

And I'm gonna click Next.

And for the Group ID, let's make that com.teamtreehouse.courses.

And for the artifact we will call this course reviews.

Right, we're writing reviews for courses.

Click next.

We're going to go ahead and make sure that we check the create directories for

empty content routes automatically.

I’m going to click next.

And we will keep it in the same place in the home directory.

Click finish.

Okay, not let's create our model object.

So if you open up over here under the source directory main Java,

we'll right click.

Choose New, Java Class.

Then we wanna blow that all the way out.

We wanna say com.teamtreehouse.courses.model and

first we'll build a thing called Course in the model package.

Okay, so our database that we're going to eventually use is going to use an internal

identifier for a primary key.

But this is common amongst just about every one of these things.

So we're gonna make a thing here called id.

And this is common practice, it's either a long or an integer.

So we'll make an id, and, what else will a course have?

A course will have a name.

We'll also have a URL, right?

So, it'll be the name of the course and the URL of where to find it.

All right. So let's go ahead and

generate our constructor.

So I'm going to go Code Generate and again that's Command N on a Mac

and we are going to generate a Constructor.

And for now let's just leave the ID out.

Right. We can just make a new course with name in

url, because it's an integer it will just be zero until it get's set properly.

Okay and then let's go ahead and let's add our getter's and our setters So,

we'll generate getters, and setters, and we will generate for all of them.

That's fine.

And, let;s go ahead, and while we're here, let's also do the equals, and hash code.

Might as well, right?

It's gonna write the code for us, might as well let it.

So, we're just gonna use the IntelliJ default.

We will use all of those.

Those are all expected in the fields that are non null.

They're both not null right?

We should always have those.

Okay, and now very similarly, let's make our review object.

So we'll do new, Java Class and we're in that same model directory, model.

And we'll say review and again this will also have an id.

So I'll do private int id.

And for now, lets just store the parent courses id.

You know you never want to go over board unless you end up needing it.

Like we could actually put a course in here, but for now,

let's just stick with the id.

That's what we're going to do, right?

We're just going to use this id.

So remember, keep it simple, smarty pants, K-I-S-S.

All right.

So it's private int, and it's a course id.

And that's going to refer to the course that we are writing a review about.

So we've got a rating.

And we also have a comment here.

Okay and very similarly lets go ahead and lets do our generating.

We'll generate a constructor.

Lets make the course id required, but not the id itself.

We'll let the dao objects take care of that later here in a bit.

So and now we will make getters and setters.

Lets get for all of them.

And also let's make the equals in hash code when we're in here just to play nice.

Okay those should all be included,

all those should be included the non null field.

Yeah comments could probably be null.

All right.

So now you can see that the review has a reference to the course id

simply by the way of the id.

Now, we have made it required for creation.

You can't create a review without having a course id.

All right, so we just created our plain, old Java objects, and now,

we need to create a way to serialize those.

I had mentioned that we are going to be using Sequel, and more specifically,

we'll embrace the classical design pattern of data access objects, or dao.

Let's get that all ready to rock right after this quick break.