Hey, great work over those last few videos.

You now have three application layers,

and hopefully a working implementation of those layers for category.

We have plenty of work left to do in giflib, but

we should fire it up now to make sure we're on the right path.

With our interfaces and implementations for category DAO and

service in place, and with our auto wired service in the category controller,

let's fire up our application.

Now, I'm assuming that your database server is still running, and

you've already inserted a row into the category table.

If not, we'll insert a second row in just a moment.

With that said, I'm gonna go ahead and run my boot run task.

If your server is still running, go ahead and hit the Stop button and

then you can rerun the task and let's see what happens here.

To make sure that everything compiles successfully and

that the spring application boots successfully without exceptions.

Looks like my application did indeed start successfully.

So let's switch to the browser.

Let me refresh this categories view to see if I still get my one category to display.

When I refresh and looks like I still successfully

grab that category using my new service DAO pattern.

Now, how about we switch to that H2 web console and

see what happens if we insert another row into the category table.

So I will go back here.

And let's do insert into category (name,

colorcode), we'll insert the values.

I'll put Java, remember that's a string.

Don't forget the single quotes as well as the hexadecimal code for

this color or whatever color you like, 35986.

Let's insert that, we'll run that.

If you get this message that simply means that your session has expired and

all you have to do is log in again.

Of course, you're gonna have to run that query again.

insert into category (name,

colorcode) values).

Get my codes in their first ('Java'

#b35986, let's try that one more time.

Cool.

Update count is one which means my row was inserted.

Now, what should happen is that when I flip back here and refresh my page,

I should see both of those categories technology and Java.

There it is.

Now, you might be wondering why the colors are the same since we

definitely chose different color codes for these categories.

Well, it's all about how the HTML and CSS is coded in this case.

And for this particular piece, the color is specified in the time leaf template.

And just so that we don't go too far in this course before interacting with our

timely views, let's open that now to prove that we can make noticeable changes.

So I'll switch back to IntelliJ, and I'm going to open the category Index Template.

So under templates, and category, let's open that index template.

Now, if we scroll down here, you'll eventually see a div

with a static background color set in its style attribute.

Now, you may have learned the rule of keeping your styling in your CSS files and

out of your HTML if you've done any front-end work.

But as with any rule, there are certainly exceptions.

If there is user data that's used to add custom styling to a page,

such as is the case here with a user specified color, this may be one of

those few scenarios where it's common practice to place that within the HTML.

In this case, we can prefix the style attribute with th or like this.

So that timely for process this attribute.

And you sometime leave concatenation to combine the background color with this

category objects color code field value.

So to trigger concatenation, we can use the vertical bars or the pipe symbol.

And instead of this statically set code we can place this expression,

cat.colorcode.

Now, let's save this template and reboot our application.

So I'll stop this spring app.

Let me trash that output there.

And I will rerun the boot run task.

And give it a moment to compile and to boot.

And let's switch back to the browser and refresh so I'm back here and

I'm going to refresh.

All right.

Look at those colors, pretty cool.

We've now touched all the layers of the apple both in the MVC architecture

as well as within the service DAO pattern.

In the next stage, we'll add a whole bunch of features to our app, allowing our

users to interact with the underlying data via our nicely designed user interface.