Our next order of business is to go the service for GIFs.

Let's start though on the controller, in particular, let's head to the controller

method that processes the new GIF submission and that is the add GIF method.

One quick note about a nice feature in IntelliJ and

other popular IDEs have this as well.

I have this Structure view, as opposed to the Project view in IntelliJ and

even if the files not open, with it highlighted, I can click structure.

And see a quick overview of that class and I mentioned the addGif method.

So if i double click on that,

that file opens with the cursor placed directly in the method I just clicked on.

Pretty cool.

Now, in order to capture the file data upon upload will need to add

a MultipartFile parameter to this method.

MultipartFile right there, I'll name it file.

And to tell Spring that this is a value that will be passed via the HTTP request

as a parameter in the payload we'll annotate it with the request param

annotation.

@RequestParam just like that and

this annotation definitely offers a name attribute.

You can specify a value for the name in there,

if the name coming from the HTML form differs from that of the parameter name.

But if I leave this off, this parameter name will be used by default.

So I'll leave it there because I know in my HTML form.

I used file as the name attribute on that input element.

So cool, we now have access to the file data.

The work we have left to do is to code a GIF service and

GIF TAO to handle the savings that we can call upon the service from the controller

to save the uploaded GIF.

Then, we'll return to this controller to wrap up its code for uploading.

Let's start by creating the GIF service.

So I'll go back to my project view.

And in the service package, I'll create a gif service

as an interface, GifService.

Let's add methods in here that we can use to do the same sorts of things that we did

in the category service.

So we'll add findAll, findByID, save and delete methods.

Here we go.

We'll make the findAll return a list of GIF objects,

Make sure you import all that stuff.

Let's import this with option enter,

there we go, also import the list interface java.util.

It's not always the first choice as you can see.

Cool, next, I will return a single GIF object with

the findByID method which accepts a long parameter value.

And then my save method will accept two parameter values,

a GIF and a multi-part file parameter.

And then, I will include a delete method as well.

Excellent, now I notice how I added this MultipartFile parameter to the save method

instead of using only a GIF parameter.

This is because currently our GIF entity does not include the MultipartFile

data our controller will have received.

So will let the service combine the two and I'll show you

the fairly brief code that's required to make this happen in just a bit.

Now, let's create the implementation class for this and annotate it with service.

So I will create a new Java Class, call it GifService.

This is the implementation i'll name it Impl and

let's annotate that with Service.

Next, I'll implement the GIF service interface.

Implements, GIF service.

And I'll add all of those unimplemented methods.

Let's use Option, Implement methods.

All of those that are not currently included, cool.

Now just as we did for the category service simple we'll auto wire a DAO

here but this time it's a gif DAO.

So we'll do @Autowired.

Private GifDao gifDao.

Now we're coding in the reverse order as we did with the categories so

this DAO is right here gifDao does not exist yet.

No worries though.

We'll add it in just a bit.

Let's finish our work here first.

So in the find all method, we'll simply call upon the find all method from the DAO

which we'll code in just a bit.

So gifdao.findAll.

And next, in the find by ID method,

we'll call upon an identical method in the DAO was well,

gifDao.findById and will pass along that ID parameter value.

Now let's jump to the delete method and

do the same before returning to the save method.

So here we'll just do gifDao.delete Gif.

Now, back to that save method.

I said we'd have the service put together this multi-part file data and

the GIF entity, before persisting the GIF entity.

To do this, we'll use the gif's setBytes method and

pass the bytes from the getBytes method of that multipart file parameter.

Here's what i mean.

We'll say, gif, that's the entity we'd receive, .setBytes,

there's the setter that came from our entity.

And the bytes that we wanna use come from the file, specifically file.getBytes.

You'll notice here that you're going to either have to make this method throw

the java.io.IOException here.

Or you're gonna have to surround it with a try catch.

Let's go ahead and surround it with a try catch here.

So I will surround with a try catch.

Cool and right here,

all says' instead of printing the stack trace all do system.arrow.print one.

And I’ll say, unable to get byte array from uploaded file.

And now that the GIF object will contain everything it needs to persist it's dated

to the database.

After that called a set bytes here, let's call the DAOs save method.

So gitDao.save(gif).

All right, that's it for the service.

Next, we'll tackle the DAO and that will get rid of all the compiler

errors we're seeing here since we're coding in the reverse order.