It's time to wrap up the controller's method for uploading,

before testing this whole upload functionality in the browser.

Now we'll first need to autowire the service, so I'll do that up top.

Autowired and we'll add a private GifService and I'll call it gifService.

Great.

Then we can return to the add gif method to finish our uploading work.

I'm going to use the structure feature that i showed you earlier,

addGif, and there is that method right there, cool.

To save the GIF entity, we'll invoke the services save method,

passing it the GIF entity, as well as the multipart file object.

As for the GIF entity, we can add it as a parameter here and

Spring will automatically reassemble the form submission data into a GIF entity, so

I'll add that right here.

And now let's call the services save method.

We'll do that right here.

So we'll call gifService.save,

we'll pass the GIF object that this controller method received, and

we'll pass the multipart file object that this controller method received as well.

After we save, we should include a flash message indicating that the save completed

successfully.

So, let me add a comment for that.

We'll add a flash message for success.

So, as I try to do that,

I realize I don't have access to a redirect attributes object.

That's because it's missing from my parameter list here, so let's add that

redirectAttributes and I'll name it the same thing and there we have access to it.

RedirectAttributes.addFlashAttribute, remember we call that attribute flash

and the object will add is a new FlashMessage object.

Here, we'll Type a status of GIF successfully

uploaded, or whatever message you like and don't forget the status.

So that's going to be FlashMessage.Status.SUCCESS,

cool, semi-colon.

As for the re-direct, let's send the browser to the newly uploaded GIF's detail

page, which is /gifs/ whatever the ID happens to be.

Here's how we'll do that, in place of null, I'll use the String.format function

and I want it to redirect to /gifs/ and

then what ever that ID happens to be.

And what is that value that we want placed in place of this placeholder right here?

Well, gif.getId.

We can get the entity's ID by calling it's getId method, and this will return a value

now because it will have been persisted to the database following this save up here.

The hibernate session save method takes care of updating the ID field for

us using it's setter, so we don't have to do that explicitly.

Now there are two more items we need to take care of in the controller.

The first is fully implementing the method for a give detail view.

Since that's exactly where we're redirecting to,

right here we're redirecting to the gif detail view /give/ whatever that

ID happens to be 1, 2, 7, 13, 1834, whatever it happens to be.

So we'll need to code that controller method that handles the detail view.

And the second thing we need to do is to make sure we're able to serve the GIF's

image data so that when it's referenced using an img tag in HTML,

our app can properly serve the image so the GIFs that the users so

enthusiastically uploaded can be displayed.

Let's work on the GIF detail view first, and

that is rendered by the GIF details method up top here.

Now that we have a findById method in our gifService,

we can invoke it here with our autowired service.

So we'll say gifService.findById, and

we'll use that gifId that we received in here, gifId.

Now for the second piece that is the actual image data,

which is right below this one in this gifImage method right here.

We need to fetch the GIF in the same way we just did in the method above.

So let's first grab the GIF entity using the service gifService.findById,

let's use that GIF id that's given as a parameter value there, and gifId.

Cool.

And then, let's return the byte array from the entity using the getBytes method,

.getBytes.

Cool.

And that should do it.

Notice that I have applied the response body annotation here.

What this tells Thymeleaf is that this return value here

constitutes the exact response body that should be sent with the HTTP response.

That is,

we don't want the Thymeleaf template engine to render any sort of view here.

We want Spring to use exactly this return value as the response body,

instead of timely doing extra processing using a template.

This will return the byte array which will then render in the browser view.

Now, if we've been careful enough along the way, we now have uploads working.

So there's only one way to find out.

Let's test it!

So I'll make sure to save all my work here,

make sure you have your database server running.

I'm going to kill my last instance of the app and

I'm going to re-run that Bootrun task.

I've got my toes and fingers crossed for successful compilation,

there we go, and hopefully everything starts up as it should.

The application has started successfully so let's switch to Chrome and

check it out.

We've got our upload form here which is looking good.

So what I'll do here is all upload a GIF that was originally used in Spring Basics.

I'll browse it, it's in my Downloads directory.

Yes, how about this one, android-explosion?

I will open that.

I will call it Android Explosion,

looks like I've used that one before, and let's select a category.

How about Technology?

Cool, let's hit upload and see if it works.

Hey, look at that, it worked!

Now if you're seeing any sort of error in the browser make sure you head back to

your IDE, IntelliJ in my case, to see the full log of errors in your IDE's console.

That was no trivial task that you just accomplished.

Adding a file upload feature to a web application is a common feature, but

the steps needed to do so can sometimes be complex.

So, getting this to work is something you should be proud of.

I know I am.

There are various considerations that need to be made with file uploads,

namely making sure we limit the size of the files we allowed users to upload and

ensuring that malicious files are not uploaded.

And this can be accomplished by checking to see if the file is indeed a GIF.

This kind of data validation requires us to leverage the custom validation

capabilities of the Spring framework, which is outside the scope of this course.

Check the teacher's notes for more information and know that you'll have

a feature that's waiting for you to address when we're all wrapped up here.