Spring MVC Tutorials 10 - Handling an HTML form using @RequestParam annotation Video Lecture | MVC Tutorials: Web Programming Course - Web Development

guys my name is incacha Karev and I were
coming to gone to series in the previous
tutorial we talked about path variable
annotation in detail on this tutorial
I'm going to talk about use of request
param and ation and alongside I will
explain how to write and handle HTML
forms in a spring MVC application
alright let's start just to save some
time I've already created an ultra
simple demo to explain you all these
concepts before I start explaining
everything which have written here in
the demo let me first show you what this
whole application is all about when I
run this application on the server the
client will enter this you are on the
browser and will hit enter my spring MVC
web application will send a form like
this back to the client client will fill
up the form with all the required values
and then will submit the form back to my
application once this data is received
by my spring MVC application on the
server it will process the data and once
processing is done it will send a
confirmation message back to this client
saying this form has got processed
successfully good these are the simple
steps I have followed to develop this
simple demo application first is writing
the student admission controller class
having two methods get admission form
and submit admission form and two JSP
files admission form dot JSP file having
HTML form and admission success starch
ASP file all right now let's understand
every bit of this demo when the client
enters this URL on the browser and hits
enter the request will reach to this
application and here the front
controller of this application will
state away make a call to this method
and how it will decide to make a call to
this method only among all other methods
which are present in the
education simply by analyzing two things
for this incoming you are requests first
is of course the pattern of this URL if
the battery of this URL is matching up
with the pattern of the method which you
have kept in the request mapping
annotation on top of the method for
Scrat area is need to make a call to a
specific method and this concept I
explained in detail in all my previous
tutorials but here you would ask me one
question
young gosh what is this extra line of
code you have written here we didn't
find you writing this statement anytime
in all of your previous tutorials so
what exactly is this all about
this is talking about what is the HTTP
request which client has made let's
before proceeding further here I am
assuming that you have a decent idea
about what's a HTTP GET post or other
types of requests which a client can
make to a server all right so here when
a client makes a request to this
application using this URL that request
can be of get type can be of post type
or can be of other HTTP request types so
when I write this statement here on top
of a method it simply means that this
method can process only requests which
are of type get all right let me explain
you this way where the client enters
this URL on the browser the browser by
default makes a get request to the
server the request reaches to this
application and the front controller
here would state away make a call to
this method of the finding the URL
pattern of this request and the pattern
of this method is matching up and also
the type of method request this method
accepts is matching up with the type of
request which client has made so here in
this case in short the request was of
get type and this method also accepts
gate type and it's your pattern is
matching up with this pattern that
Surrey's in front controller made a call
to this method
all right let's proceed further the
method here is simply returning model
and view object having view details back
to the front controller the front
controller would then state away for the
request to the admission form toward GSP
well how with the help of the resolver
class using prefix and suffix statements
so once the control reaches here to the
ignition from Rogers B file it prepares
the response using this HTML code if you
observe here it's a simple HTML form
having two fields name and hobby and a
summit button the point to note here in
this form is the method argument in this
form tag here I mentioned the post so
when a client would summit this form on
the browser the request type which would
reach here to the application will be of
a type HTTP POST
so this GSP file will simply prepare a
response using this HTML form and send
it back to the front controller and the
front controller in turn would send this
HTML form back to the clients browser
and the client will see a form like this
on the browser he will enter all
required values in the fields name and
Hobbie and we'll hit on this button that
is summer button once the client hits
this button the request will again reach
to this application with this URL and
auth type post how simply because of the
post method which is used in the form
and the URL so this action added and
then the front controller would state
away make a call to this method after
finding that the pattern of this method
is matching up with this URL as well as
the method type for this method is
matching up with this request that is
post all right guess now I'm going to
talk about a very important thing and I
would need a little more attention of
your
to understand it when the client submits
this form on the browser he will send
the values of these two request
parameters to this application along
with a request that is student name and
student hobbies values now when the
front controller makes a call to this
method the request param annotation used
in the method would simply retrieve the
values of student team and student hobby
request parameters from the request in
this body here the request paramagnet
asian will simply bind the value of
student name with the name variable and
the value of student hobby with the
Hobby variable in the method so here for
the in the method you can use these
values anywhere you want
alright let's proceed further the method
here is simply returning a model and
view object back to the front controller
having the view details and the message
which has to be printed in the response
of a page all right so once it prepares
and sends modern view object back to the
front controller now the front
controller would forward the request to
the admission success dot JSP file with
the help of view resolver class and here
the file is simply putting the message
value which the method has already set
here along with other HTML code and
sends this response back to the front
controller and the front controller
would in turn sends this response after
the clients browser so when it client
submits this form my application here is
sending this response back turd because
there are a couple of points you should
know about a request param and ation
here when the clients submitted a form
with gone to Ana's name and music's
hobby my application returned same
values for the
Qwest parameters in the response now
what if the client doesn't provide the
value of fluent name on submit the form
my application here has sent back an
empty string for name and music for
hobby now what if in this case I want to
give some default values to student name
when the client doesn't provide value
for it I can do that
using this syntax so here what I am
Telling with the default value property
of request by an annotation I am simply
saying his spring MVC framework when the
user would not provide value of student
name then please assign this default
value to student name all right so now
after this change let's see on the
browser if I do not provide the value of
student name what my application does
cool my application has considered the
value of name as mr. ABC XYZ because of
this default value property there is one
more important point to know about a
request of an annotation what if you're
tired of putting these many requests
Parham annotations here in the method
argument to retrieve all values of
request parameters which are coming all
along with the request you can simply
avoid these many requests param
annotations in the method argument by
using only one request param annotation
on a map as we saw in the previous
tutorial in the case of path variable
annotation so what you will do will
simply use request param annotation on a
map and further in the method you will
retrieve the values of student name and
hobby request parameters from the map
like this guys a big thank you for
liking my tutorials on spring MVC series
if you have any queries or feedback
please provide them below the video in
the comments section or simply write to
me on this ID
for all of your queries please hit the
like button if you really like the video
and do not forget to subscribe to my
youtube channel canto series and I'm
going to catch you in my next tutorial