SpringMVC配置过程

最新推荐文章于 2024-07-24 13:47:19 发布

喝醉的马儿

最新推荐文章于 2024-07-24 13:47:19 发布

阅读量5.5k

点赞数 5

分类专栏： Spring 文章标签： springmvc spring SpringMVC配置

原文链接：https://blog.csdn.net/fyytycoon/article/details/97617327

版权

Spring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

SpringMVC 配置过程

文章目录

SpringMVC 配置过程

一、创建Maven WEB 项目并添加Spring MVC 依赖

1.创建maven web项目
在这里插入图片描述

在这里插入图片描述

2.Web项目打包方式为war方式
在这里插入图片描述

3.生成web.xml(项目视图)
在这里插入图片描述

4.Web项目的target runtimes为tomcat
在这里插入图片描述

Web项目的编译版本为JDK1.8

6.添加Spring MVC项目依赖

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.3.8.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
		</dependency>
	</dependencies>

二、添加Spring MVC配置文件并进行基本配置

在项目的resources的目录中添加核心配置文件（例如spring-configs.xml）并进行基本配置

<?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:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"
	xmlns:jee="http://www.springframework.org/schema/jee"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:util="http://www.springframework.org/schema/util"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">

	<!-- 配置组件扫描 -->
	<context:component-scan base-package="cn.spring"></context:component-scan>
	<!--启用MVC默认配置 (@RequestMapping) -->
	<mvc:annotation-driven />
	<!-- 配置视图解析器 -->
	<bean id="viewResolver"
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/" />
		<property name="suffix" value=".jsp" />
	</bean>
	
</beans>

视图解析器

	处理请求的方法的参数是`String`类型时，默认表示响应给客户端的视图的名称，后续，会经过`ViewResolver`进行处理，得到具体的视图。
	
	首先，应该创建jsp页面，例如在**WEB-INF**下创建**index.jsp**文件，页面内容随意，例如显示“Hello, SpringMVC!!!”字样。
	
	然后，需要设计处理请求的方法的返回值，并配置`ViewResolver`！`ViewResolver`是一个接口，具体使用的实现类是`InternalResourceViewResolver`，需要在Spring的配置文件中配置它的`prefix`和`suffix`属性，分别表示“前缀”和“后缀”，`InternalResourceViewResolver`的工作模式是以**webapp**文件夹为根路径，将“前缀 + 处理请求的方法的返回值 + 后缀”得到具体的JSP文件的位置，刚才创建的JSP文件在**webapp/WEB-INF/index.jsp**，则可以：
	
		/WEB-INF/	+	index	+	.jsp
	
		""	+	/WEB-INF/index.jsp	+	""
	
	还可以是其他组合方式，只要能组合出文件的路径都是正确的，可以在处理请求的方法中返回`"index"`，然后配置为：
	
		<!-- 视图解析器 -->
		<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
			<property name="prefix" value="/WEB-INF/" />
			<property name="suffix" value=".jsp" />
		</bean>
	
	至此，开发完成，可以再次测试访问。

打开web.xml，配置DispatcherServlet对象

<servlet>
     <servlet-name>dispatcherServlet</servlet-name>
     <servlet-class> org.springframework.web.servlet.DispatcherServlet </servlet-class>
     <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-configs.xml</param-value>
     </init-param>
     <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
     <servlet-name>dispatcherServlet</servlet-name>
     <url-pattern>*.do</url-pattern>
  </servlet-mapping>

以上配置实现的效果就是：当Tomcat启动时，就会创建DispatcherServlet的对象，并且，DispatcherServlet会读取所配置的spring-configs.xml文件，以加载Spring环境，后续，DispatcherServlet将接收所有以.do为后缀的请求！

前端控制器是spring mvc处理请求的入口，是springmvc的核心，这个控制器一般需要在服务器启动时即初始化。
其中

在配置时，如果不明确DispatcherServlet的包名，可以随意创建某个Java类，在类中声明该Servlet，由Eclipse完成导包，则import语句中就有了该类的全名。

至此，DispatcherServlet就可以接收所有以.do为后缀的请求。

默认情况下，所有的Servlet都是第一次接收并处理请求时才完成的初始化操作，并且，SpringMVC框架是基于Spring框架基础之上的，在项目启动初期，就应该加载整个Spring环境，以保证SpringMVC框架能正常运行！所以，可以通过配置去实现：当启动Tomcat时，就直接初始化DispatcherServlet，在DispatcherServlet中，已经定义了某个属性，值是Spring配置文件的位置，当DispatcherServlet被初始化时，就会读取该配置文件！

在配置时，可以通过<load-on-startup>使得DispatcherServlet是默认直接初始化的！ ** 表示启动时则加载此servlet,数字越小优先级越高. 中的参数名不能变（此名字在DispatcherServlet父类中定义）**

在DispatcherServlet的父类FrameworkServlet中，有contextConfigLocation属性，其作用就是制定Spring配置文件的位置，一旦创建了DispatcherServlet对象，就会自动读取所配置的文件，以加载Spring的环境！

如果需要验证现在的配置结果，可以自定义cn.tedu.spring.User类，然后，在类中显式的定义构造方法：

	public class User {
		public User() {
			System.out.println("创建了User的对象！");
		}
	}

然后在Spring的配置文件中进行配置：

	<bean class="cn.tedu.spring.User" />

由于Tomcat启动时就会初始化DispatcherServlet，进而加载Spring配置文件，就会由Spring框架创建User对象，导致构造方法被执行，所以，当启动Tomcat时，就会看到构造方法中输出的内容！

2.2.4.创建并配置Spring MVC后端控制器

编写Spring MVC后端控制器，后端控制器在spring mvc中中又称之为handler。


@Controller
@RequestMapping("user")
public class HelloController {
	@RequestMapping("doSayHello.do")
	public ModelAndView doSayHello() {
		ModelAndView mv=new ModelAndView("hello");
		mv.addObject("message", "helloworld");
		return mv;
	}
	
	@RequestMapping("dologin.do")
	public String dologin() {
		return "login";
	}
	
	@RequestMapping(value="handle_login.do",method=RequestMethod.GET)
	public String dohandle_login(String username,String password,HttpSession session) {
		System.out.println(username);
		System.out.println(password);
		if ("root".equals(username)) {
			if ("1234".contentEquals(password)) {
				System.out.println("yes");
				session.setAttribute("username", username);
			}else {
				System.out.println("passnot");
			}
		}else {
			System.out.println("namenot");
		}
		return "index";
	}
}

其中:
1）通过@RequestMapping注解定义url到controller具体方法的映射,这个映射信息会被存储,一般是存储到一个HandlerMapping对象中.
2）ModelAndView对象为一个模型与视图对象，内置一个map对象，主要用于封装业务数据和视图名。
3）ModelAndView构造方法中传递的为视图名，addObject方法可以以key/value形式存储数据。
4）ModelAndView 对象返回时会被spring mvc自动存储到请求作用域，在对应的视图页面可以直接从此作用域获取对应的值。

创建JSP页面对象

在项目的WEB-INF/pages文件夹下创建hello.jsp文件，然后设置其内容，例如

<body>
   <h1>${message}</h1>
</body>

说明：WEB-INF目录下的资源不能允许通过浏览器地址栏直接访问。

三、Spring MVC拦截器编写及基本配置

拦截器是SpringMVC中的一个核心应用组件,主要用于处理多个Controller的共性问题.当我们的请求由DispatcherServlet派发到具体Controller之前首先要执行拦截器中一些相关方法,在这些方法中可以对请求进行相应预处理(例如权限检测,参数验证),这些方法可以决定对这个请求进行拦截还是放行.

首先，需要自定义cn.fyy.spring.LoginInterceptor拦截器类，实现HandlerInterceptor：

public class LoginInterceptor implements HandlerInterceptor {
	
		public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
				throws Exception {
			System.out.println("LoginInterceptor.preHandle()");
			return false;
		}
	
		public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
				ModelAndView modelAndView) throws Exception {
			System.out.println("LoginInterceptor.postHandle()");
		}
	
		public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
				throws Exception {
			System.out.println("LoginInterceptor.afterCompletion()");
		}
	
	}

再定义一个日志拦截器

当我们系统中有多个拦截器时,这些拦截器可以构成一个拦截器链.其原理类似过滤器中的过滤链。在多个拦截器应用中仅当所有匹配的拦截器的preHandle()都执行之后，才会调用Controller中处理请求的方法，然后再执行所有匹配的拦截器的postHandler()，再执行所有匹配的拦截器的afterCompletion()。
在拦截器链中，各拦截器的执行先后顺序取决于配置文件中配置的节点的先后顺序！

@Component
public class LogInterceptor extends HandlerInterceptorAdapter{
	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		System.out.println("log.preHandler");
		
		
		return true;
	}
	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
		System.out.println("log.afterCompletion");
	}
}

拦截器需要在Spring的配置文件中进行配置才可以使用：

 <!-- 配置拦截器 (要注意标签的编写顺序) -->
	<mvc:interceptors>
		<!-- 当存在多个拦截器时，哪个拦截器的方法先执行，要看拦截器配置的顺序 -->
		<mvc:interceptor>
			<mvc:mapping path="/user/*" />
			<ref bean="TimeInterceptor" />
		</mvc:interceptor>
		<mvc:interceptor>
			<!-- 拦截所有请求(这些请求要交给拦截器处理) -->
			<mvc:mapping path="/**" />
			<!-- 定制对哪些请求不拦截 (这些请求不需要拦截处理) -->
			<mvc:exclude-mapping path="/user/dologin.do" />
			<!-- 拦截器对象 -->
			<bean class="cn.spring.LoginInterceptor" />
		</mvc:interceptor>
	</mvc:interceptors>

如果需要实现“验证登录以决定是否拦截或者放行”的功能，需要重写拦截器类中的preHandle()方法：

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		System.out.println("LoginInterceptor.preHandle()");
		// 获取HttpSession对象
		HttpSession session = request.getSession();
		// 判断Session中有没有登录的数据
		if (session.getAttribute("username") == null) {
			// 没有登录数据，即未登录，则重定向到登录页
			// http://localhost:8080/XX/index.do
			// http://localhost:8080/XX/user/password.do
			String projectName = request.getServletContext().getContextPath();
			response.sendRedirect(projectName + "/user/login.do");
			// 返回false表示拦截，不允许向后执行
			return false;
		}
		// 返回true表示放行，允许向后执行
		return true;
	}

在这里插入图片描述

四、Spring MVC 请求处理

1. 接收请求参数

1.1. 【不推荐】通过HttpServletRequest获取请求参数

可以在处理请求的方法中，添加HttpServletRequest类型的参数，在处理过程中，调用该参数对象的String getParameter(String name)就可以获取请求参数，例如：

	@RequestMapping("handle_reg.do")
	public String handleReg(HttpServletRequest request) {
		System.out.println("UserController.handleReg()");
		String username = request.getParameter("username");
		String password = request.getParameter("password");
		Integer age = Integer.valueOf(request.getParameter("age"));
		String phone = request.getParameter("phone");
		String email = request.getParameter("email");
		
		System.out.println("\tusenrame=" + username);
		System.out.println("\tpassword=" + password);
		System.out.println("\tage=" + age);
		System.out.println("\tphone=" + phone);
		System.out.println("\temail=" + email);
		return null;
	}

通常，并不推荐使用这种做法！主要原因有：

使用比较繁琐，代码量较多；
需要手动实现数据类型的转换；
不便于实现单元测试。

1.2. 【推荐】将请求参数设计为处理请求的方法的参数

假设客户端将提交名为username的参数，则在控制器的方法中添加同名参数即可，参数的类型可以是期望的数据类型，例如期望age是Integer类型的，则声明为Integer age即可：

	@RequestMapping("handle_reg.do")
	public String handleReg(String username, String password, 
			Integer age, String phone, String email) {
		System.out.println("UserController.handleReg()");
		System.out.println("\t[2]username=" + username);
		System.out.println("\t[2]password=" + password);
		System.out.println("\t[2]age=" + age);
		System.out.println("\t[2]phone=" + phone);
		System.out.println("\t[2]email=" + email);
		return null;
	}

使用这种做法时，需要保证参数的名称与客户端提交的请求参数名称保持一致，否则，在控制器中的参数将是null值。

使用这种做法的优点很多，基本上解决了使用HttpServletRequest获取参数时的所有问题！

使用这种做法并不适用于请求参数的数量较多的应用场景！

1.3. 【推荐】使用封装的类型接收较多的请求参数

当客户端提交的请求参数较多时，可以将这些参数全部封装为1个自定义的数据类型，例如：

	public class User {

		private String username;
		private String password;
		private Integer age;
		private String phone;
		private String email;
		
		// SET/GET
	}

然后，将该类型作为处理请求的方法的参数即可：

	@RequestMapping("handle_reg.do")
	public String handleReg(User user) {
		System.out.println("UserController.handleReg()");
		System.out.println("\t" + user);
		return null;
	}

在使用这种做法时，需要保证客户端提交的请求参数，与自定义的数据类型中的属性名称是保持一致的！

2.响应处理

2.1 重定向

当处理请求的方法的返回值是String类型的，则返回的字符串使用redirect:作为前缀，加上重定向的目标路径，就可以实现重定向的效果。

在这里插入图片描述

2.2 转发

在这里插入图片描述

2.2.1 执行转发

当处理请求的方法的返回值是String类型，默认情况下，返回值就表示转发的意思，返回值将经过视图解析器，确定转发到的目标页面。

转发时，处理请求的方法的返回值也可以使用forward:作为前缀，由于默认就是转发，所以不必显式的添加前缀。

2.2.2 【不推荐】通过HttpServletRequest封装需要转发的数据

假设在登录过程中，仅当用户名为root且密码是1234时允许登录，否则，在错误提示页面中提示错误的原因。

由于错误信息可能有2种，分别是用户名错误和密码错误，使用JSP页面结合EL表达式可以显示转发的数据，在控制器转发之前，就需要将错误信息封装到HttpServletRequest对象中，则后续JSP页面才可以通过EL表达式读取HttpServletRequest对象中的数据。

可以在处理请求的方法的参数列表中添加HttpServletRequest类型的参数，当添加多项参数时（既有用户名、密码，又有HttpServletRequest），各参数不必区分先后顺序，当添加了参数后，调用HttpServletRequest参数对象的setAttribute(String name, String value)方法封装需要转发的数据即可，无需获取转发器对象执行转发，只要最后返回字符串就表示转发：

	@RequestMapping("handle_login.do")
	public String handleLogin(String username, String password,
			HttpServletRequest request) {
		// 日志
		System.out.println("UserController.handleLogin()");
		
		// 判断用户名是否正确
		if ("root".equals(username)) {
			// 是：判断密码是否正确
			if ("1234".equals(password)) {
				// 是：登录成功，重定向到主页
				return "redirect:index.do";
			} else {
				// 否：密码错误
				request.setAttribute("errorMessage", "密码错误");
				return "error";
			}
		} else {
			// 否：用户名错误
			request.setAttribute("errorMessage", "用户名错误");
			return "error";
		}
	}

当然，这种做法依然是不推荐的，使用了HttpServletRequest作为参数后不便于执行单元测试。

2.2.3 【更不推荐】使用ModelAndView

使用ModelAndView作为处理请求的方法的返回值类型，在返回结果之前，调用ModelAndView对象的setViewName(String viewName)方法确定转发的视图名称，调用addObject(String name, Object value)方法封装需要转发的数据，然后返回结果即可：

	@RequestMapping("handle_login.do")
	public ModelAndView handleLogin(String username, String password) {
		// 创建返回值对象
		ModelAndView mav = new ModelAndView();
		
		// 判断用户名是否正确
		if ("root".equals(username)) {
			// 是：判断密码是否正确
			if ("1234".equals(password)) {
				// 是：登录成功，重定向到主页
				return null;
			} else {
				// 否：密码错误
				mav.addObject("errorMessage", "ModelAndView：密码错误");
				mav.setViewName("error");
				return mav;
			}
		} else {
			// 否：用户名错误
			mav.addObject("errorMessage", "ModelAndView：用户名错误");
			mav.setViewName("error");
			return mav;
		}
		
	}

因为对于初学SpringMVC的人来说，ModelAndView是一个新的、比较麻烦的数据类型，并且SpringMVC提供了更简单的操作方式，所以不推荐使用ModelAndView。

2.2.4 【推荐】使用ModelMap封装需要转发的数据

使用ModelMap的方式与使用HttpServletRequest几乎完全相同：

	@RequestMapping("handle_login.do")
	public String handleLogin(String username, String password,
			ModelMap modelMap) {
		// 日志
		System.out.println("UserController.handleLogin()");
		
		// 判断用户名是否正确
		if ("root".equals(username)) {
			// 是：判断密码是否正确
			if ("1234".equals(password)) {
				// 是：登录成功，重定向到主页
				return "redirect:index.do";
			} else {
				// 否：密码错误
				modelMap.addAttribute("errorMessage", "ModelMap：密码错误");
				return "error";
			}
		} else {
			// 否：用户名错误
			modelMap.addAttribute("errorMessage", "ModelMap：用户名错误");
			return "error";
		}
	}

相比HttpServletRequest而言，使用ModelMap更加易于实现单元测试，并且更加轻量级，所以，推荐使用这种方式来封装需要转发的数据。

2.2.5Model对象（重点）

将响应数据直接封装为model中。

@RequestMapping("doModel")
public String doModel(Model model) {
		model.addAttribute("data", "modal");
		return "response";
}

当我们返回具体view时，系统底层会自动将model对象存储到request作用域。

2.2.6Map对象（了解）

将响应数据封装到Map中（我建议假如使用map对数据进行封装，可直接采用model对象）

@RequestMapping("doMap01")
public String doMap01(Map<String,Object> map) {
	map.put("data", "map..");
	return "response";
}

喝醉的马儿

关注

5
点赞
踩
20

收藏

觉得还不错? 一键收藏
3
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

SpringMVC配置过程

SpringMVC 配置过程

文章目录

一、创建Maven WEB 项目并添加Spring MVC 依赖

二、添加Spring MVC配置文件并进行基本配置

三、Spring MVC拦截器编写及基本配置

四、Spring MVC 请求处理

1. 接收请求参数

1.1. 【不推荐】通过HttpServletRequest获取请求参数

1.2. 【推荐】将请求参数设计为处理请求的方法的参数

1.3. 【推荐】使用封装的类型接收较多的请求参数

2.响应处理

2.1 重定向

2.2 转发

2.2.1 执行转发

2.2.2 【不推荐】通过HttpServletRequest封装需要转发的数据

2.2.3 【更不推荐】使用ModelAndView

2.2.4 【推荐】使用ModelMap封装需要转发的数据

2.2.5Model对象 （重点）

2.2.6Map对象（了解）

2.2.5Model对象（重点）