Transcript
This transcript was autogenerated. To make changes, submit a PR.
Hello.
So we are going to talk about, innovative tools to supercharge
your Spring boot applications.
So here, so the Spring boot, It is a, the revolutionary Java application
development because nowadays most of the, enterprise developers are going to use
this, spring boot applications because this is the, and the more, most vis,
framework and, So here we are going to examine tools that, how to set up the
project and how to eliminate the, boil bread code and, improve the monitoring
and, solving the, development challenges.
And we'll go by one.
each, tools, whatever.
we use that.
So first of all, here, the spring install.
So how are you going to start your project?
So the easy way is, like you have a spring.io install website
that, like you can, start, you can create a. Your new project.
So there, you can get all the dependencies which are needed, like all
the starters, like a Tomcat starters or spin data, GPS starters, and, you'll
be whatever the starters you need.
So you'll get all the starters from there.
And, You can configure the, packages however you want, dot jar and
however you want there, in the spring dot I, so you can see that
and after that you can download the project and, wherever you want to
use that, any id, you can use that.
So this is, how these being board start our projects.
and mainly the dev tools.
So how the, the dev tools, will help on our development cycles because here,
the dev tool, dev tools mainly, so what will happens, it'll monitor your class
path whenever you made any changes.
So automatically it'll repress, your, class files and, it'll be
reflecting, with your latest code whenever you start the server.
And, the reloading, so what's happening here?
So whenever you make changes on the front end, so the browser, which automatically
will be, uploaded with the latest changes and, it'll reflect into the backend and,
the property defaults here at Oregon.
Say Here.
we can say we have the many properties like, application and application,
like SIT and, you have application data pro, the different properties
is there and, so we can use the properties wherever you want.
get it based on the, at the rate value properties, which is there in the,
which is there in the fingerprint work.
And, next we are going to do that, how the Spring Boot interacting
with the docker containers.
So basically here, we have how the self contain applications will work
and, simplified the Docker file and, consistency across environments
and, spring boot profiles, we're going to code that in this.
So basically, the self contain applications.
so what happens means.
So when you create these channel applications, so it'll include the bred
server and Tomcat, like kind of the, so all the necessary, like a jar or
wire file will be, will be replaced.
will be going to add into that.
and, the simpler docker files here from, so what happens here when they open JDK?
If we have the open JDK there, we are going to replace our jar into the
path and we can tell two documents.
So where, we are keeping our jar file in the specific locations.
So the docker will be going to, take that, the wall and will be going to, start your
applications based on your configurations.
And the con and consistency across environments like, so here, the
dockets, it'll help you to run on, your local, environment can be run, CADC
with the CD, CD pipelines and testing environments and production servers.
it'll run on the, different in months where like wherever you, you install that.
And finally the springboard, profiles and dockets.
So basically this profiles, so you are going to use that.
So whenever you want, so let's say you have a different
environments, SAT environment and dev environment and productions.
So you have a different, the properties based on the ment.
So if you are using the profiles, so based on the profile, the profile name, it's
Dev, SATR, The products in, the prop, the propel name, it'll take the respective
property and, will be, it'll be placed into the, the, in the, into the, that
respective docker image and docker, the respective job file, wherever you need it.
So the next is.
How the spring, boot aware of your intelligent, like kind of the, IDs here.
I'm going to tell about how the intelligent.
So basically here, so the in inte will help you to the, like kind of
the automatic suggestions, the code.
so whenever you write the codes, so it'll help you the, some code
snip at, and, for debugging.
so the spring boot applications.
so it's usually you can debug the applications.
and if you want to, run the any, Your test cases.
so the, so it's like you can do that like method level or, like kind of
the, class level wherever you want.
You can in the, in this, in the inte you can do that and basically
here, In this, in the inte id.
So this is a user friendly, id and, whenever you trying to write the code
and, it'll, help you that where you are.
Where you are calling that method and where you are going to call that
means, so it'll help you on that.
this is, the spring.
like Springboard, is helping for the, intelligent id.
And when it comes to the, eliminate boiler plate code, so basically here,
the boiler plate code is nothing bad.
So let's say like you are writing some PO classes.
So in the project classes you are, so you have to write many, set and get it
and like kind of the two string methods and the yes score and equals method.
So this, like the springboard will help you to reduce all the barrel plate code.
So with the help up, there is a feature, there is a, there is annotation
called, and get its, and, no augments are, like now nowadays we have the
data, data, which is one annotations.
We, it'll help you to, it, it reduce the, your boiler bread code.
This bottle pit code, mainly in the runtime you won't get many pin pits.
So when only the developer perspective, you'll get, the less code I can say you
can, the code will be reduced and the button on the developers will be reduced.
So that is the main object on the eliminating the boiler pit code.
And, how the spring boat interacting, with the, integrating with the
microservices architectures.
So basically here, the spring boot mainly, you know how it'll start the Spring boot?
Basically like there is a one spring boot main applications.
which will help you to start your applications.
So what will be there in the spring boot main applications?
So there is a, the static, main method will be there, which is,
Which is going to load all the classes under the, the same package,
what you define in the main class.
So how it'll be going to start that.
So there is a there is an annotation call at the Red Spring boot applications.
So that will help you to, load all your, classes, which you are, created, which
you are developed under the same package.
So it'll be, loaded runtimes whenever you start your servers.
so mainly here how the, so my Spring Boot applications are going to interact,
in integrating with them, microservice.
So basically here when you write away any service like, restful services, or
anything like web services, anything.
So when you develop one respirable services, that is, you are going to,
create the, at the rate rest control load, which is, which is nothing but
the respirable services after that.
when you write the microservices, the micro is, like it is the, part up.
when you.
When you develop the Spring boot applications, which is having
the dashboard service, and at the same times, you, if you want to
interact with the other services, you can do with, rest templates.
So here, these Spring Boot is interact, integrating with the, microservices
because due to the Spring boot, features mainly at their spring boot, boot
application and starters and, how the, your, spring Boot will help you to the
microservices because microservices nothing, but it's the, when you're writing
the applications, it's Many d let's say like I have the one applications, I have
the, like different models that date.
So now I want to write each model one application, one microservices.
Then, so what happens means each model will be going to run in once, one service.
That means like you're going to write one, like I can say one service per that.
And so that will be, that each model will be running on
one database and one servers.
So the, so what happens means when you integrating all the services,
so it'll be, the performance will be increased compared to the, compared
to the like monolithic applications.
Because let's say I have one microservices.
I have, two microservices.
One is, employee microservices, and another one is develop,
department microservices.
So when I interacting with my applications, even my,
department applications, my department micro switch is down.
Even also I can interact with the, my employee, microservices because that is
the advantage there, here because both are running on their, like individual servers.
That is the service independence here.
And Interservice Communications, suppose if you want to interact with
the one service to another services.
So here, so the Spring Boot will help you.
On the how to interact with, so basically in the testable
services you have, desk template.
There is a template called desk templates.
So it'll help you how to, in how to interact with other services.
So there you have different methods.
Like I know, you can, inbook the GET method or put methods.
You have different HTP methods.
So with these methods, like you can invoke the, other service,
and here you can interact with the one service to, the service.
And, so service discovery.
So I was telling about, Let's say I have more than, five services.
How are you going to, interact with each other?
So first of all, you need to register with the one, like one registry.
Then, so you, then you like, you can be, in integrating with the other services.
the Ika, it's I can say one is Ika registry there.
So this will help you to interact with the one service to another service based on
the, so in the registry you are going to.
provide the, what are thes are there?
like you, you are going to provide the, all the service s you are
going to interact with each other.
So the registry will help you to what is the next, service you want
to interact based on the, your key, whatever you're going to provide,
from one service to another service.
And Gateway is there.
So Gateway is here.
This is the, a centralized entry point for the, interacting with
one service, another service.
So it'll, it'll help you on the load balancing for each, all these services
and, so it provides security and Security and mainly like when you, whenever
you're going to create a API gateway.
So what happens means when the request comes for the a p gateway, so it'll
look, it'll, it'll, provide the, the request, the service, which is coming to
there, which service you have to invoke.
It'll probably the respective, so the a p get you will help you on that.
So now, automated database migrations.
So here, Western control for databases.
and, here we can do like a track and manage scheme changes as
code alongside your application.
And, suppose if you've made any change in the database, so it'll
help you to the validate, your, database query or, whatever it may be.
And, repeatable migrations.
So suppose so if you're writing, many database scripts, so it'll help you on
that and, and speak, but mainly it's automatically detecting and, applying the
migrations while starting, while, starting the servers because this, elements,
the traditional disconnect between the application code and the schema changes
whenever, you deploy the service.
So the next one is the real services for the testing.
So whenever you try to test the spring boot applications, you don't
need to worry about the, your mocks.
So it'll be going to run with the, there own services.
So there is a, there is boot test, so it'll help you on that.
And, So whenever you run that, any, test case, so you can do that first screen
instance for the every test run and, and even you can, you can run the, like you,
you can test the, your database queries and, you can test the, or the database,
repositories whenever you were trying to, integrated with the database, with
the, the repositories and services.
So the last one is circuit breaking and fault tolerance.
So the circuit breaking will help you to.
Whenever any, failures happen, your service, so it'll catch the circuit
breaker, for your failure, and it'll help you to the, provide the, the problems.
when the circuit opens.
So it's ki on it to look for the failures.
if the failures exceed the maximums, maximum of, times, what happens
means it'll, it'll, report to you.
So immediately it'll stop the sequential requests, which is
coming up for the circuit breaker.
So that is the main, advantage in the circuit breaker here, and rate limited the
product services from the being who harmed by the, constrain the rate of the request.
This ensures system stability during TRO spikes and the province research adjust.
So here.
It'll be producting the services whenever you trying to, when,
whenever you got the fault tolerance, when you turn your services.
and, it'll show the, what is the topic is coming to the,
your request and your services.
And where the like the maximum, the topic is coming and, based on that, so you can
go and you can analyze the, your issues suppose if you have any issues on that.
Thank you.
Thank very much.
That's it.
It.