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 dot Ivo 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 pick 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 springboard 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 say here.
We can say we have the many properties like application de and application like
SIT and you have application data, pro 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 can consistency across
environments and spring boot profiles, we're going to code that in this.
So basically the self content applications.
So what happens means.
So when you create these general applications so it'll include the Unbred
server and Tomcat, like kind of the jets.
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 you 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 we 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 CAD CD pipelines and testing environments and products and servers.
It'll run on the different in months where like wherever you or 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
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 ads 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 intelligence, 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 poster classes.
So in the project classes you are, so you have to write many set and get it and
like kind of the two stringing methods and the yes score and equals method.
So this like the spring boot 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 mean 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 boil pit code.
And how the Spring Boot 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 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 run times whenever you start your servers.
So mainly here, how the so my spin boot applications are going to interact in
integrating with them microservice.
So basically here when you write away any service restful services.
Or anything like a web services, anything.
So when you develop one respirable services, that is, you are going to
create the, at the rate rest control alert, which is which is nothing but
your, the respirable services after that.
When you write the microservices is it is the part of 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 are there.
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 microservice 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 REST 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 invoke the get method or put methods.
You have different HTP methods.
So with those 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 I Registry, you are going to.
Provide the, what are the s 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 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, 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
the, which service you have to invoke.
It'll probably the respective so the a p gateway 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 the 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 the own services.
So there is a there is an called, there is Spring 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 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 keep 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 harmed by the constrain the rate of the request.
This ensures system stability during topics, spikes, and the
province research adjust in.
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, suppose if, have any issues on that.
Thank you.
Thank you much.
That's it.