package com.rmigb.controller;

 

 import org.springframework.stereotype.Controller;

 import org.springframework.ui.Model;

 import org.springframework.web.bind.annotation.RequestMapping;

 import org.springframework.web.bind.annotation.RequestMethod;

 

/*
Spring MVC Hello World Tutorial
In this Spring MVC tutorial we will create a small hello world application using Spring 3.0 MVC in Eclipse and Tomcat. We will also learn about spring annotations like @Controller, @RequestMapping.
HelloworldController.java
A Spring Controller
*/

 @Controller

 public class HelloworldController {

/*
Mapping '/sayhello'
When user navigates to url 'http://localhost:8080/sayhello', this code executes.
*/

   @RequestMapping(method=RequestMethod.GETvalue="/sayhello")

   public String showHelloworld(Model model)

   {

     model.addAttribute("helloworldmessage""Hello World! This is my first Spring MVC Program");

     return "hello";

   }

 }

/*
hello.jsp
A Simple view to display a message
*/

 <%taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>

 <%page session="false"%>

 <html>

 <head>

 <title>Hello World</title>

 </head>

 <body>

   <h1>Message From Server is  : ${helloworldmessage}</h1>

 </body>

 </html>

/*
root-context.xml
It is generally used to contain beans that are shared between all servlets in a webapp. We have just one servlet in our application, that is DispatcherServlet . so we dont need to declare any bean here.we will declare all required beans in servlet-context.xml file. So for our this application, this file is unnecessary.
*/

 <?xml version="1.0" encoding="UTF-8_1"?>

 <beans xmlns="http://www.springframework.org/schema/beans"

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

   

   <!-- Root Context: defines shared resources visible to all other web components -->

     

 </beans>

/*
servlet-context.xml
The servlet-context.xml defines the beans for one servlet's app context. we can have more than one this kind of configuration files in single application.
for this application, all Spring MVC configuration detail is defined in this file.
*/

 <?xml version="1.0" encoding="UTF-8_1"?>

 <beans:beans xmlns="http://www.springframework.org/schema/mvc"

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xmlns:beans="http://www.springframework.org/schema/beans"

   xmlns:context="http://www.springframework.org/schema/context"

   xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd

     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

 

   

/*
<annotation-driven />
we know we use @Controller, @RequestMapping and other annotations in our Spring MVC application. all these annotations have different purposes. <annotation-driven/> is just used to enable these annotations in our application.
In short, we have to write this code in configuration file, if we want to use annotations in our application
*/

   <annotation-driven />

 

/*
<resources>
it is used to specify all static contents's location in our web application, for example, we can set here path for js, css.
But in our application, we are not using any static resource So we can remove this line.
*/

   <resources mapping="/resources/**" location="/resources/" />

 

/*
View Resolver
After execution, controller returns a logical name, InternalResourceViewResolver add prefix and suffix to that name and provide a view for a particular request.
for example, if controller's method returns hello, then view will be '/WEB-INF/views/hello.jsp' and this view will be rendered and output displayed on browser's screen.
*/

   <beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">

     <beans:property name="prefix" value="/WEB-INF/views/" />

     <beans:property name="suffix" value=".jsp" />

   </beans:bean>

/*
component-scan
Here we mention those classes' path, in which we are using @Controller, @Repository, @service, @component annotations. and so that it can scan and registers those beans with application context
*/

   <context:component-scan base-package="com.rmigb.controller" />

 </beans:beans>

/*
web.xml
A web application's deployment descriptor describes the classes, resources and configuration of the application and how the web server uses them to serve web requests. When the web server receives a request for the application, it uses the deployment descriptor to map the URL of the request to the code that ought to handle the request.

for more details :
http://en.wikipedia.org/wiki/Deployment_descriptor
*/

 <?xml version="1.0" encoding="UTF-8_1"?>

 <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

 

   <!-- The definition of the Root Spring Container shared by all Servlets and Filters -->

/*
<context-param>
Here we specify location of root-context.xml file, A configuration file which is shared by all servlets and filters.
*/

   <context-param>

     <param-name>contextConfigLocation</param-name>

     <param-value>/WEB-INF/spring/root-context.xml</param-value>

   </context-param>

   

   <!-- Creates the Spring Container shared by all Servlets and Filters -->

/*
<listener>
ContextLoaderListener

As we know, we define our configuration detail in root-context.xml.ContextLoaderListener loads this configuration detail on startup and save it as context so we can use that configuration anywhere in application.
*/

   <listener>

     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

   </listener>

 

   <!-- Processes application requests -->

/*
DispatcherServlet
DispatcherServlet is used to handle incoming request's and searches the handler according to request's url and then move the client request to that handler.
Here We are also specifying location of servlet-context.xml configuration file.
this xml file contains all configuration for spring MVC for example: our controllers, converters, viewresolvers etc.
*/

   <servlet>

     <servlet-name>appServlet</servlet-name>

     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

     <init-param>

       <param-name>contextConfigLocation</param-name>

       <param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>

     </init-param>

     <load-on-startup>1</load-on-startup>

   </servlet>

     

/*
<servlet-mapping>
<url-pattern>/</url-pattern> means, all incoming requests are handled by appServlet(defined above)
*/

   <servlet-mapping>

     <servlet-name>appServlet</servlet-name>

     <url-pattern>/</url-pattern>

   </servlet-mapping>

 

 </web-app>

/*
First of all, we are going to see the structure of this project.
Lets first start with pom.xml.

pom.xml
It contains information about the project and configuration details used by Maven to build the project.
for more details :
http://maven.apache.org/guides/introduction/introduction-to-the-pom.html#What_is_a_POM
*/

 <?xml version="1.0" encoding="UTF-8_1"?>

 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation="http://maven.apache.org/POM_1/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

   <modelVersion>4.0.0</modelVersion>

   <groupId>com.mycompany</groupId>

   <artifactId>rohit</artifactId>

   <name>mynetbeansproject</name>

   <packaging>war</packaging>

   <version>1.0.0-BUILD-SNAPSHOT</version>

   <properties>

     <java-version>1.6</java-version>

     <org.springframework-version>3.1.1.RELEASE</org.springframework-version>

     <org.aspectj-version>1.6.10</org.aspectj-version>

     <org.slf4j-version>1.6.6</org.slf4j-version>

   </properties>

   <dependencies>

     <!-- Spring -->

     <dependency>

       <groupId>org.springframework</groupId>

       <artifactId>spring-context</artifactId>

       <version>${org.springframework-version}</version>

       <exclusions>

         <!-- Exclude Commons Logging in favor of SLF4j -->

         <exclusion>

           <groupId>commons-logging</groupId>

           <artifactId>commons-logging</artifactId>

          </exclusion>

       </exclusions>

     </dependency>

     <dependency>

       <groupId>org.springframework</groupId>

       <artifactId>spring-webmvc</artifactId>

       <version>${org.springframework-version}</version>

     </dependency>

         

     <!-- AspectJ -->

     <dependency>

       <groupId>org.aspectj</groupId>

       <artifactId>aspectjrt</artifactId>

       <version>${org.aspectj-version}</version>

     </dependency>  

     

     <!-- Logging -->

     <dependency>

       <groupId>org.slf4j</groupId>

       <artifactId>slf4j-api</artifactId>

       <version>${org.slf4j-version}</version>

     </dependency>

     <dependency>

       <groupId>org.slf4j</groupId>

       <artifactId>jcl-over-slf4j</artifactId>

       <version>${org.slf4j-version}</version>

       <scope>runtime</scope>

     </dependency>

     <dependency>

       <groupId>org.slf4j</groupId>

       <artifactId>slf4j-log4j12</artifactId>

       <version>${org.slf4j-version}</version>

       <scope>runtime</scope>

     </dependency>

     <dependency>

       <groupId>log4j</groupId>

       <artifactId>log4j</artifactId>

       <version>1.2.15</version>

       <exclusions>

         <exclusion>

           <groupId>javax.mail</groupId>

           <artifactId>mail</artifactId>

         </exclusion>

         <exclusion>

           <groupId>javax.jms</groupId>

           <artifactId>jms</artifactId>

         </exclusion>

         <exclusion>

           <groupId>com.sun.jdmk</groupId>

           <artifactId>jmxtools</artifactId>

         </exclusion>

         <exclusion>

           <groupId>com.sun.jmx</groupId>

           <artifactId>jmxri</artifactId>

         </exclusion>

       </exclusions>

       <scope>runtime</scope>

     </dependency>

 

     <!-- @Inject -->

     <dependency>

       <groupId>javax.inject</groupId>

       <artifactId>javax.inject</artifactId>

       <version>1</version>

     </dependency>

         

     <!-- Servlet -->

     <dependency>

       <groupId>javax.servlet</groupId>

       <artifactId>servlet-api</artifactId>

       <version>2.5</version>

       <scope>provided</scope>

     </dependency>

     <dependency>

       <groupId>javax.servlet.jsp</groupId>

       <artifactId>jsp-api</artifactId>

       <version>2.1</version>

       <scope>provided</scope>

     </dependency>

     <dependency>

       <groupId>javax.servlet</groupId>

       <artifactId>jstl</artifactId>

       <version>1.2</version>

     </dependency>

   

     <!-- Test -->

     <dependency>

       <groupId>junit</groupId>

       <artifactId>junit</artifactId>

       <version>4.7</version>

       <scope>test</scope>

     </dependency>        

   </dependencies>

     <build>

         <plugins>

             <plugin>

                 <artifactId>maven-eclipse-plugin</artifactId>

                 <version>2.9</version>

                 <configuration>

                     <additionalProjectnatures>

                         <projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>

                     </additionalProjectnatures>

                     <additionalBuildcommands>

                         <buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>

                     </additionalBuildcommands>

                     <downloadSources>true</downloadSources>

                     <downloadJavadocs>true</downloadJavadocs>

                 </configuration>

             </plugin>

             <plugin>

                 <groupId>org.apache.maven.plugins</groupId>

                 <artifactId>maven-compiler-plugin</artifactId>

                 <version>2.5.1</version>

                 <configuration>

                     <source>1.6</source>

                     <target>1.6</target>

                     <compilerArgument>-Xlint:all</compilerArgument>

                     <showWarnings>true</showWarnings>

                     <showDeprecation>true</showDeprecation>

                 </configuration>

             </plugin>

             <plugin>

                 <groupId>org.codehaus.mojo</groupId>

                 <artifactId>exec-maven-plugin</artifactId>

                 <version>1.2.1</version>

                 <configuration>

                     <mainClass>org.test.int1.Main</mainClass>

                 </configuration>

             </plugin>

         </plugins>

     </build>

 </project>

Spring MVC Hello World Example
In this example, We are going to learn writing a simple Web Based Hello World application


What tools we require to develop this application?
(1) JDK 1.5 (or above), (2) Tomcat 5.X (or above), (3) Eclipse 3.2.X (or above) (4) Spring MVC 3.0

How to study this code?
(1.) In this example, We are going to send a "hello world" message from controller to view.
(2.) We can start from web.xml file. It is better to learn about DispatcherServlet, ContextLoaderListener first.
(3.) Then We can move to ServletConfig.java file to learn all configuration needed to develop this project
(4.) After that We can view HelloWorldController and hello.jsp view.
(5.) Then, we can start its debugging by pressing keyboard's down arrow key.
(6.) To know more about this program, you can talk directly to us : click here (7.) Lets close this dialog and start learning this code line by line.

Steps to learn Spring MVC Hello world application
  • This handler method is mapped with url http://localhost:8080/sayhello . So when I navigates to http://localhost:8080/sayhello, control comes here.

    At this line, we are adding an attribute in model with key=helloworldmessage and value=Hello World! This is my first Spring MVC Program, so that it can be accessed in view hello.jsp.

    Why we use model?
    We use model to transfer data from Controller to view.
  • return hello; means, control will now move to hello.jsp view.

    Why control will move to hello.jsp?

    After this code's execution, next task is to represent data in some readable format(like excel, jsp, csv, pdf etc.)
    This work is done by viewresolvers.
    Spring MVC offers us different viewresolvers to represent data in different format..

    In this program, We are using InternalResourceViewResolver to represent data in jsp view.

    As you can see in servlet-context.xml, We have defined a bean of type InternalResourceViewResolver

    internalResourceViewResolver will now convert this return hello to /WEB-INF/views/hello.jsp.

    That's why control will now move to hello.jsp
  • Control is here at hello.jsp view. in this view, we will only display the message, what we saved in model as attribure
  • Control is here at hello.jsp view. in this view, we only display a message, that we have saved in model as attribure
  • This line prints :Message From Server is :Hello World! This is my first Spring MVC Program on web page

    We will see this view's output soon.
  • At next line, we will see the rendered html of this view..

@*

url:

*@

Spring MVC Hello World Example

In this example, We are going to learn writing a simple Web Based Hello World application

What tools we require to develop this application?

(1) JDK 1.5 (or above), (2) Tomcat 5.X (or above), (3) Eclipse 3.2.X (or above) (4) Spring MVC 3.0

How to study this code?

(1.) In this example, We are going to send a "hello world" message from controller to view.
(2.) We can start from web.xml file. It is better to learn about DispatcherServlet, ContextLoaderListener first.
(3.) Then We can move to ServletConfig.java file to learn all configuration needed to develop this project
(4.) After that We can view HelloWorldController and hello.jsp view.
(5.) Then, we can start its debugging by pressing keyboard's down arrow key.
(6.) Lets close this dialog and start learning this code line by line.

Comments

VARIABLES INFO

OUTPUT ON CONSOLE

PRESS DOWN ARROW

 Once There

 

 Was A

 Rohit Malhotra

 He Was Very

 Good boy

 Once There

 

 Was A

 Rohit Malhotra

 He Was Very

 Good boy

 Once There

 

 Was A

 Rohit Malhotra

 He Was Very

 Good boy

We have three ways to learn this code