Okay, so we have a common problem.

We have used the consumer functional interface, and

it unfortunately doesn't throw any exception.

And so therefore, we have to cover that in our lambda ourselves.

So we can make our own functional interfaces, and

this is one solution to the problem.

And I think you might like it.

So let's take a look at it.

So I'm gonna open up the project window over here.

And let's go in under this database here, and I'm gonna make a new Java class,

and we are going to call this a ConnectionConsumer.

Right, so, the ConnectionConsumer follows the naming path of,

sorry, we're gonna actually make this an interface.

We're gonna say, public interface.

ConnectionConsumer, and we're gonna mark this with a functional interface, and

it follows the same naming structure, right?

So we have like a boolean consumer in the Java util function package, so

you kind of say what type it's going to do.

And we don't really want it to accept anything else, so

we don't need to make it anything fancy here, so we'll make a public void, right?

So the consumer doesn't return anything, so

that means it's all full of side effects and all that.

So we're gonna use the same word, right, let's kind of follow the same pattern, and

it's gonna accept the connection, and we'll call it conn.

And now we can say that this throws an IOException.

All right, so now we've made our own functional interface just like that.

And if we come back over to our method, or withConnection here,

how about instead of this Consumer, very specific Consumer,

let's just go ahead and call this a ConnectionConsumer.

All right, so now we have the ability, if we look in our application here, woah.

If we look in our application over here,

we have the ability to just let this bubble up, right?

Since we were already catching that over in the other ceremony from before, so

we can get rid of this try and catch.

And now if we go ahead and run this, we see that stuff still works.

And one of the things that I think is gonna come out of you switching to using

more functional interfaces are people are gonna say you know what?

Actually, why don't we just use results for each year, right?

And then we'll use System.out, and then we'll just put it right to println.

I mean, obviously, this is probably not what you're doing in your application, but

now you'll see that people are using more functional things there.

And now we're running again, doing the same thing.

But yeah, only two lines of code here, it's really clear what's happening.

Now, the other beauty of this is you can now have a single place

over here in your legacy database that you can innovate, right?

I can make this a pool, I could make this here, this connection here,

I could get this out of a pool, and I could push a connection in there.

And I could keep them open or closed, and I don't really need to worry about that,

I could change what happens in here.

And I could very easily add transactions, right, like I could begin the transaction,

and when it's done, it's done, commit it.

So it's pretty powerful, and we have followed the same structure,

it's really easy to make one of these.

And I think your team's gonna love you for stopping that dance.

So please share your feedback in the forum and also with me if you wanna review these

videos, let me know what you thought about this style of content.

Looking forward to giving you some more, thanks.