Spring Boot Tutorial for Beginners (Java Framework)

Hi, welcome to amigos code. My name is Nelson. 
And in this crash course, I'm going to teach   you everything you need to know about Spring 
Boot Spring Boot. It's an amazing framework for   building Java applications very fast. Recently, 
Netflix just announced that they'll be switching   their entire back end to Spring Boot. And this 
is because Spring Boot is so solid, that there's   no need for you to reinvent the wheel. So they 
provide things such as connectivity to databases,   jetty servers, metrics configuration, and pretty 
much instead of you having to configure the low   level code to get up and running, you can simply 
use Spring Boot and get off the ground very   quick.

So first, I'm going to show you exactly 
how to use Spring Boot dependency injection,   and how to implement to an interface where we will 
have an in memory database, and then I'm going to   show you exactly how to connect to a real database 
running on Docker. So without further ado,   let's get started. Alright, amigos, welcome to 
amigos code. In this video, I want to teach you   exactly how to use Spring Boot 2.0. Spring 
Boot is by far one of the best frameworks   for building applications in the Java world. So 
if you want to build an enterprise application,   you can use Spring Boot, or if you want to 
prototype an idea and see whether you know,   it works that you can use Spring Boot because 
it makes it very easy to build applications.

And   basically, Spring Boot provides you a platform for 
building back end applications. And not only that,   you can also build web applications as well. So in 
this video, let's go ahead and build this awesome   API, where any client can submit a request. So 
these requests could be a get request, post,   delete, and put. And then we're going to take 
that request, and within the API layer or control   layer, so this is where we receive the requests, 
we're going to send that to the service layer.

And   basically, the service layer is responsible to 
handle all the business logic that you may have   within your application. After you perform some 
business logic, then you might decide to use a   database to perform some various CRUD operations. 
And basically, so this layer right here,   so this layer is responsible to connect to any 
database of your choice. So the cool thing about   Spring Boot and dependency injection is that you 
can start with an implementation. And then if   you want to switch to a different database, you 
simply have to change one line of code. And I'm   going to show you exactly how to do that with the 
pendency injection. So after you submit the actual   request from any clients, so the clients could 
be an iOS app, a react or even an Android app,   the request will go through all these layers, and 
then go back with a response to the client.

So the   response could actually be, for example, a JSON 
payload, or an image, or a status code of 200 500,   so on and so forth. So if you want to learn the 
best framework for building Java applications,   stick to this video, because there is a lot to 
cover. And I'm pretty sure that after this video,   you will be very comfortable building back 
end applications with Spring Boot. So let's   go ahead and get started. So the very first 
thing that I want you to do is to navigate   to this website start.spring.io. And basically, 
this website, you can see that it's it's titled   spring initializer. And basically allows 
you to bootstrap your application by picking   dependencies and configuring the actual project. 
So go ahead and generate a project with Maven,   we can see that you can be Gradle. And then 
you have the option to code with Java kotlin   or groovy. So I'm gonna stick with Java. And then 
for the actual version, make sure that it is above   2.0.

So I've got a video on 1.5. And basically, 
I just want to make sure that you guys have the   latest version, so that you can use it within 
your latest projects. So then go ahead and click   on this link right here. So switch to the full 
version, basically, right here, you can, you know,   configure your project metadata. So go ahead and 
change these according to your company or project   name. But for this tutorial, I'm going to leave 
everything as is apart from the Java version.   So I'm going to pick Java 11, because I do have 
it installed.

But if you don't have Java 11 go   ahead and pick Java eight because it will also 
work. Then, if you scroll down, you can see that   right here you have a bunch of dependencies. And 
this is why springboard is pretty much one of the   best Java frameworks for building applications. 
So they give you a lot of flexibility with these   dependencies, which simply means that you can 
install one of these dependencies and start coding   right away instead of you having to configuring 
and you know, setting up things.

So basically,   you just have to install these dependencies, 
and then start implementing whatever you want.   So you can see that we have a bunch of sections 
right here. So web server web applications with   spring MVC, and Tomcat at jersey WebSockets, 
template engines, security, so they make it very   easy for you to configure security within your 
applications. So you know, it saves you the hassle   of having to implement security the right way. 
So basically, they're doing the difficult job,   which is implementing the security, and then 
giving you this nice package that you can just   plug in play. And then you have SQL, so my sequel, 
h2 JDBC, Postgres flyway for database, migrations,   Mongo, and then you can scroll down, you can see 
that they have a lot of great things.

So for this   video right here, let's go ahead and focus on 
picking this dependency right here. So web server   web applications with spring receipt and Tomcat. 
So I'm going to take that and then generate a   project. So right here, you see that I've got 
this demo zip, which I'm going to open in my   desktop. There we go.

So now I'm going to click on 
this zip folder. And if I delete the actual zip,   you can see that now I have this folder right 
here. So for this video, I'm going to be using   intelligence, which is by far the best ID. And if 
you want to learn about intelligence, go ahead and   check my video on YouTube, which I show you how to 
download, install and configure IntelliJ properly.   And if you are using NetBeans, or Eclipse, this 
will also work. So inside of IntelliJ. So I   actually recommend you to download and install 
IntelliJ if you don't have it to follow along,   and I'm pretty sure that you're going to learn 
great things with IntelliJ throughout this video.   So what I'm going to do now is pretty much click 
on open. And then navigate to desktop, and then   open up this demo folder, and then open up the 
actual POM dot XML. So I'm going to open that up,   and then open as project.

So I'm going to allow 
and just give you a second, Maven is resolving   the dependencies for this project. There we go. 
So that's nice and done. So let's go ahead and   explore this project. So open up demo. And inside 
demo, you can see they have couple of folders,   but the ones that we really care about are 
the palm dot XML. So if I open that up,   and see that this is what you saw when configuring 
the project with spring initializer. So you saw   the group ID artifact, name, and then version. 
So this is the version right here. And then this   is Java 11. Basically, the actual dependency 
that we picked was this one right here.

So   Spring Boot starter web. And by default Spring 
Boot ships with Spring Boot starter tests for   writing unit and integration tests. So go ahead 
and close this because we don't need it. And open   up the source folder. So open up source, and 
then main. And you can see that you have Java,   and then inside you should have a class called 
demo application. And inside of this class,   you have this public static void Main method. 
And this is how you pretty much just run your   spring application.

And if I play so make sure you 
play this. Just give me a second. You should see   that I have spring up and running and you can see 
that it says that Tomcat started on port 8080. So   right here, we could change this port but this is 
the default port for Tomcat. So I'm going to stop   this and you can see that everything is up 
and running fine. I'm gonna stop this and then   collapse this.

And then inside of resources, you 
have static templates and application properties.   So start is where all the web resources 
live for web applications. And then you   have templates. And this is where you have all the 
templates for your web application. So usually,   you would use something like mustache or ej s. And 
then you have this application that properties.   So this is where all the properties for your 
application do live. And the cool thing about   properties is that you can define properties for 
different environments. So you could have a demo   environment, a test environment and a production 
environment with different values for the actual   properties. So it's pretty cool. So I'm going 
to cancel out of that.

And now that you know   the actual structure and make sure that you can 
start the application, you've successfully managed   to start a Tomcat server with Spring Boot. So 
now let's go ahead and implement our API with   all of those resources, controllers, services, 
and defining a database as well. So if I go back   to this diagram, so remember that I said we had 
the API layer controller, or controller layer,   and then we have service layer for business logic, 
and then database for data access. So let's go   ahead and start things right here. So we're going 
to start right here.

And in fact, this I mean, put   a dot right here, so you know what we're doing. So 
if I remove that, basically, let's put just a.so,   we know where we are, with things. So right 
here. And then if I collapse that, so basically,   we're going to implement this section first, 
and then move our way up. So basically, we're   going to implement one step at a time, and then 
see everything working fine, and then implement   some other functionality. So let's go ahead and 
go back to IntelliJ. And the first thing that I   want you to do is to create a package. So let's 
go ahead and create a package. And right here,   simply call it API. So this is where the API 
will live. Go ahead and create a second package,   and simply say, model, go ahead and create 
a third package, call it service, go ahead   and create a fifth package or actually a fourth 
package and call it so we need the actual da Oh,   and I think this is it.

So we have API d o model 
and service. And basically these packages are   representing this diagram. So if I go back, and 
perhaps you haven't seen me, like right clicking,   so new, and then a package. So basically, I tend 
to use a lot of keyboard shortcuts. And this is   how I am productive with IntelliJ. So if I press 
Ctrl, and then enter, you can see the keyboard   shortcut down below. And basically, then that 
gives me the ability to create a new package.   So the same if I, for example, create a variable. 
So if I say var, and then ELO equals to two. And,   and then if I press Command, and then why you can 
see the keyboard down below, right? So I've just   deleted that line.

So also, let me go ahead and 
say, Okay, so now what we need to do is actually   define our model. So what is the actual model for 
this application? So if I go back to this diagram,   so let's go ahead and define a model. So I'm going 
to copy this stereotype. And you can grab this   diagram, you can find the link in the description 
below where you can download and see exactly,   you know, everything that we're doing here. So 
basically, the actual model, so oops, so the model   for this tutorial will be a person. And basically 
a person will have an ID. So when ID. And let's   keep things simple and have like, let's say a full 
or actually name, just like that. So obviously,   you could have more properties. But I want 
to keep it simple for you see exactly what's   happening. And so things you know, become really 
obvious to you. So we have this model right here   called person. Let's go ahead and define this 
in actual code.

So go back to IntelliJ and in   side of the model package, go ahead and create 
a new class and simply call this person. Right,   so the kind it's a class, and then press enter. 
So now simply go ahead and say private final, and   then the ID will be of type U ID. And simply call 
the Id go ahead and simply save private final,   and then string. So this is the actual name. And 
then I'm going to add these two constructors. So   you can see I'm using keyboard shortcuts again, 
and then the getters. So just like that, and there   we go. So now we have a model that we can work 
with. So if I go back, so now we have to define   the actual database section right here, right, so 
let's define the actual interface that will allow   us to have any implementation for our database. So 
inside of the DA, Oh, go ahead and create a class,   and then simply save person and then the A Oh, 
so instead of like class, change this to an   interface.

And this is the actual interface where 
we're going to define the operations allowed,   or the actual contract for anyone that wishes to 
implement this interface. And the cool thing about   it is that we can then use dependency injection 
to switch between implementations with just one   line of code. So let's go ahead and define our 
very first method. So for our database, we want   to insert a person into the actual database. So 
we will simply return an integer. And basically,   we're going to mock a database using like a 

And basically, we will return zero or one   depending whether the actual data is persisted to 
the actual database. So let's simply go ahead and   say insert, and then person. And this will take 
a user ID, which is the actual ID, and then a   person just like that, and that with semicolon. 
Now, let's also go ahead and create a default   method. And basically, this will be the same 
thing, or actually sorry, this will be integer.   So it will be the same thing. And let's simply 
call this ad and then person. And right here,   we will simply take person, right. And what this 
allows us to do is to actually generate the you   IDs, ourself, or the actual ID, so you would, and 
then let's call the ID equals two, and then UAT,   dot and then run the mu ID, and then simply say, 
return. And then insert person passing the ID, and   then the actual person.

Yep. So basically, we have 
two methods, one that allows us to insert a person   with a given ID, and the other one without an ID. 
And the ID is simply randomly generated. Now let's   go ahead and create a class that will implement 
this interface. So open up the DA o package,   and then simply create a class and call it person 
and call it fake. And then person data, access,   and then service.

And then this guy implements 
and then person, da, oh, just like that, and then   implement the methods. And we need to implement 
insert person, right. So right here, let's go   ahead and define our list. So private, and then 
static. And then and then list. And this will be a   list of person, simply quality b equals to a new, 
and then array list just like that. Or, in fact,   we could even initialize this inside of a static 
clock, if we wanted. So now to insert a person,   all we have to do is simply add to this database 
right here. So for the sake of this, simply go   ahead and say dB, dot and then add, and then new 
and then person and simply take the actual ID,   and then simply say person, dot and then get name. 

So And finally, let's simply go ahead and   return one. So we know that it always works. So 
the insertion always works. So now let's go ahead   and actually define the actual service. So inside 
of the service package, go ahead and create a new   class. And then simply call it person and then 
service. And right here inside of this class,   let's see if we have a method to insert a new 

So simply go ahead and say public,   and then int, and then and and then person. And 
basically, this will take a person. And what we   want to do is simply say return. And right here, 
we need to actually get a reference of the actual   person, da Oh, so let's go ahead and simply say, 
private, and then final, and then person, da, oh,   and make sure that you get the actual interface 
and not the concrete class. So don't get the   actual fake person data access service, because 
I want to show exactly how to use dependency   injection. So then what we need to do is added to 
the constructor. And now we can simply say person,   da, O dot, and then insert, and then person. So 
remember, we had two methods. And if I go back   to my interface, so person to you, oh, and in 
fact, I need to call this the same. So let's be   consistent. So person, so insert person, actually. 
So now you can see that the error went away. So   basically, we have the option of providing the ID 
or not. So in this case, let's go ahead and have   it, you know, randomly generated, because we don't 

But if you need to generate the ID yourself,   you know that you can do it. So now that we have 
the service done, let's go ahead and implement   the actual API. So inside of the API package, go 
ahead and create class, and simply call it person.   And then resource. Or actually, let's go ahead and 
save controller. So in Spring Boot world, we tend   to name these as controllers. So and then simply 
say, OK, and then let's go ahead and also have   a reference to the actual service. So private, 
final, and then person service.

And then right   here, we need to add this to the constructor. And 
then let's simply go ahead and have a method that   adds a person, so public, and then simply say, 
void, so we don't want to return an integer in   this case. So we want to, so we want to return 
a status code of 200. Or if anything fails,   we can pretty much throw an exception. So or 
you could also have your custom exceptions,   if you wish. So let's go ahead and simply say add, 
and then person. And this will take a person, so a   person just like that. And then what we need to do 
is actually say person service, dot and then add   person, just like that. So up to this point, we 
simply have normal Java classes. And to be honest,   we're not even using spring framework at this 
point. So let's go ahead and configure everything   to start using spring framework. So let's go ahead 
and open up the actual da Oh, so fake person data   access service. And you'll see right here inside 
of the actual service, we have a reference to it.   So person, da O.

And basically, we are trying to 
use dependency injection. So if I was to run this,   this would wouldn't work because this person 
deal is not instantiated. And you know,   there's no way for this constructor to know about 
it, right. So this is where we use annotations to   instantiate beans. So open up the fake person 
data access service. And the way that we tell   spring that this class needs to be established, 
created as a beam so that we can inject it   in all the classes is simply by saying act and 
then repository. Right. So you could also say add,   and then component. So this is the exact same 
thing. But repository makes it obvious that this   class is served as a repository. Right. So now 
that we have a repository, let's go ahead and   configure the actual service. So for service, 
you might take a guess. So this will be add and   then service. Right. And you could also use a lead 
component if you wish.

But I usually prefer to be,   you know, specific. So anyone looking up my code, 
know exactly that this is a service. So now that   we pretty much annotated the actual data access 
service, and right here we are injecting right   so we are injecting into the actual constructor. 
So the way that we inject is simply saying add and   then auto wired. So basically, we are auto wiring 
into this interface, right. So now, because we can   have multiple implementations of this interface 
right here, we must have a way to distinguish   between them, right. And this is when use at 
and then qualifier, right? So add qualifier.   And then right here, you can give it a name, so 
fake and then da O. And basically, I need to go   back to my fake person that access service.

then right here, I'm going to name this as fake.   And then da O. And what this allows me to do is 
to have multiple implementations. And basically,   all I need to do is for example, if I have, for 
example, a Postgres or a MongoDB implementation,   I simply say Mongo, just like that, and then 
I don't have to change anything. So let's go   ahead and use the fake da Oh, and now this is why 
it's correctly. So finally, let's go ahead and   open up the actual API package. And then personal 
controller. Let's also go ahead and simply say,   at an auto wired, basically, springboard injects 
the actual service into this constructor.

And   if you want to learn more about dependency 
injection, go ahead and check my channel,   I made a video specific on dependency injection, 
and why it's important for you to know about it.   So now, remember that I said that this class right 
here, so the API, if I go back to our diagram,   is this one right here. And right here, we 
can specify HTTP methods. So get post, delete,   and put. So these clients right here, right, so 
they have to issue some requests to our back end.   So right now, there is no code that tells that 
this method right here will be served as a post   or put or get or delete.

And also, this class is 
not available as a rest controller. So to do that,   we need to use a special annotation and simply 
say, add, and then rest controller, right. So   this is a rest controller class, that we can have 
some methods, and then expose some endpoints that   clients can consume. So in our case, what we 
want to do is have this method right here to   be served as a POST request. So basically gets is 
for retrieving data from your server posts is to   adding a resource to your server, put modifying, 
and then delete for deleting a resource,   a resource from your server.

So to tell spring 
that this method will be used as a POST request,   we'll simply use the annotation at and then post 
and then mapping. And this is all we have to do   now. So obviously, we want to add a person from my 
client, right? So go ahead and download postman.   So postman allows you to pretty much just serve 
as a client, because we don't have, for example,   a react application or an Android app, or you 
know, you we don't have any, any any client,   right. So we can use postman as our client, right. 
So go ahead and download postman, it's an amazing   client. And what we need to do is actually send a 
person to our server. So before we do that, so let   me actually clear everything here.

And basically, 
go ahead and say post, and then this will be local   host, column, and then AD AD. And then for slash, 
and then simply say API, forward slash, and then   v1, and then person, right. So after you define 
the actual endpoint, go ahead to the actual body,   and then simply say raw, and then instead of text, 
go ahead and send a JSON. So we want to send a   JSON payload to the actual server. And remember, 
we have name, and let's say that this is James   and then bond. So basically, we want to send James 
Bond to the server. So in order for us to do that,   we have to do few things. One is we have to define 
these properties in our pojo so that when we send   this JSON spring knows to take this property and 
then convert that into a jar. Have a class, right.   So in order for us to do that, what we need to do 
is open up person. So inside of the model package,   open a person.

And then you'll see right here in 
the constructor, let's go ahead and define some   properties. So JSON property, and this will be 
the ID. And then right here, so if I put this on   your line art, and then Jason property, and this 
will be the actual name, right? So you could also   define more properties. But as I said, Let's keep 
this simple so that you understand exactly what's   going on.

So if I open a postman again. So right 
here, you see that name. So this name right here   matches the property that we have in our class 
person. And if we wanted to send the ID, so we   would simply say ID and then pass, you know an 
ID, but we are generating the ID from the server,   therefore, we don't need to send it.

Now what I 
need to do is actually tell that we are receiving   this JSON payload from the actual body. So inside 
of person controller, go ahead, and you see right   here where you add a person. So right here, simply 
annotate this with ADD, and then request. And then   body, right. So we are simply saying that we 
want to take the request body, and then shovel   that inside of this person. And then because we 
have, so right here, so because we have these,   this property right here, we will simply turn 
this JSON object into a person.

That's what   we're saying. And the final thing that we have 
to do is actually define this path right here,   right? So right here before rest controller simply 
say at and then request. And then mapping. And the   actual mapping will be API, v1, and then person. 
So this is all you need to do in order to create   your very first endpoint with Spring Boot. Now, 
what we need to do is actually test it. So let's   go ahead and simply play the application. So as 
you can see, Tomcat started on port 8080. Now,   if I open up postman, and then simply send this 
request right here, you can see that we have a   200 status code. And this means that the request 
went through fine. Now, obviously, we don't have a   way of testing this, right, because we don't have 
an endpoint to retrieve people from our database.   So let's go ahead and define the functionality 
to get people from our database. So let me go   ahead and open up the IntelliJ. And if I collapse 
that, so go ahead and open up the person da Oh,   and let's go ahead and say that this will return 
a list of person and say, select all people.

And   then let's go ahead and open up the person data 
access service. So we need to implement that. And   then right here, what we need to do is very simple 
within the actual database, and open up service.   So right here, simply create a method public. And 
then list of person, get, and then all people and   then this will return person, the Oh, don't and 
then select all people. So now we need to define   the actual resource or the actual method that will 
serve as the get request. So simply say public,   and then a list of and then person and then get 
all people and then what we're going to return   is the actual person service dot and then get 
Oh people, right. So now we need to tell that   this method will be served as a get request. 
And the way that you do it is simply by saying   add and then get and then mapping. So you see 
that everything has the same pattern at the post   mapping at getting mapping.

Now, let me go ahead 
and pretty much just restart the server There we   go. So the actual server started on port 8080. So 
open up postman. And then let's actually try and   send the actual same request. So we're going to 
send James Bond can see that worked. And now let's   go ahead and try and perform a get request to our 
server. So the exact same URL, send, and there we   go. So you can see that we have an array with one 
person that comes from our database. So this is   awesome. Now let's go ahead and perform a nother 
post. So so right here, so change this to Nelson,   and then Mandela, you can change this to whatever 
name you want to be honest, I'm going to send that   you can see that it's 200. And then simply change 
this to Anna, and then Jones, send. And now if I   perform a get request to our server, you can see 
that we have three people. So James Bond, Nelson,   and Anna Jones.

So as you see, springboard is 
just incredible. It's super fun. And as you saw,   like, it didn't take us long to implement this 
functionality, right, we're just using annotations   to drive our implementation, which is awesome. 
And we can pretty much deliver results very fast,   using Spring Boot. Now, let's go ahead 
and implement the other two HTTP methods,   the ability to update a person, as well as 
deleting a person.

So open up IntelliJ. If   I collapse this, and then open up the actual 
da Oh, and let's define the actual interface,   or actual method. So right here, simply say int, 
and delete, and then person by ID. And right here,   we need to pass the actual ID, so you ID and then 
ID. And let's also define a couple of things. So   let's also define that we want to update a person. 
So this will return an integer, and then simply   say, update. And then person by ID. So right 
here, we're going to pass the actual ID and the   actual new person that we want to update, right, 
so person. And also, let's define one more method.   And this will be an optional of and then person. 
And then simply say, select person by and then ID,   and then simply pass the actual ID inside. And 
there we go. So now let's go ahead and open up   the fake person data access service. And we have 
to implement all of those methods.

So I'm pressing   Alt, and then enter, and then implement methods. 
And you can see that we have these two methods   that we need to implement. Okay, and error is 
gone. So in fact, let's go ahead and implement,   select the person by the first. So to implement 
this method, what we need to do is actually search   within our database and see whether we have a 
person with the given ID so this one right here,   so the way we do it is simply by streaming our 
database. So let's go ahead and use Java streams,   dot and then stream. And if you want to learn 
more about streams, go ahead and check my video   on Java streams where I cover this. So let's 
go ahead and simply say filter. And right here,   we get a person. And then let's simply say that 
person dot and then get ID dot equals to ID,   right. And then what we want is dot and then 
find, and then first.

And there we go. So now   let's go ahead and open up the actual service, 
and then simply implement the same method here,   so public, and then this will be an optional, and 
then person, and then get person by ID, and then   simply pass the actual ID. And you can see that 
it's almost the same thing that we're doing right   here return and then person do dot and then get 
or actually select person by ID, and then pass   the ID and then open up the controller. So person 
controller, and this will be a get so basically   We went to public. So this will be person and then 
get in then person by ID. And then we're going to   pass the ID, and I'm going to show you exactly how 
do we get that.

So Id, and then what we want to do   is simply say return. And then person service dot 
get person by ID, lowercase ID, and then.or. Else,   and then no. So right here, you could actually 
have a custom message or a custom exception,   or a custom code thrown to the actual client. So 
for example, a 404, with a message saying, user   not found, but for this video, let's go ahead and 
keep it simple and simply return now.

Right? So   now what we want to do is, if I open up postman is 
you see this ID right here, right? So I want to be   able to copy the ID, and then simply say, forward 
slash, and then pass the ID. And then when I send   the request, I should get that person back. Right. 
So the way that we get the ID from the path is by   simply using an annotation, and the annotation is 
called. So this one is at, and then path and then   variable. And the PATH variable that we want, is 
an ID. So Id, just like that. And basically, this   is a type right here. So now let's go ahead and 
define the actual mapping. So this will be add,   and then get and then mapping.

And now because we 
want to have the actual ID in the path, so inside   simply save path. And then what you want is double 
quotes, and then curly brackets, and then pass ID.   So basically, this will allow you to have forward 
slash and then some ID. And then right here,   you're simply grabbing the ID, and then turning 
that into a unit. Right. So let's go ahead and   test this. So if I pretty much just restart 
the actual server, there we go up and running.   So if I open up postman, now we need to issue 
some requests. So you can see that, you know,   every time that we restart the server, we lose 
everything from our list. That's a disadvantage   of having an in memory database. But for this 
video, you can see exactly how everything works.   So let's go ahead and send a POST request there. 
And then let's get everyone so remove the actual   you with there.

So send. So we have knelson, right 
there. And basically now we can grab Nelson's ID,   and then do a forward slash, and then paste that. 
Right. So now if I send, you can see that we   have only one object, right? It's not It's not an 
array, but it's an object. And if I was to change   the ID for something that doesn't exist, send, you 
can see that actually, it's a bad request. Because   the you with it's completely wrong. So it's not 
valid you with that I've just sent to the server,   but you get the idea.

So if I go ahead, and 
let's go ahead and add Anna Jones. So send,   and then let's get everyone, and let's grab 
Anna Jones ID right there. And then Ford slash,   send that. In, see that works. Right. And in fact, 
let me go ahead and say you wait generator, and   let me generate the unit. So I want one unit here. 
And if I grab this, and then go back to postman,   and then perform a get request with that up there. 
So if I delete everything, and then paste that   yo ID and then send you see that it's a 200.

we have nothing in our database without your ID.   Right? So as I said, so you shouldn't be throwing 
a 404 with a custom exception. But in this video,   you can see exactly that we are returning nothing 
because there is no one without you it against our   database. So let's go ahead and implement the 
remaining methods. So if I collapse this, so   Let's go ahead and implement everything in one go 
now. So open up the actual fake person data access   service.

And to delete a person, what we need 
to do is simply get the person if the person is   there, delete it, otherwise, return zero. So let's 
go ahead and simply say select. And then person by   ID, we're going to grab the ID. And remember, this 
returns an optional, so person, and then maybe,   and right here, I'll simply say, if, and then 
person may be dot, and then is empty. So if it is   empty, we want to return zero. Otherwise, what we 
want to do is actually remove from the database,   right, so if it's there, we want to remove so DB 
dot and then remove, and then person, maybe dot   and then get just like that. And then return one, 
right, so we know that we did delete this person.   Now let's go ahead and implement update person. 
So what we're going to do is simply say return and   then get or actually select person by ID, we're 
going to pass the ID.

And then what we want to   do is say dot and then map. So right here, we get 
a person, let's call it P. So P. And as I said,   if you want to learn about, you know Java streams, 
maps, operations filtering, go ahead and check my   YouTube video where I teach all of this. So now 
let's go ahead and try and get the actual index   of this person. So int, and then index of and 
then person to delete equals to and then DB dot,   and then index of and then pass the actual 
person, right. So now we have an index. So I'm   going to say if the actual index to the leat and 
I'm missing a knee right there.

So if the index   to delete is greater or equal to zero, what we 
want to do is actually set the actual person, so   we means that we found someone, right, so let's go 
ahead and say DB dot and then set and then index   of the person to delete, and then simply pass the 
actual person, right. And now what we can do is   simply return one right here.

So otherwise, so 
else, or we can simply say return and then zero.   And then right here, so because we need to return 
an integer, simply say don't, and then Or else,   and then zero. Right. So basically, if I format 
this, so basically, I'm saying select the person,   and then map that person to something else, 
right. And if the actual index of that person   is greater or equal to zero, we know that we 
found that person, and then set the contents   of that person to the new person that we've just 
received from the client, and then return one,   everything is fine. Otherwise, return zero. Or 
if select person by the is not present, we don't   do anything and simply return zero. So this is 
what it means. So now let's go ahead and simply,   you know, feed this through the service, as well 
as controller and then test it.

So let's go ahead   and simply open up pass and service. So let's 
go ahead and save public and then ain't delete,   and then person. And then right here, we're going 
to take the actual ID, so Id, and then this will   be very simple. All we need to do is simply say 
return, and then person do that. And then the lead   by ID pass the actual ID, and we're done. To 
update a person, sorry. So if I close that, so to   update a person, what we need to do is simply say, 
public, and then ENT, update, and then person. So   we're going to take the actual ID, so you ID and 
then ID and then this person is the new person,   so new and then person. Right? And then what 
we need to do, I simply say return personally,   oh Don and an update, and then Id right.

So you 
can see that I don't have much logic going on   here. Here. And this is because, you know, 
I'm just teaching you exactly how to use,   you know, Spring Boot to to create an API. But 
essentially, you know, inside of this service,   you will have whatever logic your application 
requires, right. So I'm just making this simple   for you to understand exactly. So you don't 
have a lot of code going on. Basically, you see   the entire process of what we're doing. So now, 
let me go back to the actual person controller,   and simply expose those to a REST API. So the 
first one is update, or actually delete. So let's   go ahead and say delete, so public, and then 
void, and then delete, and then person by ID,   we simply pass the ID, and pretty much the same 
thing at and then PATH variable.

And then this   will be the ID. And then we want that to be 
a u ID, ID. And then return, Oh, actually,   there's no need to return here, because this is 
void. So simply say person service dot, and then   the lead person passed the ID. Now this has to be 
guess what at, and then remember, we are deleting   a resource from the server. So delete, and then 
mapping. So now inside, we have to have the path,   and then the actual ID, right, so this ID is this 
one, right here, which we can pass down to the   service. So let's also go ahead and implement 
the actual update. So the update will be act,   and then put, and then mapping, and public. And 
then Floyd, and then update person. And then this   will take a person from the request body. So 
art, and then request body will take a person   to update. There we go. And now simply say person 
service dot and then update. And in fact, we also   need the actual path. So the path will include the 
actual ID. So Id, and let's go ahead and say that,   and then path and then variable.

pexels photo 4049876

And that will 
contain the ID. And this will be a user ID,   and then call it ID. And there we go. So now we 
can pass ID and then person to update. Right.   And to be honest, this is all we have to do to 
implement our REST API. So let's go ahead and test   it. So I'm going to pretty much just restart the 
server. So let me go ahead and open up postman. So   let's start with one person. So let me send this 
request. And then let me get everyone. So send,   you see that we have Nelson Mandela. So let's go 
ahead and change Nelson's name to something else.   So go ahead and simply create a new request. So 
go ahead and change this to a put and the body.   So instead of saying, Nelson Mandela, let's simply 
say that this is Alex.

And inquiring, right. And   now let's go ahead and simply pass Nelson Mandela 
right here. And basically, we're just changing his   name. So if I go ahead and send, you can see that 
the request did work. And now if I get everyone   from our database, so if I perform a get request, 
and then send, you can see that that didn't work.   And let's go ahead and debug this in a second. 
But for now, let's go ahead and pretty much try   and delete this person. So Nelson Mandela. So 
if I put forward slash and then the actual ID,   and then delete, and then send, we got 200. If we 
get everyone, you see that Nelson is not there,   and it's been deleted. So we had a bag. So if 
I post let's go ahead and Post, Anna Jones.

And   basically, we couldn't update the actual name. So 
if I get an A Jones, get the actual ID, and then   perform a put. And this will be Anna Jones Id just 
like that. And then body. And then let's, let's   simply say update and then update, send. Still a 
200. But if we get everyone, you see that still   Annie Jones, so we have a bank. So let's go 
ahead and try and find out why exactly this is   happening. So, let me go back to IntelliJ and then 
close this and then open up the actual data access   service. And now this is the actual method.

we are selecting the person mapping. And then so   basically, so right here we have index of person 
to delete. So this would be actual update. So to   update and DB index of person. So basically, 
yes, so this is the error. So so right here,   so you see that we have, so this person right 
here. So this is what we want to update. So right,   so let me rename this to update, right, so the 
index of person to update, you know, it's minus   one. So this will always return zero. So what 
we want is actual p, so P is the actual person,   in fact, just I mean, rename this to person. So 
we want this person that we found. So person,   and then this should return the actual index. And 
then if it's bigger or equal to zero, what we want   is Neal, so because this update doesn't contain 
the actual ID, so we need new person, and then   pass the ID, and then simply update dot and then 
get name. So yeah, I think this makes more sense.   So let's go ahead and restart the server.

we go. So now if I open up postman and then pretty   much just get so let's start from scratch. So no 
one in the database. Let's go ahead and post Anna   Jones. And now we have to get let's go ahead and 
get so we get the actual uod of Anna Jones. And   then right here, let's go ahead and perform a put 
to this endpoint and simply pass Anna Jones you   ID or ID. And then in the actual body. Let's also 
change this to Anna, and then Montana, just like   that. And then if we send, so we got 200. And now 
this should work. So go ahead and send. And that.   So you can see that this now works. So you see 
that we pretty much just managed to implement   all of the methods defined in our API. So it is 
nice to have like tests for everything right here.   And basically I wrote tests for this class.

go ahead and download the repo down below. And   you can run all the tests and see that this works 
as expected. So I've got unit tests around all of   this. So one last thing that I want to mention 
is that you see inside of this person controller   right here. So this person controller, we 
can have, you know, some annotations that   enforce null ability in our application. So we can 
pretty much just use one, attach some annotations,   and enforce that this object right here is always 
present, and also valid. So go ahead and open up   person model. And then right here, what we can 
do is actually say that this field right here,   so the actual name, this cannot be blank, so act 
and then not and then blank, right? So the reason   why I'm not saying that no, is because if you have 
an empty string, it's not No, but if you have an   empty string, it's actually blank. So basically, 
we don't want that to be blank, right? So then go   back to the actual controller.

And now you can say 
that the request body. So this has to be. So add   and then valid, right? And then we can also say 
that this must not be no. So we could also do the   same here. So we can enforce that this is valid, 
and also add and then not know, right? So now if I   pretty much restart the server, so you see exactly 
what we're doing.

So basically, we want to fail as   soon as possible instead of having to deal with 
nullability inside of our code. So now let's go   ahead and open up postman. And then let's go 
ahead and pretty much try and post someone   to our database. So right here, so you see that 
we have Anna Jones, but if we send for example,   blank, so send, you'll see that we get an error. 
And basically, this is working as expected,   as expected. So you see that it's a bad request. 
And it's pretty much saying that validation fail   for object person right here. So this is awesome. 
And you can see the actual default message,   which says that the field name must not be blank. 
So now if I go ahead and add the correct payload,   so right here, so let's go ahead and say, john, 
and then Jones.

And then send, you can see that   we have a 200 status code. And if I go ahead and 
get everyone in, see that we have john Jones. So   this is it to be honest. So now you should be 
familiar with Spring Boot and writing API's for   your application. So now the cool thing about it 
is that you can have a client API, and then do   all kinds of things depending on your application. 
So one more thing, actually, that I forgot to show   you is dependency injection, right? So let's say 
that we want to have a Postgres implementation,   right, another database or connecting to a 
different database. So how do we change that   without changing pretty much anything apart 
from one line of code. So to do that, what we   need to do is open up the actual do package, and 
then simply create a new class. And right here,   simply call it for example. person listening 
was call it person. And then data, access,   and then service, right, let's simply call it 
that. So this is a real thing now.

So okay,   implement and then person, da, oh. And then 
implement all the methods. And then right here,   so when we select everyone, I simply return 
list, dot, and then all of and then new,   and then person, your weird dot random mu ID. And 
then, let's simply say from Postgres dB, right? So   now what we need to do is annotate this with ADD, 
and then repository, and then simply say that this   is a Postgres implementation, right? And then to 
change our implementation, right, all we have to   do is grab this name right here, and then go where 
you inject the actual interface, which is inside   of the service, right? So person service. So now 
instead of fake do simply use Postgres, like that.   Now, if I restart the actual server, and then 
open up postman now if I perform a get, you can   see that we pretty much switched our database, 
we just one line of code.

And you can see that   this now is coming from a Postgres database. So 
I'm actually planning to do a video on you know,   connecting to a real Postgres database. But go 
ahead and check my channel because I've got a   video on how to spin up a Postgres container using 
Docker, and also an example with Spring Boot. So   go ahead and check my video on that. But I'm gonna 
make a second part on this video connecting to a   real database. So the last thing that I'm going 
to show you exactly how to spin up everything.   So go ahead and stop your server. Now what I want 
to show you is actually how to spin up the actual   jar. So this is the, the the jar that you can 
deploy to a server and have your application up   and running. So I'm going to simply collapse that. 
And then inside of Maven, so go ahead and open up   this tab right here. So Maven, and you should 
see a target folder. So if you don't see that,   so if I delete that, simply go ahead and open up 
lifecycle, and then simply say, install.

There we   go. So this is actually running some tests. And 
there we go, you see that we have a target folder   right here. So inside of the target folder, go 
ahead and simply right click, and then open in   Terminal. So you should see that we have this demo 
001 snapshot dot jar, the jar, and this is what   we can pretty much just run on the actual server, 
right? So when you deploy this to any environment,   so just to show you, so if I open a post, man, 
so if I send a request, you see that the server   is not up and running. So to kick off this jar, 
all you have to do is simply say Java, and right   here. So if I scroll up, you can see that so if 
I scroll up, you'll see that we can say Java,   and then minus jar, and then pass the actual 
jar. So go ahead and simply say Java, minus,   and then jar, and then the actual job.

So the job 
name is demo. And then if I press tab, you'll see   that we get auto completion. And then all I have 
to do is press Enter. And you can see that now we   are starting our server. So right here, Tomcat 
started on port 8080. And what I'm going to do   now is simply open up my web browser. And this is 
the actual API that you would use, so localhost,   and then 8080, and an API, and then v one, and 
then person, and then enter. There we go. So   you see that we have a JSON that we can consume. 
And basically, you can distribute this and have   1000s of clients consume your API. So I hope you 
had fun implementing this application or this API   with Spring Boot. And basically, we achieved 
everything. So we have, you know, a client.   So in our case was postman, we implemented get 
post, delete, and pull requests. Through the   actual controller layer, we had a service layer 
data access layer for a database, you saw how   to implement an in memory database.

And then you 
saw how easy it was to switch from databases. And   then we return the actual response to the actual 
client, which is what you see right here. So as   I said, I'm going to do a second part on this 
video, I really want to add value by connecting   to a real Postgres instance, which to be honest, 
is not going to be a lot of work, as you saw,   it's just switching one line of code and then 
implementing the actual connectivity to Postgres.   So now, let's actually go ahead and pretty much 
just use, we're actually connected to a real   database. The database engine that we're going 
to be using for this second part of this crash   course, is this amazing database engine called 
Postgres. So if you want to learn more about   Postgres, you can go ahead and check my website, 
where I've got this PostgreSQL Crash Course,   or actually, it's a course about four hours long, 
and it's absolutely free.

So you can see the   roadmap right here, and a cover the essentials 
that you need to know, in order to be familiar   with Postgres. And by far, actually, by far, both 
price is the best database out there. So go ahead   and check it out, go ahead and enroll. And it's 
absolutely free. So if I go back to the diagram,   so you can see that right here, we have this 
data access layer, and instead of talking to a   fake database, we're going to connect to a real 
database, which will be Postgres.

So for this   database, what I'm going to be using his Docker, 
so I'm going to use Docker and simply say Postgres   and go ahead and click on this very first link 
and Basically, if you don't know about Postgres   and Docker or Docker, go ahead and check my video. 
So I've got this video right here, where I cover   about where I covered Docker and Postgres in about 
10 minutes.

So everything I'm going to teach you,   you can find on this video. So if I close that, 
and basically is really straightforward. So you   can see that they have some description on what 
is Postgres. And basically, this is how you start   an instance, once you have Postgres installed. 
So let me go ahead and simply grab this command   right here. So let me just grab this command, and 
then go ahead and open up your terminal iterm, or   command line. So go ahead and simply open that up. 
And what I'm going to do is simply paste that in.   So actually, I didn't copy that.

So let me just 
grab this. And then paste that in, basically what   we're doing here, so just let me explain so so 
let's start from the very first command. So Docker   run, so this is the Docker command. And then I'm 
going to name this container as so let me simply   rename this to, let's say, post grass, and then 
dash, sprink. And then right here, so dash E is   the environment variable. So we need that to set 
the actual password. So let's simply keep things   simple and simply have a very weak password. So 
password, and then minus d, Postgres. And this is   the actual image and go ahead and simply change 
this to Postgres, and then Alpine.

So this is   the smallest version. And then what we need to do 
is also expose a port. So we're going to take the   port that is running inside of that Docker 
container. So 5432, and then expose that   to the outside world, as 5432. So basically, what 
we're doing, and so basically, this minus D is in   detached mode. So as soon as I press enter, then 
we can carry on doing all the things. So go ahead   and check my video if you don't quite understand 
this, because I teach you all of this. So go ahead   and simply press Enter. And there we go. So now 
if I go ahead and simply say Docker, and then PS,   you can see that we have this container right 

And the name is Postgres spring. So go   ahead and simply say Docker, and then port, and 
then post, an Ingress dash spring. And you can   see that we are exposing the container port to 
the outside world, on localhost, and then 5432.   And by the way, 5432. This is a default port for 
Postgres. So now that we have a database, so we   can log into it, and then perform various things. 
So I want to show you exactly how to SSH into this   box in a second. But for now, you have a container 
running and exposing a port 15432. So now what we   need to do is actually go and open up IntelliJ. 
And let's actually connect to this database. So   what I want to do is first revert this because I 
want to connect to Postgres.

And what we need to   do is if I actually stopped that, and then close 
that, so open up the resources. And by the way,   I didn't mention that we have some tests right 
here. So if I open up tests, so you can see that   I even took some time to write some tests to 
make sure that everything works. So let me go   ahead and close this. And then what we're going to 
do is open up this application dot properties. So   application application dot properties, this is 
where you define the connection details to your   database.

So go ahead and pretty much just delete 
the application properties. So go ahead and delete   application dot properties. And inside what I want 
really is a file and simply call it application   dot and then yamo wash that could have simply 
renamed that to yamo. But it's fine. So okay,   and not for now, I'm going to commit this in a 
second so you can have everything on a branch.   So now inside of this application dot yamo. This 
is where we define all the connection details to   our database. But before we do that, what we 
need to do is actually add some dependencies   that will allow us to connect To databases have 
the drivers and then also give us the ability to   write SQL commands against our database. So for 
that, what we need to do is open up palm dot XML.   And just let me collapse this for a second.

you can see some information about this project,   I'm using Java 11. The version of Spring Boot 
is 2.13 release. And then you can see that we   have some dependencies right here. So this is the 
actual dependency for Spring Boot starter web. So   this gives you the ability to have a Tomcat server 
up and running and write some API's using Spring   Boot MVC, so on and so forth. And then we have 
this one right here. So Spring Boot starter test   for writing tests. And then we have this set for 
j, which is pretty much an assertion library for   writing unit tests.

So the dependencies that we 
need are the following. So go ahead and simply add   a new dependency. So I'm going to press Enter. And 
you can see that now we can add a new dependency.   So the first one that I need is from all dot 
spring framework dot boot, so it's me grab that,   and then paste that in. And then the artifact ID 
that we need will be spring, and then dash and   then boot, dash, and then Stata and then dash 
JDBC. So let's actually duplicate this. And then   what we need is org dot and then post and then 
dress keywell. And then the artifact ID is simply   PostgreSQL. So just let me grab that. So that will 
be that. And then what we need is simply have a   scope. And then this will be only at runtime. 
And finally, we need a net of dependency. And   this time, this will be org, dot and then fly way. 
And I'm gonna explain this in a second. And then   dB. And then what we need is simply fly. And then 
way, and then core, wash the dash, and then core,   just like that.

So all of these dependencies will 
allow us to connect to a database. And basically,   this is what allows us to write, or actually it 
gives us an awesome API that we can execute some   statements against our database. This is for the 
actual driver, so PostgreSQL. And in this flyway,   db is for database migrations, and you will see 
this in a second. So now let me simply go ahead   and open up the project tab. And then if I open 
up the demo application, and then press play, you   should see that we have an error. And the error 
simply says that failed to configure data source   URL attribute is not specified, and no embedded 
data source could be configured.

So basically,   what we need to do now is simply to create a data 
source, and inject the URL, username and password.   And then pretty much allow us to add an image that 
will allow us to connect to our database. So let   me go ahead and simply collapse this. And what we 
need to do first is simply go ahead and create a   new package. So package, and then simply call 
it as data and then source.

And then go ahead   and press OK. And inside of this package, let's 
go ahead and simply create a new class, and then   simply say, post, grass, and then data and then 
source. Press OK. And don't ask me again, I will   add all of this later on. So this class will be 
served as a configuration. So add configuration.   And what we're going to do inside of this class 
is simply return a data source, so public,   and then it carry data source. And let's simply 
go ahead and name it as the current data source.   And what we're going to do here is simply return a 
data source of builder. And inside let's simply go   ahead and say dot and then create Then right here, 
simply go ahead and say, and then simply go ahead   and say dot and then type. And the type for this 
will be e curry data source dot and then class,   and then dot and then build.

So you can see that 
now we have this data source. And what we need   to do is simply say add and then being. And what 
we need to do also is say configuration and end   our properties. And then what we're going to do 
is simply have app dot and then data, and then   source. So, basically, we are instantiating, this 
Ikari data source as a bean. And then what we're   going to do is create some configuration file 
that will contain the username, URL, password,   so on and so forth. So let's go ahead and simply 
open up the application dot properties. And inside   of application properties, what we need to do 
is simply do the following.

So let's go ahead   and have an app and property. And inside of this 
app property, we have data and then source. And   then inside of data source, what we need is JDBC 
dash URL. And this will be JDBC. Colon post grass   qL colon forward slash localhost. And then the 
port will be 5432. And then Ford slash, and then   we need to connect to a database. So we're going 
to create a database in a second. But for now,   let's simply name this as spring and then boo. And 
then dash and then post grass dashDB. long name,   but you get the point. So now we need a username. 
So the default username that ships with Postgres,   it's called post press, we need the password. 
So password.

And remember, the password that   we chose was password. And we can also define a 
pool size. So basically, this is the number of   connections that we can have actively, instead of 
having to create a new connection to the database,   every time that we want to execute a query, 
every time we want to execute a query against our   database. So simply go ahead and add 30. And that 
should be it. So you can see that we have App Data   Source. And inside of this data source package, 
we have this Postgres data source. And basically,   it's just grabbing all the dependencies from 
this app, and then data source. So just let me   go ahead and start this because I want you to see 
the errors, and you see exactly what is going on.   So if I start the application. There we go. So now 
it says that cannot find migrations in location,   class, path, db, and then migration.

So what 
we need to do is to create a folder called dB,   and then another one called migrations and then 
have our database migrations inside it. So what   flow and this is basically flyweight, right? So 
flyway allows us to manage our database schema   as we evolve. So go ahead and pretty much 
just learn about flyweight, right here. So   flyway. And basically, you can read through the 
documentation, but it is straightforward. So just   follow along and you will understand exactly 
what I'm doing. So if I close Oh, actually, I   just have to keep that open. So if I go ahead and 
simply close this or actually clear that and then   I've got this terminal right here. So I'm going 
to open this terminal. And if I do pwd, you can   see that I'm inside of desktop Spring Boot YouTube 
Crash Course.

So what I'm going to do is simply CD   into SRC, and then main and then inside of core 
resources. So inside let me go ahead and make a   folder. So make and then there. And what I need 
is dB, CD into dB, and then make another folder.   So make dir and then migrations. There we go. 
Enter. And basically, you could simply come here   and pretty much just right click, and a new, and 
then directory, and then DB dot migrations.

But   I prefer to use terminal. And you should also get 
used to it. So inside of dB migrations, let's go   ahead and create a file. And this file will be as 
follows. So version one, underscore, underscore,   and then person, table dot SQL. So make sure 
that this is as follows. Because otherwise he   won't work. So version one, underscore, underscore 
person, table dot SQL, enter. Now, let me ignore   this extension. So this is where we can write 
some SQL. So let's go ahead and simply create   table person. And then inside of this person, we 
have an ID. So Id, and this is of type EU ID. And   then this will be not and then no, primary, and 
then key. And then we also have, so if I open   up the person class, we have the actual name. So 
if I go back, so this will be name. And then this   is a VAR, char. So let's go ahead and simply 
add 100.

Not Know. So this is enough. So now   we have a table called person with the following 
columns ID and Name. So what I need to do now is   actually go ahead and create our database. So if 
I open up the applications, or yamo, so remember,   so right here, we have this database called Spring 
Boot, Postgres dash dB. So you can get a better   name. But you know, I'm just giving this name so 
that you know exactly what we're doing. So what we   need to do now is actually, so if I open up the 
terminal, and this is where I've got, you know,   I've typed some Docker commands.

And you saw that 
how we pretty much just launched this container,   which is running and also exposing this port. So 
5432. So this is the port that we are connecting,   right, so localhost 5432. So let's actually go 
ahead and bash into this container and create   a database. So simply go ahead and say Docker. 
And then exec, and then dash, and then it for   interactive. And then what we want is actually, 
if I grab this container ID, and then simply say,   bin, forward slash, and then bash, Enter.

And you 
can see that now we are inside of that box, or   actually. And you can see that now we are inside 
of this container right here, which we can simply   now run some commands. So go ahead and simply 
say p SQL. And you can see that we have p SQL   working. And now we can write some p SQL commands. 
Again, if you have missed my course on p SQL,   or actually Postgres, so on my website, so this is 
where I teach everything that you see me typing.   And to be honest, you should learn Postgres. It's 
amazing. And a lot of companies are using it. And   you can also use it for your personal project. So 
let me go ahead and simply go back to my terminal,   and simply go ahead and say p SQL, dash, and then 
capital U, for post grass.

So remember, so this is   the actual username, and then enter. And there we 
go. So you can see that now we are inside. So if I   pretty much type backslash, and then l. So if I 
clear the screen, backslash L, you can see that   I do have three databases. So you can see a list 
of databases, we have Postgres template zero and   template one. So let's go ahead and create a new 
database with this main. So let me grab this. And   then if I tried to create So, caps, so create 
table or actually database and then paste the   name and that with semicolon, enter. Oh, okay. So 
we cannot have dash. So let me simply pretty much   rename this to demo dB. Right? So demo And then 
dB, Enter. And you can see that worked backslash   L. And we have demo DB right here. So let's go 
back to IntelliJ. And let's simply rename this   to demo dB.

And now all we need to do is actually 
connect to this database. So let me connect   inside. So backslash, C, and then demo dB, Enter. 
And you can see that I'm connected to demo dB. So   if I do backslash, and then D, so to describe what 
we have in here, so backslash, D, we haven't got   anything backslash dt, you can see that there is 
no relations. So these are everything. And then   dt is for tables only. So now what I'm going to 
do is go back to IntelliJ. And let's go ahead and   simply start our application. So let's actually 
go ahead and click on this icon right here,   edit configurations. And let's go ahead and simply 
say that we only want one single single instance   running at a time. So if you press play multiple 
times, it means that you will only get the same   process and not get two processes. And then you 
get like one error saying that the port is already   in use, so we don't wander.

So go ahead and simply 
now play. And we have an error, and it says cannot   find migrations in classpath DB migration. And 
thus, because I've misspelled migration, I've   typed migrations instead of migration. So just let 
me rename that. So migration, and then refactor,   there we go, and install the application. And 
there we go. So you can see that everything   started fine. And basically right here, you can 
see that we have a curry pool started and then   completed. And then we have database demo database 
right here.

And you can see that we have migrating   schema. So person tables. So basically, that was 
executed. So our command was executed correctly.   And you can see that the migration was applied. 
And now we have the server running on port 8080,   which is awesome. So now, so if I pretty much go 
back to my terminal. So I just want to show you   something first. So remember, previously, we 
type backslash, D, and backslash dt. And that   wasn't working. Well actually, it was working, 
but we didn't have any relations. So if I type   the same command, so backslash d t, you can see 
that now we have two tables. So this one is for   flyway specific, which you shouldn't care at 
this point.

But you can see that we have this   table right here called person. And if I go ahead 
and describe a person, so backslash d ln person,   you can see that we have this table called person 
inside of the public schema. And then the ID is   of type you will not know. And then we also have 
name, and then it's a character varying. And then   this is 100. So this is the length. And it's 
also not no, and this is awesome. So if I go   ahead and simply say select, and then start from 
and then person and with semicolon. And you can   see that we have zero rows. So let's go ahead and 
simply insert someone. So because I know I need to   install an extension to be able to to generate the 
Jew IDs and also I cover this on my free course,   I need to install an extension.

So what I want to 
do basically is this, so select and then you ID   and then generate and then v4 as a function. And 
you can see that no function matches. So what we   need to do is create extension. And then this will 
be u ID. Dash o s SP. So w ID dash o s SP and now   it's semicolon. And you can see that worked. Now 
if I pretty much select you with generate vision   for and you can see that now we can generate you 
It's so If I go ahead and simply say insert, into,   and then person.

And then we have ID, and a name, 
and then values. And then we want to generate a u   ID. So generate, and then v4, and then the actual 
name. So let's simply say that this is Maria,   and then Jones. And then end with parentheses, 
and enter. You can see that Maria Jones does not   exist. And last, because that has to be single 
quotes, and not double quotes. So Marie Jones,   like that, enter, and you can see that worked. 
So let me go ahead and add Tom, and then Smith,   enter. Now if I select star from person, you 
can see that we have two people inside of our   database. And this is awesome.

So we've managed to 
connect to our database using Spring Boot. And we   have a database up and running with a table. And 
now what we need to do really is just write some   code to retrieve data from our database using 
Spring Boot. Oh, actually, we're actually using   Java and Spring Boot and their API basically. So 
let me go ahead and collapse this, and inside of   the person data access service. So let's go ahead 
and write some code that will retrieve as everyone   from our database. So what we need to do is to 
use this class right here, so private, final,   and then JDBC template. So what we're going to do 
is add this to constructor, and then auto wire. So   this is dependency injection, we don't have to 
do anything spring, no Spring Boot knows how to   initialize correctly this class for us, so that we 
can write some code against our database.

So now,   instead of saying select all people, and then 
return a list, so basically this fake list,   what we're going to do is use JDBC template API. 
So simply go ahead and say JDBC template dot,   and you can see that they have various methods. So 
the one that we want is query. So we want to query   and the query takes two things. So we can pass 
s, so we can pass an SQL statement. And then we   have to pass a row mapper.

So basically, the row 
mapper is how we take the values that we retrieve   from our database, and then transform that into a 
Java object. So let me go ahead and simply simply   define a string. So string, and let's go ahead 
and make this final, not needed, but why not.   So SQL equals to select. So basically, the same 
thing that we had, so select name, or actually,   this is ID, name. And then from and then person, 
not the same. So previously, we simply said select   star. So right here, so select star, so select, 
and then Id, name from person.

And this is the   same thing. So I prefer to use the actual column 
names instead of the instead of star. So now let's   go ahead and simply pass the SQL query. So SQL, 
and now we have to pass this row mapper. So this   row mapper is a lambda that has access to the 
result set to the result set, as well as the   index.

So what we're going to do inside here, so 
let's simply go ahead and say return. And then   we need to return a person object. So person, 
so this is our model, and inside of our person,   we need to pass what we need to pass the uod. 
So they should be new person, just like that.   So inside you can see that we have to pass a u 
ID and also a name. So inside of the result set,   we can get the string so get string, and then you 
can see that we can pass the column label. So I   know the column label is so basically ad. And also 
we can get the actual name. So resolve set dot,   and then get string. And then this will be 
named. So if I put this this on a new line,   and you can see exactly what we're doing. So right 
here, you can see that we have an error. And this   is because this result set Daguerre string 
is a string basically. And what we need is   a unit type.

So let's simply go ahead you ID and 
then from string. And then we need that. So that   will work. So you can see that now this works, 
let's end with semicolon. And what I like to do   is actually to extract this way variable. So all 
of that actually. And then this will be ID. And   then this will be name, so you see exactly what's 
happening. And we can remove that. And also that,   and then that and then format everything. So 
now I don't need to return the list of pretty   much just fake people. So this from Postgres 
DB is not named, and we are retrieving from   a database.

So you can see that I still have an 
error. And this returns a list of people, right.   So you can see that it's a list of people. So I 
can either say return, and then people whoops,   so people just like that. Or I can simply return 
that in line, so refactor. And there you go. So   you can see that I'm returning that in line, 
which is awesome. So this is it. So if I now   restart the application. So let me go ahead and 
simply say stop, and we run. There we go. It's   up and running. And if I open up Chrome, and 
then remember, so right here, we previously add   an empty list. And this is because he was coming 
from our fake database. So now, if I refresh this,   there we go. So you can see that now, this is 
coming from our database. And this is awesome,   guys. So you can see the power of Spring Boot. 
Basically, you can just write code, you know very   fast, and they give you these tools so that you 
can focus on writing what matters instead of you   having to configure things.

So there we go. So let 
me go ahead and simply add someone else into this   table. So let's go ahead and simply, say, Tomcat, 
we're actually not Tomcat. Let's simply say, Anna,   and then Jamil and an editor. So if I refresh 
this, you can see that now we have Anna Jamil.   So there we go. If I collapse this, you can see 
that this is only one implementation of our API,   right? So we have a bunch of other methods. So 
select person by ID, you actually let's go ahead   and implement this one quickly. So you see exactly 
how this is done. So what you want is to pass,   or actually select ID name from person. And then 
here you can see where in an ID equals to question   mark. And then what you want is to take the exact 
same thing here, and then simply return that back   instead of query because query it returns you a 
list, what you want is query for and an object.   And query for object takes the SQL. But we also 
need to pass the arguments.

So new object, so this   must be an array. So just like that, and you can 
see that So currently, this is empty, right? But I   need to pass this ID that comes from the client. 
So Id and then this, let's rename this because   it's already in scope. So person, and then ID. And 
let's rename that to person ID as well. Just like   that, and let's actually change this. So this will 
be a person, right? But what we want really is to   return so return optional.of nullable, because 
that can be no Then pass person, just like that.   So basically, it's the same thing.

But we have 
this question mark, and then query for object,   we pass the ID right here. So if I put this on a 
new line, so you can see exactly what we're doing.   So in that, that, so we passed the SQL, the ID. 
And basically, if you had more item arguments,   you'd simply pass him right here. So we have the 
ID, and then this is the row mapper, as you saw   before, so right here. And then we simply return 
the optional of nullable of person, because,   you know, we might not find a student with a 
given ID. So if I restart this, and then open   up Chrome. So if I refresh, you can see that this 
still works. But you find out take this ID, and   then pretty much to Ford slash and then Id remove 
the quotes there, Enter. And you can see that now   we only get one person.

And this is awesome. So 
there we go. So you can see that we managed to   connect to a database using Docker, Postgres, 
flyway, spring JDBC. And you can see that this   was pretty much, you know, very straightforward. 
And we even managed to use a carry. So I didn't   even explain what you carry was, but you carry is 
the actual recommended data. So if I you should be   using for a Spring Boot, because it's very fast, 
reliable. And yeah, it's just one of the best   ones out there. So there we go, guys, if you have 
any questions on this, and basically, I'm gonna   let you implement the rest of the logic. So insert 
person, the same with delete, and then update. But   basically, it is straightforward using some SQL. 
So go ahead and pretty much just subscribe to my   channel to get more videos like this, if you want 
to learn more about all of this and more.

So I've   got a Spring Boot full stack, web development 
course where I teach all of this and a lot   more. And also creating user interface for this 
using react, reacts and hooks. And pretty much,   it's a lot of content packed into one course where 
I'm pretty sure that once you learn that you will   be able to build applications on your own. And 
also apply for jobs because a lot of companies   are looking for a Spring Boot developers or, you 
know, Java developers. But Spring Boot is used   quite a lot in the industry. And once you know 
all of these skills, so dependency injection,   connecting to databases, writing tests, writing 
integration tests, writing user interface for it,   I'm pretty sure that you will be able to get a 
job. Okie dokie. As you saw throughout this crash   course, springboard is amazing. So we really just 
scratched the surface. And the next step for you   is to check out my full stack web development, 
Spring Boot and react. And in that course,   I'm going to teach you everything you need 
to know about Spring Boot.

So we're going to   cover essential topics that you need to know as 
a software developer. And the cool thing about   this course, is that whatever you learn, you 
will be deploying it into a real server using   Amazon Elastic Beanstalk. And upon completion, 
the skills acquired in this course, it will help   you apply for jobs because it will help you with 
a lot of great important concepts that a software   engineer should know. Also, you can start your 
own projects, university projects, and pretty   much if you are a developer, you should be aware 
of this awesome framework and how to use it inside   out.

This is all for now. Go ahead and check out 
my YouTube channel where I've got more content   similar to this. It was a pleasure teaching 
you and I'll catch you in the next one. See ya.

As found on YouTube

You May Also Like