`

spring mvc详解

阅读更多

  现在主流的Web MVC框架除了Struts这个主力 外,其次就是Spring MVC了,因此这也是作为一名程序员需要掌握的主流框架,框架选择多了,应对多变的需求和业务时,可实行的方案自然就多了。不过要想灵活运用Spring MVC来应对大多数的Web开发,就必须要掌握它的配置及原理。

  一、Spring MVC环境搭建:(Spring 2.5.6 + Hibernate 3.2.0)

  1. jar包引入

  Spring 2.5.6:spring.jar、spring-webmvc.jar、commons-logging.jar、cglib-nodep-2.1_3.jar

  Hibernate 3.6.8:hibernate3.jar、hibernate-jpa-2.0-api-1.0.1.Final.jar、antlr-2.7.6.jar、commons-collections-3.1、dom4j-1.6.1.jar、javassist-3.12.0.GA.jar、jta-1.1.jar、slf4j-api-1.6.1.jar、slf4j-nop-1.6.4.jar、相应数据库的驱动jar包

  2. web.xml配置(部分)

  1. <!-- Spring MVC配置 -->
  2. <!-- ====================================== -->
  3. <servlet>
  4. <servlet-name>spring</servlet-name>
  5. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  6. <!-- 可以自定义servlet.xml配置文件的位置和名称,默认为WEB-INF目录下,名称为[<servlet-name>]-servlet.xml,如spring-servlet.xml
  7. <init-param>
  8. <param-name>contextConfigLocation</param-name>
  9. <param-value>/WEB-INF/spring-servlet.xml</param-value> 默认
  10. </init-param>
  11. -->
  12. <load-on-startup>1</load-on-startup>
  13. </servlet>
  14. <servlet-mapping>
  15. <servlet-name>spring</servlet-name>
  16. <url-pattern>*.do</url-pattern>
  17. </servlet-mapping>
  18. <!-- Spring配置 -->
  19. <!-- ====================================== -->
  20. <listener>
  21. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  22. </listener>
  23. <!-- 指定Spring Bean的配置文件所在目录。默认配置在WEB-INF目录下 -->
  24. <context-param>
  25. <param-name>contextConfigLocation</param-name>
  26. <param-value>classpath:config/applicationContext.xml</param-value>
  27. </context-param>
<!-- Spring MVC配置 -->
<!-- ====================================== -->
<servlet>
	<servlet-name>spring</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	<!-- 可以自定义servlet.xml配置文件的位置和名称,默认为WEB-INF目录下,名称为[<servlet-name>]-servlet.xml,如spring-servlet.xml
	<init-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>/WEB-INF/spring-servlet.xml</param-value>  默认
	</init-param>
	-->
	<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
	<servlet-name>spring</servlet-name>
	<url-pattern>*.do</url-pattern>
</servlet-mapping>
  


<!-- Spring配置 -->
<!-- ====================================== -->
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
  

<!-- 指定Spring Bean的配置文件所在目录。默认配置在WEB-INF目录下 -->
<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>classpath:config/applicationContext.xml</param-value>
</context-param>

  3. spring-servlet.xml配置

  spring-servlet这个名字是因为上面web.xml中<servlet-name>标签配的值为spring(<servlet-name>spring</servlet-name>),再加上“-servlet”后缀而形成的spring-servlet.xml文件名,如果改为springMVC,对应的文件名则为springMVC-servlet.xml。

  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <beansxmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:p="http://www.springframework.org/schema/p"
  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  6. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
  7. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
  8. http://www.springframework.org/schema/context <ahref="http://www.springframework.org/schema/context/spring-context-3.0.xsd">http://www.springframework.org/schema/context/spring-context-3.0.xsd</a>">
  9. <!-- 启用spring mvc 注解 -->
  10. <context:annotation-config/>
  11. <!-- 设置使用注解的类所在的jar包 -->
  12. <context:component-scanbase-package="controller"></context:component-scan>
  13. <!-- 完成请求和注解POJO的映射 -->
  14. <beanclass="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/>
  15. <!-- 对转向页面的路径解析。prefix:前缀, suffix:后缀 -->
  16. <beanclass="org.springframework.web.servlet.view.InternalResourceViewResolver"p:prefix="/jsp/"p:suffix=".jsp"/>
  17. </beans>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"     
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"     
        xmlns:context="http://www.springframework.org/schema/context"     
   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd   
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd   
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd   
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">

	<!-- 启用spring mvc 注解 -->
	<context:annotation-config />

	<!-- 设置使用注解的类所在的jar包 -->
	<context:component-scan base-package="controller"></context:component-scan>

	<!-- 完成请求和注解POJO的映射 -->
	<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />

	<!-- 对转向页面的路径解析。prefix:前缀, suffix:后缀 -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" p:prefix="/jsp/" p:suffix=".jsp" />
</beans>

  4. applicationContext.xml配置

  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <beansxmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:aop="http://www.springframework.org/schema/aop"
  5. xmlns:tx="http://www.springframework.org/schema/tx"
  6. xsi:schemaLocation="
  7. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
  8. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
  9. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
  10. <!-- 采用hibernate.cfg.xml方式配置数据源 -->
  11. <beanid="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
  12. <propertyname="configLocation">
  13. <value>classpath:config/hibernate.cfg.xml</value>
  14. </property>
  15. </bean>
  16. <!-- 将事务与Hibernate关联 -->
  17. <beanid="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  18. <propertyname="sessionFactory">
  19. <reflocal="sessionFactory"/>
  20. </property>
  21. </bean>
  22. <!-- 事务(注解 )-->
  23. <tx:annotation-driventransaction-manager="transactionManager"proxy-target-class="true"/>
  24. <!-- 测试Service -->
  25. <beanid="loginService"class="service.LoginService"></bean>
  26. <!-- 测试Dao -->
  27. <beanid="hibernateDao"class="dao.HibernateDao">
  28. <propertyname="sessionFactory"ref="sessionFactory"></property>
  29. </bean>
  30. </beans>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		xmlns:aop="http://www.springframework.org/schema/aop"
		xmlns:tx="http://www.springframework.org/schema/tx"
		xsi:schemaLocation="
			http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
			http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
			http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

	<!-- 采用hibernate.cfg.xml方式配置数据源 -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="configLocation">
			<value>classpath:config/hibernate.cfg.xml</value>
		</property>
	</bean>
	
	<!-- 将事务与Hibernate关联 -->
	<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory">
			<ref local="sessionFactory"/>
		</property>
	</bean>
	
	<!-- 事务(注解 )-->
	<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/>

 	<!-- 测试Service -->
 	<bean id="loginService" class="service.LoginService"></bean>

	<!-- 测试Dao -->
	<bean id="hibernateDao" class="dao.HibernateDao">
		<property name="sessionFactory" ref="sessionFactory"></property>
	</bean>
</beans>

 

  二、详解

  Spring MVC与Struts从原理上很相似(都是基于MVC架构),都有一个控制页面请求的Servlet,处理完后跳转页面。看如下代码(注解):

  1. package controller;
  2. import javax.servlet.http.HttpServletRequest;
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.RequestParam;
  6. import entity.User;
  7. @Controller//类似Struts的Action
  8. publicclass TestController {
  9. @RequestMapping("test/login.do") // 请求url地址映射,类似Struts的action-mapping
  10. public String testLogin(@RequestParam(value="username")String username, String password, HttpServletRequest request) {
  11. // @RequestParam是指请求url地址映射中必须含有的参数(除非属性required=false)
  12. // @RequestParam可简写为:@RequestParam("username")
  13. if (!"admin".equals(username) || !"admin".equals(password)) {
  14. return"loginError"; // 跳转页面路径(默认为转发),该路径不需要包含spring-servlet配置文件中配置的前缀和后缀
  15. }
  16. return"loginSuccess";
  17. }
  18. @RequestMapping("/test/login2.do")
  19. public ModelAndView testLogin2(String username, String password, int age){
  20. // request和response不必非要出现在方法中,如果用不上的话可以去掉
  21. // 参数的名称是与页面控件的name相匹配,参数类型会自动被转换
  22. if (!"admin".equals(username) || !"admin".equals(password) || age < 5) {
  23. returnnew ModelAndView("loginError"); // 手动实例化ModelAndView完成跳转页面(转发),效果等同于上面的方法返回字符串
  24. }
  25. returnnew ModelAndView(new RedirectView("../index.jsp")); // 采用重定向方式跳转页面
  26. // 重定向还有一种简单写法
  27. // return new ModelAndView("redirect:../index.jsp");
  28. }
  29. @RequestMapping("/test/login3.do")
  30. public ModelAndView testLogin3(User user) {
  31. // 同样支持参数为表单对象,类似于Struts的ActionForm,User不需要任何配置,直接写即可
  32. String username = user.getUsername();
  33. String password = user.getPassword();
  34. int age = user.getAge();
  35. if (!"admin".equals(username) || !"admin".equals(password) || age < 5) {
  36. returnnew ModelAndView("loginError");
  37. }
  38. returnnew ModelAndView("loginSuccess");
  39. }
  40. @Resource(name = "loginService") // 获取applicationContext.xml中bean的id为loginService的,并注入
  41. private LoginService loginService; //等价于spring传统注入方式写get和set方法,这样的好处是简洁工整,省去了不必要得代码
  42. @RequestMapping("/test/login4.do")
  43. public String testLogin4(User user) {
  44. if (loginService.login(user) == false) {
  45. return"loginError";
  46. }
  47. return"loginSuccess";
  48. }
  49. }
package controller;

import javax.servlet.http.HttpServletRequest;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import entity.User;

@Controller  //类似Struts的Action
public class TestController {

	@RequestMapping("test/login.do")  // 请求url地址映射,类似Struts的action-mapping
	public String testLogin(@RequestParam(value="username")String username, String password, HttpServletRequest request) {
		// @RequestParam是指请求url地址映射中必须含有的参数(除非属性required=false)
		// @RequestParam可简写为:@RequestParam("username")

		if (!"admin".equals(username) || !"admin".equals(password)) {
			return "loginError"; // 跳转页面路径(默认为转发),该路径不需要包含spring-servlet配置文件中配置的前缀和后缀
		}
		return "loginSuccess";
	}

	@RequestMapping("/test/login2.do")
	public ModelAndView testLogin2(String username, String password, int age){
		// request和response不必非要出现在方法中,如果用不上的话可以去掉
		// 参数的名称是与页面控件的name相匹配,参数类型会自动被转换
		
		if (!"admin".equals(username) || !"admin".equals(password) || age < 5) {
			return new ModelAndView("loginError"); // 手动实例化ModelAndView完成跳转页面(转发),效果等同于上面的方法返回字符串
		}
		return new ModelAndView(new RedirectView("../index.jsp"));  // 采用重定向方式跳转页面
		// 重定向还有一种简单写法
		// return new ModelAndView("redirect:../index.jsp");
	}

	@RequestMapping("/test/login3.do")
	public ModelAndView testLogin3(User user) {
		// 同样支持参数为表单对象,类似于Struts的ActionForm,User不需要任何配置,直接写即可
		String username = user.getUsername();
		String password = user.getPassword();
		int age = user.getAge();
		
		if (!"admin".equals(username) || !"admin".equals(password) || age < 5) {
			return new ModelAndView("loginError");
		}
		return new ModelAndView("loginSuccess");
	}

	@Resource(name = "loginService")  // 获取applicationContext.xml中bean的id为loginService的,并注入
	private LoginService loginService;  //等价于spring传统注入方式写get和set方法,这样的好处是简洁工整,省去了不必要得代码

	@RequestMapping("/test/login4.do")
	public String testLogin4(User user) {
		if (loginService.login(user) == false) {
			return "loginError";
		}
		return "loginSuccess";
	}
}

  以上4个方法示例,是一个Controller里含有不同的请求url,也可以采用一个url访问,通过url参数来区分访问不同的方法,代码如下:

  1. package controller;
  2. import org.springframework.stereotype.Controller;
  3. import org.springframework.web.bind.annotation.RequestMapping;
  4. import org.springframework.web.bind.annotation.RequestMethod;
  5. @Controller
  6. @RequestMapping("/test2/login.do") // 指定唯一一个*.do请求关联到该Controller
  7. publicclass TestController2 {
  8. @RequestMapping
  9. public String testLogin(String username, String password, int age) {
  10. // 如果不加任何参数,则在请求/test2/login.do时,便默认执行该方法
  11. if (!"admin".equals(username) || !"admin".equals(password) || age < 5) {
  12. return"loginError";
  13. }
  14. return"loginSuccess";
  15. }
  16. @RequestMapping(params = "method=1", method=RequestMethod.POST)
  17. public String testLogin2(String username, String password) {
  18. // 依据params的参数method的值来区分不同的调用方法
  19. // 可以指定页面请求方式的类型,默认为get请求
  20. if (!"admin".equals(username) || !"admin".equals(password)) {
  21. return"loginError";
  22. }
  23. return"loginSuccess";
  24. }
  25. @RequestMapping(params = "method=2")
  26. public String testLogin3(String username, String password, int age) {
  27. if (!"admin".equals(username) || !"admin".equals(password) || age < 5) {
  28. return"loginError";
  29. }
  30. return"loginSuccess";
  31. }
  32. }
package controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/test2/login.do")  // 指定唯一一个*.do请求关联到该Controller
public class TestController2 {
	
	@RequestMapping
	public String testLogin(String username, String password, int age) {
		// 如果不加任何参数,则在请求/test2/login.do时,便默认执行该方法
		
		if (!"admin".equals(username) || !"admin".equals(password) || age < 5) {
			return "loginError";
		}
		return "loginSuccess";
	}

	@RequestMapping(params = "method=1", method=RequestMethod.POST)
	public String testLogin2(String username, String password) {
		// 依据params的参数method的值来区分不同的调用方法
		// 可以指定页面请求方式的类型,默认为get请求
		
		if (!"admin".equals(username) || !"admin".equals(password)) {
			return "loginError";
		}
		return "loginSuccess";
	}
	
	@RequestMapping(params = "method=2")
	public String testLogin3(String username, String password, int age) {
		if (!"admin".equals(username) || !"admin".equals(password) || age < 5) {
			return "loginError";
		}
		return "loginSuccess";
	}
}

  其实RequestMapping在Class上,可看做是父Request请求url,而RequestMapping在方法上的可看做是子Request请求url,父子请求url最终会拼起来与页面请求url进行匹配,因此RequestMapping也可以这么写:

  1. package controller;
  2. import org.springframework.stereotype.Controller;
  3. import org.springframework.web.bind.annotation.RequestMapping;
  4. @Controller
  5. @RequestMapping("/test3/*") // 父request请求url
  6. publicclass TestController3 {
  7. @RequestMapping("login.do") // 子request请求url,拼接后等价于/test3/login.do
  8. public String testLogin(String username, String password, int age) {
  9. if (!"admin".equals(username) || !"admin".equals(password) || age < 5) {
  10. return"loginError";
  11. }
  12. return"loginSuccess";
  13. }
  14. }
package controller;

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

@Controller
@RequestMapping("/test3/*")  // 父request请求url
public class TestController3 {

	@RequestMapping("login.do")  // 子request请求url,拼接后等价于/test3/login.do
	public String testLogin(String username, String password, int age) {
		if (!"admin".equals(username) || !"admin".equals(password) || age < 5) {
			return "loginError";
		}
		return "loginSuccess";
	}
}

 

  三、结束语

  掌握以上这些Spring MVC就已经有了很好的基础了,几乎可应对与任何开发,在熟练掌握这些后,便可更深层次的灵活运用的技术,如多种视图技术,例如 Jsp、Velocity、Tiles、iText 和 POI。Spring MVC框架并不知道使用的视图,所以不会强迫您只使用 JSP 技术

 

本文转自:http://blog.csdn.net/wangpeng047/article/details/6983027

分享到:
评论

相关推荐

    Spring MVC详解(学习总结).txt

    Spring MVC详解(学习总结)Spring MVC详解(学习总结)Spring MVC详解(学习总结)Spring MVC详解(学习总结)Spring MVC详解(学习总结)Spring MVC详解(学习总结)Spring MVC详解(学习总结)Spring MVC详解(学习总结)Spring ...

    使用Spring 2.5 基于注解驱动的 Spring MVC详解

    使用 Spring 2.5 基于注解驱动的 Spring MVC 详解 本文将介绍 Spring 2.5 新增的 Spring MVC 注解功能,讲述如何使用注解配置替换传统的基于 XML 的 Spring MVC 配置。 Spring MVC 注解驱动 在 Spring 2.5 中,...

    spring MVC配置详解

    Spring MVC 配置详解 Spring MVC 是一个基于 DispatcherServlet 的 MVC 框架,它是当前主流的 Web 框架之一。要想灵活运用 Spring MVC 来应对大多数的 Web 开发,就必须要掌握它的配置及原理。 一、Spring MVC ...

    注解的spring MVC 详解

    该文档时基于注解的当前流行的SpringMVC框架,涵盖了springMVC常用的注解的使用方法!以及文件的配置,和案例!

    spring mvc过程详解

    #### 六、Spring MVC 配置文件详解 Spring MVC 的配置文件通常包含了以下几个关键部分: 1. **DispatcherServlet 配置**:配置 DispatcherServlet 如何初始化以及加载配置文件。 2. **视图解析器配置**:配置 ...

    spring mvc + es

    **Spring MVC详解** Spring MVC 提供了一个灵活且可扩展的Web应用程序开发模型,通过解耦控制器、服务、模型和视图,使得开发者可以独立地进行组件的开发和测试。其核心组件包括DispatcherServlet(调度器)、...

    Spring mvc(从入门到精通)

    Spring MVC 详解 Spring MVC 是一个基于 Java 的 Web 应用程序框架,基于模型-视图-控制器(MVC)模式。它提供了一个灵活的方式来开发 Web 应用程序,具有良好的可扩展性和灵活性。 Spring MVC 的核心组件 在 ...

    spring mvc Mybatis开发框架模板

    **Spring MVC详解** 1. **核心组件**:Spring MVC的核心组件包括DispatcherServlet、Controller、Model、View和ViewResolver。DispatcherServlet是入口,负责接收请求并分发到相应的处理器。Controller处理业务逻辑...

    spring mvc的配置文件详解

    ### Spring MVC 的配置文件详解 #### 一、配置分发器 (DispatcherServlet) Spring MVC 的核心组件之一就是 DispatcherServlet,它作为整个框架的入口,负责处理所有进入 Spring Web 应用程序的请求。为了使 ...

    Spring mvc 教程

    ### Spring MVC 教程知识点详解 #### Spring Web MVC 框架简介 Spring Web MVC 是 Spring Framework 的一个重要组成部分,主要用于构建基于 Java 的 Web 应用程序。它提供了一个灵活且强大的 MVC 实现,使得开发者...

    Spring mvc5.0.3 所有jar包

    **Spring MVC 5.0.3 知识点详解** Spring MVC是Spring框架的一个核心模块,专注于构建Web应用程序。在Spring MVC 5.0.3版本中,它提供了丰富的功能和改进,使得开发者能够更高效地开发RESTful服务、处理HTTP请求、...

    spring mvc案例+配置+原理详解+架包

    Spring MVC 是一个强大的Java Web开发框架,用于构建可维护、高性能和灵活的Web应用程序。它作为Spring框架的一部分,提供了一种模型-视图-控制器(MVC)架构,简化了处理HTTP请求和响应的复杂性。这个压缩包包含了...

    毕业设计管理系统java服务端,采用spring mvc.zip

    【Spring MVC详解】 Spring MVC是Spring框架的一个模块,主要用于构建Web应用的后端控制层。它提供了一种分层架构,将请求处理、业务逻辑和视图渲染分离,提高了代码的可测试性和可维护性。Spring MVC的核心组件包括...

Global site tag (gtag.js) - Google Analytics