第一个demo----配置式SpringMVC
01-primary:配置式的springmvc项目：
配置式：在springmvc的配置文件中，使用<bean>创建控制器（处理器）对象
步骤：
1.新建 web project
2.导入jar:
1)spring的核心jar:spring-beans.jar,spring-core.jar,spring-context.jar,spring-expression.jar
2)spring-aop.jar
3)web相关的jar:spring-web.jar
4)springmvc的实现jar:spring-webmvc.jar
5)日志：commons-logging.jar
3.重点：修改web.xml ， 注册springmvc的核心对象：中央调度器DispatherServlet
1) 中央调度器DispatherServlet是一个Servlet
2) 中央调度器的作用：1）接收用户的请求；2）响应处理结果。
3) 中央调度器也叫做前端控制器(front controller)
4.新建jsp，发起一个请求。
5.新建控制器对象，在配置式的方式中需要实现接口Controller 。
控制器对象是处理用户请求的。也称为后端控制器（back controller）
6.新建jsp，显示请求的处理结果
7.定义springmvc的配置文件
1）使用<bean>声明控制器（处理器）对象，让他处理某个请求
2）声明视图解析器，处理视图
8.修改控制器，使用逻辑视图名称
==========================================================================
配置式开发中的映射器和适配器
1.处理器映射器：
org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping
org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping
使用的是 BeanNameUrlHandlerMapping
2.处理器的适配器
org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter
org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter
org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter
使用的是 SimpleControllerHandlerAdapter ， 处理Controller接口的
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
index.jsp <br><br>
<a href="some.do">发起some.do的请求</a>
</body>
</html>
1>web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
<display-name>01-primary</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
<!-- 注册springmvc的核心对象DispatherServlet(中央调度器) -->
<!--
/WEB-INF/springmvc-servlet.xml
/WEB-INF/myweb-servlet.xml
DispatcherServlet在创建对象的时候，在init()方法中会创建springmvc的容器对象
WebApplicationContext, 创建容器的时候会读取配置文件， 创建配置文件中的所有bean对象。
默认读取的配置文件的位置是 /WEB-INF ,默认的文件名称是 <servlet-name>-servlet.xml
-->
<servlet>
<servlet-name>myweb</servlet-name>
<!-- springmvc.jar -->
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 自定义springmvc配置文件的位置和名称 -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!-- 在服务器启动的时候，创建对象 -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>myweb</servlet-name>
<!--
url-pattern是把请求交给某个Servlet处理， 我们现在要做的是把用户的请求交给SpringMVC框架中的核心对象
中央调度器， 交给中央调度器的处理的请求才能使用springmvc框架。
中央调度器是springmvc框架的入口
## url-pattern的配置方式: 1.扩展名方式： *.xxxx ； xxxx是自定义的扩展名，例如 *.do , *.action, *.mvc的等等。不能使用 *.jsp
http://localhost:8080/myweb/some.do
http://localhost:8080/myweb/user/addUser.do
2.使用斜杠"/"
-->
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>
2>springmvc.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:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
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
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 声明处理器对象， 让他处理请求
class:处理器的全限定类名
id:指定请求的uri(请求的地址)，需要以"/"开头。
"/"只是表示当前对象是能处理用户请求的， 可以区分是普通bean还是处理器对象
-->
<bean id="/some.do" class="com.bjpowernode.controllers.MyController"></bean>
<!-- 声明视图解析器对象：框架提供的类， 处理视图的。
实现ViewResolver接口的类叫做视图解析器
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 指定前缀：表示视图文件的目录 -->
<property name="prefix" value="/WEB-INF/jsp/" />
<!-- 指定后缀：表示视图文件的扩展名 -->
<property name="suffix" value=".jsp" />
</bean>
</beans>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
/WEB-INF/jsp/other.jsp <br>
msg: ${msg }
</body>
</html>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
/WEB-INF/jsp/show.jsp <br>
msg: ${msg }
</body>
</html>
package com.bjpowernode.controllers;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
/**
* 实现Controller接口的类叫做处理器类
* 处理器类能够处理用户的请求， 是自定义的类。
* 处理器类也叫做后端控制器（back controller）
*
*/
public class MyController implements Controller {
/**
* handleRequest()处理用户的请求，在方法中可以调用Service处理业务逻辑
* 返回值： ModelAndView
* Model:表示数据的，是一个Map的结构。(MVC中的Model)
* View:负责显示数据的，(MVC中的View)
*
*/
@Override
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
// doGet, doPost
ModelAndView mv = new ModelAndView();
//调用Service层处理请求，把处理结果显示给用户
//把处理结果的数据存放到Model
//框架对数据的处理是：把数据放入到request作用域；等同于request.setAttribute("msg", "Hello SpringMVC");
mv.addObject("msg", "Hello SpringMVC Internal");
//指定视图， 在视图中显示Model中的数据
//对视图的处理是执行forward
//等同于request.getRequestDispatcher("/show.jsp").forward(request,response);
//mv.setViewName("/show.jsp");
//mv.setViewName("/WEB-INF/jsp/show.jsp");
//mv.setViewName("/WEB-INF/jsp/other.jsp");
//使用逻辑视图名称（文件名），配合视图解析器前缀 + 视图文件名 + 后缀 = 完整的视图路径
// /WEB-INF/jsp/ + show + .jsp = /WEB-INF/jsp/show.jsp
mv.setViewName("show");
return mv;
}
}
根据上面代码可得下图：
时序图：
分析：
springmvc执行流程：
***1.由中央调度器接收请求
2.中央调度器把请求交给了处理器映射器
处理器映射器：是一些类，他们需要实现HandlerMapping接口。
处理器映射器作用：根据请求的信息，找到处理此请求的处理器对象。
也就是根据some.do 找到MyController.把找到的
MyController对象保存到 “处理器执行链”的对象中。
3.中央调度器把“处理器执行链”的处理器对象（MyController）,
交给的处理器的适配器
处理器适配器：是一些类，需要实现HandlerAdapter接口。
处理器适配器作用：根据处理器对象找到对应的处理器适配器对象（根据你的电脑的型号找到适合电源）。
每个处理器接口都有一个适配器对象
4.中央调度器，根据找到的处理器适配器。
通过这个处理器适配器执行处理器方法（调用MyController的handlerRequest()方法），
处理器调用完成后，会得到ModelAndView(数据和视图)
5.中央调度器把处理后的ModelAndView交给了视图解析器
视图解析器：是一些类，需要实现ViewResovler接口
视图解析器作用：根据他的前缀，后缀，组成视图的完整路径， 并创建视图文件的对应视图对象
在框架中， 视图是用View接口表示的。***
对应源码属性配置文件，启动容器时候创建下面对象：
# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.
org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver
org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping
org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter
org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver
org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator
org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager
url-pattern:设置中央调度器的url-pattern为"/"
02-url-pattern:设置中央调度器的url-pattern为"/"
步骤：
1.新建 web project
2.导入jar:
1)spring的核心jar:spring-beans.jar,spring-core.jar,spring-context.jar,spring-expression.jar
2)spring-aop.jar
3)web相关的jar:spring-web.jar
4)springmvc的实现jar:spring-webmvc.jar
5)日志：commons-logging.jar
3.重点：修改web.xml ， 注册springmvc的核心对象：中央调度器DispatherServlet
1) 中央调度器DispatherServlet是一个Servlet
2) 中央调度器的作用：1）接收用户的请求；2）响应处理结果。
3) 中央调度器也叫做前端控制器(front controller)
4.新建jsp，发起一个请求。
5.新建控制器对象，在配置式的方式中需要实现接口Controller 。
控制器对象是处理用户请求的。也称为后端控制器（back controller）
6.新建jsp，显示请求的处理结果
7.定义springmvc的配置文件
1）使用<bean>声明控制器（处理器）对象，让他处理某个请求
2）声明视图解析器，处理视图
8.修改控制器，使用逻辑视图名称
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
<display-name>01-primary</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
<!-- 注册springmvc的核心对象DispatherServlet(中央调度器) -->
<!--
/WEB-INF/springmvc-servlet.xml
/WEB-INF/myweb-servlet.xml
DispatcherServlet在创建对象的时候，在init()方法中会创建springmvc的容器对象
WebApplicationContext, 创建容器的时候会读取配置文件， 创建配置文件中的所有bean对象。
默认读取的配置文件的位置是 /WEB-INF ,默认的文件名称是 <servlet-name>-servlet.xml
-->
<servlet>
<servlet-name>myweb</servlet-name>
<!-- springmvc.jar -->
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 自定义springmvc配置文件的位置和名称 -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!-- 在服务器启动的时候，创建对象 -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>myweb</servlet-name>
<!--
url-pattern是把请求交给某个Servlet处理， 我们现在要做的是把用户的请求交给SpringMVC框架中的核心对象
中央调度器， 交给中央调度器的处理的请求才能使用springmvc框架。
中央调度器是springmvc框架的入口
url-pattern的配置方式:
1.扩展名方式： *.xxxx ； xxxx是自定义的扩展名，例如 *.do , *.action, *.mvc的等等。不能使用 *.jsp
http://localhost:8080/myweb/some.do
http://localhost:8080/myweb/user/addUser.do
2.没使用之前是tomcat处理静态资源的，不是中央调度器；使用斜杠"/".导致的问题静态资源没有对应的处理器对象， 静态资源不能访问。 静态资源有 jpg,png, gif, css ,js, html
动态资源能正常访问。
-->
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
解决办法： 两种
方法1：
在sprignmvc.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:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
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
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 声明处理器对象， 让他处理请求
class:处理器的全限定类名
id:指定请求的uri(请求的地址)，需要以"/"开头。
"/"只是表示当前对象是能处理用户请求的， 可以区分是普通bean还是处理器对象
-->
<bean id="/some.do" class="com.bjpowernode.controllers.MyController"></bean>
<!-- 声明视图解析器对象：框架提供的类， 处理视图的。
实现ViewResolver接口的类叫做视图解析器
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 指定前缀：表示视图文件的目录 -->
<property name="prefix" value="/WEB-INF/jsp/" />
<!-- 指定后缀：表示视图文件的扩展名 -->
<property name="suffix" value=".jsp" />
</bean>
<!-- 处理静态资源，把静态资源的请求转给服务器的名字叫default的Servlet处理 -->
<mvc:default-servlet-handler/> <!-- 把请求转给default处理 -->
<!-- 当你的服务器没有default这个Servlet,需要指定处理静态资源的Servlet名称
default-servlet-name:处理静态资源的Servlet名称
例如WebLogic服务器使用 FileServlet
-->
<!-- <mvc:default-servlet-handler default-servlet-name="FileServlet"/> -->
</beans>
web.xml中也可以添加下面配置
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.css</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.gif</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.jpg</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.js</url-pattern>
</servlet-mapping>
方法2：
修改springmvc.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:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
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
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 声明处理器对象， 让他处理请求
class:处理器的全限定类名
id:指定请求的uri(请求的地址)，需要以"/"开头。
"/"只是表示当前对象是能处理用户请求的， 可以区分是普通bean还是处理器对象
-->
<bean id="/some.do" class="com.bjpowernode.controllers.MyController"></bean>
<!-- 声明视图解析器对象：框架提供的类， 处理视图的。
实现ViewResolver接口的类叫做视图解析器
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 指定前缀：表示视图文件的目录 -->
<property name="prefix" value="/WEB-INF/jsp/" />
<!-- 指定后缀：表示视图文件的扩展名 -->
<property name="suffix" value=".jsp" />
</bean>
<!-- 处理静态资源的访问
location:静态资源在web项目中目录位置，不能是/WEB-INF
mapping:访问静态资源的uri地址：
1. * ：表示任意的文件
2. **：表示任意的目录和文件
-->
<mvc:resources location="/htmls/" mapping="/htmls/**" />
<mvc:resources location="/images/" mapping="/images/**" />
<!-- 作业：只配置 <mvc:resources>一句话， 处理多种静态资源的访问 -->
</beans>
05-primay-annotation：注解的springmvc项目
注解式的springmvc项目是指使用注解@Controller创建处理器对象。
步骤：
1.新建 web project
2.导入jar:
1)spring的核心jar:spring-beans.jar,spring-core.jar,spring-context.jar,spring-expression.jar
2)spring-aop.jar
3)web相关的jar:spring-web.jar
4)springmvc的实现jar:spring-webmvc.jar
5)日志：commons-logging.jar
3.重点：修改web.xml ， 注册springmvc的核心对象：中央调度器DispatherServlet
1) 中央调度器DispatherServlet是一个Servlet
2) 中央调度器的作用：1）接收用户的请求；2）响应处理结果。
3) 中央调度器也叫做前端控制器(front controller)
4.新建jsp，发起一个请求。
5.新建控制器对象，是一个普通的java类
1）在类的上面加入注解@Controller，创建处理器对象
2）在类中自定义方法，处理某个请求， 在方法的上面加入@RequestMapping.
6.新建jsp，显示请求的处理结果
7.定义springmvc的配置文件
1）声明组件扫描器，指定@Controller注解所在的包名
2）声明视图解析器，处理视图
8.修改控制器，使用逻辑视图名称
springmvc.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:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
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
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 声明组件扫描器，指定@Controller注解的包名 -->
<context:component-scan base-package="com.bjpowernode.controllers" />
<!-- 声明视图解析器对象：框架提供的类， 处理视图的。
实现ViewResolver接口的类叫做视图解析器
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 指定前缀：表示视图文件的目录 -->
<property name="prefix" value="/WEB-INF/jsp/" />
<!-- 指定后缀：表示视图文件的扩展名 -->
<property name="suffix" value=".jsp" />
</bean>
</beans>
MyController.java
package com.bjpowernode.controllers;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
/**
* @Contorller:创建处理器对象，默认是单例对象
* 位置：在类的上面
*
*/
@Controller
public class MyController {
//自定义方法处理请求。
/**
* @RequestMapping:请求映射， 把请求指定给某个方法处理。
* 使用@RequestMapping修饰的方法叫做处理器方法，处理器方法是处理用户请求的。
* 属性：1）value , 表示请求的uri(地址，资源)。 uri的值必须是唯一的。
* 可以"/"开头，也可以不加"/"
* 位置：
* 1.在方法的上面，常用的。
* 2.在类的上面。
*/
@RequestMapping(value={"some.do","first.do"})
public ModelAndView doSome(){
//处理some.do的请求， doSome就相当于 Servlet的doGet
ModelAndView mv = new ModelAndView();
//调用Service处理业务，将处理结果显示到视图
mv.addObject("msg", "Hello SpringMVC Annotation");
mv.addObject("fun", "doSome");
//指定视图
mv.setViewName("show");
return mv;
}
@RequestMapping(value={"other.do","second.do"})
public ModelAndView doOther(){
//处理some.do的请求， doSome就相当于 Servlet的doGet
ModelAndView mv = new ModelAndView();
//调用Service处理业务，将处理结果显示到视图
mv.addObject("msg", "Hello SpringMVC Annotation");
mv.addObject("fun", "doOther");
//指定视图
mv.setViewName("show");
return mv;
}
}
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
<display-name>01-primary</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
<!-- 注册springmvc的核心对象DispatherServlet(中央调度器) -->
<!--
/WEB-INF/springmvc-servlet.xml
/WEB-INF/myweb-servlet.xml
DispatcherServlet在创建对象的时候，在init()方法中会创建springmvc的容器对象
WebApplicationContext, 创建容器的时候会读取配置文件， 创建配置文件中的所有bean对象。
默认读取的配置文件的位置是 /WEB-INF ,默认的文件名称是 <servlet-name>-servlet.xml
-->
<servlet>
<servlet-name>myweb</servlet-name>
<!-- springmvc.jar -->
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 自定义springmvc配置文件的位置和名称 -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!-- 在服务器启动的时候，创建对象 -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>myweb</servlet-name>
<!--
url-pattern是把请求交给某个Servlet处理， 我们现在要做的是把用户的请求交给SpringMVC框架中的核心对象
中央调度器， 交给中央调度器的处理的请求才能使用springmvc框架。
中央调度器是springmvc框架的入口
url-pattern的配置方式:
1.扩展名方式： *.xxxx ； xxxx是自定义的扩展名，例如 *.do , *.action, *.mvc的等等。不能使用 *.jsp
http://localhost:8080/myweb/some.do
http://localhost:8080/myweb/user/addUser.do
2.使用斜杠"/"
-->
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>
show.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
/WEB-INF/jsp/show.jsp 使用注解创建处理器对象 <br>
msg: ${msg } <br>
fun: <b>${fun }</b>
</body>
</html>
06-RequestMapping-modelName：@RequestMapping注解放到类的上面
06-RequestMapping-modelName：@RequestMapping注解放到类的上面
把它的value属性值叫做模块名称， 实际上是所有请求地址的公共部分
步骤：
1.新建 web project
2.导入jar:
1)spring的核心jar:spring-beans.jar,spring-core.jar,spring-context.jar,spring-expression.jar
2)spring-aop.jar
3)web相关的jar:spring-web.jar
4)springmvc的实现jar:spring-webmvc.jar
5)日志：commons-logging.jar
3.重点：修改web.xml ， 注册springmvc的核心对象：中央调度器DispatherServlet
1) 中央调度器DispatherServlet是一个Servlet
2) 中央调度器的作用：1）接收用户的请求；2）响应处理结果。
3) 中央调度器也叫做前端控制器(front controller)
4.新建jsp，发起一个请求。
5.新建控制器对象，是一个普通的java类
1）在类的上面加入注解@Controller，创建处理器对象
2）在类中自定义方法，处理某个请求， 在方法的上面加入@RequestMapping.
6.新建jsp，显示请求的处理结果
7.定义springmvc的配置文件
1）声明组件扫描器，指定@Controller注解所在的包名
2）声明视图解析器，处理视图
8.修改控制器，使用逻辑视图名称
@RequestMapping:请求映射 value:在类的上面使用，value属性表示请求地址的公共部分， 我们叫做模块名称
package com.bjpowernode.controllers;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
/**
* @Contorller:创建处理器对象，默认是单例对象
* 位置：在类的上面
*
* @RequestMapping:请求映射
* value:在类的上面使用，value表示请求地址的公共部分， 我们叫做模块名称
*
*/
@Controller
@RequestMapping("test")
public class MyController {
//自定义方法处理请求。
/**
* @RequestMapping:请求映射， 把请求指定给某个方法处理。
* 使用@RequestMapping修饰的方法叫做处理器方法，处理器方法是处理用户请求的。
* 属性：1）value , 表示请求的uri(地址，资源)。 uri的值必须是唯一的。
* 可以"/"开头，也可以不加"/"
* 位置：
* 1.在方法的上面，常用的。
* 2.在类的上面。
*/
@RequestMapping(value={"some.do","first.do"})
public ModelAndView doSome(){
//处理some.do的请求， doSome就相当于 Servlet的doGet
ModelAndView mv = new ModelAndView();
//调用Service处理业务，将处理结果显示到视图
mv.addObject("msg", "Hello SpringMVC Annotation");
mv.addObject("fun", "doSome");
//指定视图
mv.setViewName("show");
return mv;
}
@RequestMapping(value={"other.do","second.do"})
public ModelAndView doOther(){
//处理some.do的请求， doSome就相当于 Servlet的doGet
ModelAndView mv = new ModelAndView();
//调用Service处理业务，将处理结果显示到视图
mv.addObject("msg", "Hello SpringMVC Annotation");
mv.addObject("fun", "doOther");
//指定视图
mv.setViewName("show");
return mv;
}
}
RequestMapping的 method属性
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
index.jsp <br><br>
<a href="test/other.do">发起get方法some.do的请求</a>
<br>
<br>
<form action="test/first.do" method="post">
<input type="submit" value="post请求">
</form>
</body>
</html>
package com.bjpowernode.controllers;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
/**
* @Contorller:创建处理器对象，默认是单例对象
* 位置：在类的上面
*
* @RequestMapping:请求映射
* value:在类的上面使用，value表示请求地址的公共部分， 我们叫做模块名称
*
*/
@Controller
@RequestMapping("test")
public class MyController {
//自定义方法处理请求。
/**
* @RequestMapping:请求映射， 把请求指定给某个方法处理。
* 使用@RequestMapping修饰的方法叫做处理器方法，处理器方法是处理用户请求的。
* 属性：1）value , 表示请求的uri(地址，资源)。 uri的值必须是唯一的。
* 可以"/"开头，也可以不加"/"
* 2）method, 它的值是RequestMethod[] ,表示请求的方式，
使用RequestMethod类的枚举值，表示请求方式
* 位置：
* 1.在方法的上面，常用的。
* 2.在类的上面。
*/
//指定some.do只能使用get请求方式。
@RequestMapping(value="some.do",method = RequestMethod.GET)
public ModelAndView doSome(){
//处理some.do的请求， doSome就相当于 Servlet的doGet
ModelAndView mv = new ModelAndView();
//调用Service处理业务，将处理结果显示到视图
mv.addObject("msg", "Hello SpringMVC Annotation");
mv.addObject("fun", "doSome");
//指定视图
mv.setViewName("show");
return mv;
}
//指定other.do只能使用post请求方式
@RequestMapping(value="other.do",method = RequestMethod.POST)
public ModelAndView doOther(){
//处理some.do的请求， doSome就相当于 Servlet的doGet
ModelAndView mv = new ModelAndView();
//调用Service处理业务，将处理结果显示到视图
mv.addObject("msg", "Hello SpringMVC Annotation");
mv.addObject("fun", "doOther");
//指定视图
mv.setViewName("show");
return mv;
}
//first.do不指定method属性， 表示请求方式没有限制。
@RequestMapping(value="first.do")
public ModelAndView doFirst(){
//处理some.do的请求， doSome就相当于 Servlet的doGet
ModelAndView mv = new ModelAndView();
//调用Service处理业务，将处理结果显示到视图
mv.addObject("msg", "Hello SpringMVC Annotation");
mv.addObject("fun", "doFirst");
//指定视图
mv.setViewName("show");
return mv;
}
}
params属性
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
index.jsp <br><br>
<a href="test/other.do">发起get方法some.do的请求</a>
<br>
<br>
<form action="test/first.do" method="post">
<input type="submit" value="post请求">
</form>
</body>
</html>
package com.bjpowernode.controllers;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import javax.servlet.http.HttpSession;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
/**
* @Contorller:创建处理器对象，默认是单例对象
* 位置：在类的上面
*
* @RequestMapping:请求映射
* value:在类的上面使用，value表示请求地址的公共部分， 我们叫做模块名称
*
*/
@Controller
@RequestMapping("test")
public class MyController {
//自定义方法处理请求。
/**
* @RequestMapping:请求映射， 把请求指定给某个方法处理。
* 使用@RequestMapping修饰的方法叫做处理器方法，处理器方法是处理用户请求的。
* 属性：1）value , 表示请求的uri(地址，资源)。 uri的值必须是唯一的。
* 可以"/"开头，也可以不加"/"
* 2）method, 它的值是RequestMethod[] ,表示请求的方式，
使用RequestMethod类的枚举值，表示请求方式
3）params,表示请求中的参数信息。params的值是String[]
* 位置：
* 1.在方法的上面，常用的。
* 2.在类的上面。
*/
//指定some.do的请求中必须有 name ,age两个参数，可以有更多的参数
@RequestMapping(value="some.do",params={"name","age"})
public ModelAndView doSome(){
//处理some.do的请求， doSome就相当于 Servlet的doGet
ModelAndView mv = new ModelAndView();
//调用Service处理业务，将处理结果显示到视图
mv.addObject("msg", "Hello SpringMVC Annotation");
mv.addObject("fun", "doSome");
//指定视图
mv.setViewName("show");
return mv;
}
//指定other.do请求中，必须有age参数，不能有name参数，可以有其他参数
@RequestMapping(value="other.do",params={"!name","age"})
public ModelAndView doOther(){
//处理some.do的请求， doSome就相当于 Servlet的doGet
ModelAndView mv = new ModelAndView();
//调用Service处理业务，将处理结果显示到视图
mv.addObject("msg", "Hello SpringMVC Annotation");
mv.addObject("fun", "doOther");
//指定视图
mv.setViewName("show");
return mv;
}
//first.do请求中必须有name ,name的值必须是zs ，请求中必须有age,值必须是23;可以有其他参数
@RequestMapping(value="first.do",params={"name=zs","age=23"})
public ModelAndView doFirst(HttpServletRequest request,HttpServletResponse response, HttpSession session){
//使用request获取请求的参数值
String name = request.getParameter("name");
String sex = request.getParameter("sex");
System.out.println("name:"+name+"|sex:"+sex);
//处理some.do的请求， doSome就相当于 Servlet的doGet
ModelAndView mv = new ModelAndView();
//调用Service处理业务，将处理结果显示到视图
mv.addObject("msg", "Hello SpringMVC Annotation");
mv.addObject("fun", "doFirst");
//指定视图
mv.setViewName("show");
return mv;
}
}
处理器方法的参数：
逐个接收参数：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
index.jsp <br><br>
<a href="test/other.do">发起get方法some.do的请求</a>
<br>
<br>
<form action="test/some.do" method="post">
姓名：<input type="text" name="name" /><br><br>
年龄：<input type="text" name="age" /> <br><br>
<input type="submit" value="post请求">
</form>
</body>
</html>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
/WEB-INF/jsp/show.jsp 使用注解创建处理器对象 <br>
myname: ${myname } <br>
myage: <b>${myage }</b>
</body>
</html>
package com.bjpowernode.controllers;
import javax.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
/**
* @Contorller:创建处理器对象，默认是单例对象
* 位置：在类的上面
*
* @RequestMapping:请求映射
* value:在类的上面使用，value表示请求地址的公共部分， 我们叫做模块名称
*
*/
@Controller
@RequestMapping("test")
public class MyController {
//自定义方法处理请求。
/**
* 使用逐个接收，接收请求中的参数：
* 要求请求中参数名和处理器方法的形参名一样
*
* 框架的处理方式：
* 1.使用request对象接收参数
* String strName = request.getParameter("name");
* String strAge = request.getParameter("age");
* 2.使用处理器适配器对象，调用处理器方法
*
* doSome(strName, Integer.parseInt(strAge) )
*
* 框架可以实现String - int , long ,float，double类型转换。
*/
@RequestMapping(value="some.do")
public ModelAndView doSome( Integer age,String name,HttpServletRequest request){
System.out.println("doSome参数name:"+name+"|age:"+age);
//处理some.do的请求， doSome就相当于 Servlet的doGet
ModelAndView mv = new ModelAndView();
//调用Service处理业务，将处理结果显示到视图
mv.addObject("myname", name);
mv.addObject("myage", age);
//指定视图
mv.setViewName("show");
return mv;
}
}
注意：
解决post请求中文乱码的问题
在web.xml中配置
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
<display-name>01-primary</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
<!-- 注册springmvc的核心对象DispatherServlet(中央调度器) -->
<!--
/WEB-INF/springmvc-servlet.xml
/WEB-INF/myweb-servlet.xml
DispatcherServlet在创建对象的时候，在init()方法中会创建springmvc的容器对象
WebApplicationContext, 创建容器的时候会读取配置文件， 创建配置文件中的所有bean对象。
默认读取的配置文件的位置是 /WEB-INF ,默认的文件名称是 <servlet-name>-servlet.xml
-->
<servlet>
<servlet-name>myweb</servlet-name>
<!-- springmvc.jar -->
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 自定义springmvc配置文件的位置和名称 -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!-- 在服务器启动的时候，创建对象 -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>myweb</servlet-name>
<!--
url-pattern是把请求交给某个Servlet处理， 我们现在要做的是把用户的请求交给SpringMVC框架中的核心对象
中央调度器， 交给中央调度器的处理的请求才能使用springmvc框架。
中央调度器是springmvc框架的入口
url-pattern的配置方式:
1.扩展名方式： *.xxxx ； xxxx是自定义的扩展名，例如 *.do , *.action, *.mvc的等等。不能使用 *.jsp
http://localhost:8080/myweb/some.do
http://localhost:8080/myweb/user/addUser.do
2.使用斜杠"/"
-->
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<!-- 注册字符集过滤器，解决post请求中乱码的问题 -->
<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<!-- 指定当前项目使用的字符编码 -->
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
<!-- 强制请求(HttpServletRequest)对象，使用encoding的字符编码 -->
<init-param>
<param-name>forceRequestEncoding</param-name>
<param-value>true</param-value>
</init-param>
<!-- 强制应答(HttpServletResponse)对象，使用encoding的字符编码 -->
<init-param>
<param-name>forceResponseEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
当请求参数名和处理器形参名不一致会使用矫正注解？
使用对象来接收参数
对象定义无参数构造方法和set/get方法
使用处理器方法的返回值表示返回的结果
2>返回String
不能和视图解析器同时使用
##3. 返回 void
例子：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<script type="text/javascript" src="js/jquery-1.11.1-min.js"></script>
<script type="text/javascript">
$(function(){
$("button").click(function(){
$.ajax({
url:"test/myajax.do",
data:{
"name":"zhangsan",
"age":23
},
type:"post",
dataType:"json",
success:function(resp){
alert(resp)
}
})
})
})
</script>
</head>
<body>
index.jsp <br><br>
<a href="test/other.do">发起get方法some.do的请求</a>
<br>
<br>
<button>发起ajax请求</button>
</body>
</html>
package com.bjpowernode.controllers;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import com.bjpowernode.beans.Student;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
/**
* @Contorller:创建处理器对象，默认是单例对象
* 位置：在类的上面
*
* @RequestMapping:请求映射
* value:在类的上面使用，value表示请求地址的公共部分， 我们叫做模块名称
*
*/
@Controller
@RequestMapping("test")
public class MyController {
//自定义方法处理请求。
/**
* 处理器方法返回void:
* void:不表示数据，也表示视图。 用来响应ajax
* 通过使用HttpServletResponse对象的输出流，将数据输出给浏览器。
* @throws IOException
*/
@RequestMapping("myajax.do")
public void doAjax(String name,Integer age,HttpServletResponse response) throws IOException{
System.out.println("接收参数 name:"+name+"|age:"+age);
//调用Service处理请求，将处理结果输出给浏览器。
Student student = new Student();
student.setAge(age);
student.setName(name);
//将Student转为json， 使用Jackson中的ObjectMapper
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(student);
System.out.println("json:"+json);
//输出json到浏览器
response.setCharacterEncoding("utf-8");
PrintWriter pw = response.getWriter();
pw.println(json);
pw.flush();
pw.close();
}
}
14-returnObject-String:处理器方法返回Object(对象)，对象表示数据，和视图无关，可以相应ajax请求。
框架处理器方法返回对象，需要做的工作：
1.在springmvc的配置文件中加入 mvc:annotation 注解驱动
创建HttpMessageConveter接口的7个实现类对象，
7个类中有一个MappingJackson2HttpMessageConveter类，可以实现java对象到json的处理
2.加入操作json的工具库， springmvc框架默认使用的是Jackson工具库。
注意的是springmvc4.3版本中要求Jackson的版本是2.6或以上的。
3.在处理器方法的上面，加入@ResponseBody。
@ResponseBody的作用是把2中的数据输出到应答体（通过HttpServletResponse输出）
HttpMessageConveter接口的作用：
1.可以把请求中的数据转为java对象的。
使用接口中的 canRead() ,read()
2.可以把处理器方法的返回值转为某种格式的数据，交给输出流。
使用接口的在的canWrite() ,write()
步骤：
1.新建 web project
2.导入jar:
1)spring的核心jar:spring-beans.jar,spring-core.jar,spring-context.jar,spring-expression.jar
2)spring-aop.jar
3)web相关的jar:spring-web.jar
4)springmvc的实现jar:spring-webmvc.jar
5)日志：commons-logging.jar
6)Jackson的工具库：三个jar
3.重点：修改web.xml ， 注册springmvc的核心对象：中央调度器DispatherServlet
- 中央调度器DispatherServlet是一个Servlet
- 中央调度器的作用：1）接收用户的请求；2）响应处理结果。
- 中央调度器也叫做前端控制器(front controller)
4.新建jsp，发起一个请求。
定义请求参数 name ,age (使用整数表示年龄)
加入JQuery的库文件
5.新建控制器对象，是一个普通的java类
1）在类的上面加入注解@Controller，创建处理器对象
2）在类中自定义方法，处理某个请求， 在方法的上面加入@RequestMapping.
方法定义形参 name ,age
6.新建jsp，显示请求的处理结果
7.定义springmvc的配置文件
1）声明组件扫描器，指定@Controller注解所在的包名
2）声明视图解析器，处理视图
8.修改控制器，使用逻辑视图名称
<?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:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
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
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 声明组件扫描器，指定@Controller注解的包名 -->
<context:component-scan base-package="com.bjpowernode.controllers" />
<!-- 声明视图解析器对象：框架提供的类， 处理视图的。
实现ViewResolver接口的类叫做视图解析器
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 指定前缀：表示视图文件的目录 -->
<property name="prefix" value="/WEB-INF/jsp/" />
<!-- 指定后缀：表示视图文件的扩展名 -->
<property name="suffix" value=".jsp" />
</bean>
<!-- 声明注解驱动：
创建HttpMessageConverter接口的7个实现类对象
-->
<mvc:annotation-driven />
</beans>
package com.bjpowernode.controllers;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import com.bjpowernode.beans.Student;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
/**
* @Contorller:创建处理器对象，默认是单例对象
* 位置：在类的上面
*
* @RequestMapping:请求映射
* value:在类的上面使用，value表示请求地址的公共部分， 我们叫做模块名称
*
*/
@Controller
@RequestMapping("test")
public class MyController {
//自定义方法处理请求。
/**
* 处理器方法返回Object-String
* String表示数据，不是视图
*
* 区分String是数据还是视图：看处理器方法上面是否有@ResponseBody注解
* 1）如果有@ResponseBody，String表示数据
* 2）没有@ResponseBody，String表示视图
*
* @ResponseBody:将数据输出到浏览器（输出到应答体中）
* 位置：在处理器方法的上面
*
* 框架的处理逻辑：
* 1.框架根据处理器方法的返回值的数据类型， 寻找HttpMessageConverter接口的实现类对象。
* String - StringHttpMessageConverter.
* 2.框架调用 HttpMessageConverter接口的实现类对象，处理返回值，把String转为
* text/plain;charset=ISO-8859-1； 文本数据，使用ISO-8859-1编码。
* 3.把2步骤中的结果数据，通过使用HttpServletResponse的输出流对象，输出到浏览器。
* 由@ResponseBody注解完成的。
*
* 解决中文的输出， 使用utf-8的编码
* 使用@RequestMapping的属性produces，指定输出数据的格式和编码
*
*/
@ResponseBody
@RequestMapping(value="myajax.do",produces="text/html;charset=utf-8")
public String doAjax(String name,Integer age) {
System.out.println("接收参数 name:"+name+"|age:"+age);
return "Hello SpringMVC HttpMessageConverter 中文数据";
}
}
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<script type="text/javascript" src="js/jquery-1.11.1-min.js"></script>
<script type="text/javascript">
$(function(){
$("button").click(function(){
$.ajax({
url:"test/myajax.do",
data:{
"name":"zhangsan",
"age":23
},
type:"post",
//dataType:"json",//返回字符串的时候不要加这行。
success:function(resp){
alert(resp)
}
})
})
})
</script>
</head>
<body>
index.jsp <br><br>
<a href="test/other.do">发起get方法some.do的请求</a>
<br>
<br>
<button>发起ajax请求</button>
</body>
</html>
返回值是对象：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<script type="text/javascript" src="js/jquery-1.11.1-min.js"></script>
<script type="text/javascript">
$(function(){
$("button").click(function(){
$.ajax({
url:"test/myajax.do",
data:{
"name":"zhangsan",
"age":23
},
type:"post",
//dataType:"json",
success:function(resp){
alert(resp.name+" | "+resp.age)
}
})
})
})
</script>
</head>
<body>
index.jsp <br><br>
<a href="test/other.do">发起get方法some.do的请求</a>
<br>
<br>
<button>发起ajax请求</button>
</body>
</html>
package com.bjpowernode.controllers;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import com.bjpowernode.beans.Student;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
/**
* @Contorller:创建处理器对象，默认是单例对象
* 位置：在类的上面
*
* @RequestMapping:请求映射
* value:在类的上面使用，value表示请求地址的公共部分， 我们叫做模块名称
*
*/
@Controller
@RequestMapping("test")
public class MyController {
//自定义方法处理请求。
/**
* 处理器方法返回Object-Student
*
* 框架的处理逻辑：
* 1.框架根据处理器方法的返回值的数据类型， 寻找HttpMessageConverter接口的实现类对象。
* Student - MappingJackson2HttpMessageConverter.
* 2.框架调用 HttpMessageConverter接口的实现类对象，处理返回值，把Student转为json
* application/json;charset=UTF-8；使用UTF-8编码。 Student -- JsonObject
* 3.把2步骤中的结果数据，通过使用HttpServletResponse的输出流对象，输出到浏览器。
* 由@ResponseBody注解完成的。
*
*
*/
@ResponseBody
@RequestMapping(value="myajax.do")
public Student doAjax(String name,Integer age) {
System.out.println("接收参数 name:"+name+"|age:"+age);
//业务层的处理结果
Student student = new Student();
student.setAge(age);
student.setName("新同学姓名："+name);
return student;
}
}
返回值是List
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<script type="text/javascript" src="js/jquery-1.11.1-min.js"></script>
<script type="text/javascript">
$(function(){
$("button").click(function(){
$.ajax({
url:"test/myajax.do",
data:{
"name":"zhangsan",
"age":23
},
type:"post",
//dataType:"json",
success:function(resp){
$.each(resp,function(i,n){
alert(n.name+" | "+n.age)
})
}
})
})
})
</script>
</head>
<body>
index.jsp <br><br>
<a href="test/other.do">发起get方法some.do的请求</a>
<br>
<br>
<button>发起ajax请求</button>
</body>
</html>
package com.bjpowernode.controllers;
import java.util.ArrayList;
import java.util.List;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.bjpowernode.beans.Student;
/**
* @Contorller:创建处理器对象，默认是单例对象
* 位置：在类的上面
*
* @RequestMapping:请求映射
* value:在类的上面使用，value表示请求地址的公共部分， 我们叫做模块名称
*
*/
@Controller
@RequestMapping("test")
public class MyController {
//自定义方法处理请求。
/**
* 处理器方法返回Object-List<Student>
*
* 框架的处理逻辑：
* 1.框架根据处理器方法的返回值的数据类型， 寻找HttpMessageConverter接口的实现类对象。
* Student - MappingJackson2HttpMessageConverter.
* 2.框架调用 HttpMessageConverter接口的实现类对象，处理返回值，把Student转为 json数组
* application/json;charset=UTF-8；使用UTF-8编码。 Student -- JsonArray
* 3.把2步骤中的结果数据，通过使用HttpServletResponse的输出流对象，输出到浏览器。
* 由@ResponseBody注解完成的。
*
*
*/
@ResponseBody
@RequestMapping(value="myajax.do")
public List<Student> doAjax(String name,Integer age) {
System.out.println("接收参数 name:"+name+"|age:"+age);
//业务层的处理结果
Student student = new Student();
student.setAge(22);
student.setName("李四");
Student student1 = new Student();
student1.setAge(23);
student1.setName("张三");
List<Student> students = new ArrayList<>();
students.add(student1);//张三
students.add(student);//李四
return students;
}
}
返回值是ModelAndView来实现转发操作
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
/WEB-INF/jsp/show.jsp 使用注解创建处理器对象 <br>
myname: ${myname } <br>
myage: <b>${myage }</b>
</body>
</html>
package com.bjpowernode.controllers;
import javax.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
/**
* @Contorller:创建处理器对象，默认是单例对象
* 位置：在类的上面
*
* @RequestMapping:请求映射
* value:在类的上面使用，value表示请求地址的公共部分， 我们叫做模块名称
*
*/
@Controller
@RequestMapping("test")
public class MyController {
//自定义方法处理请求。
/**
* 处理器方法返回ModelAndView实现转发到视图
* 语法格式： setViewName("forward:视图的完整路径")
*
* forward:使用特点是不和视图解析器一同工作，就当项目中没有视图解析器的。
* 优势：当项目中大多数的视图使用视图解析器，有某些视图不在视图的目录中，可以使用forward指定到其他位置
*
*/
@RequestMapping(value="some.do")
public ModelAndView doSome( Integer age,String name,HttpServletRequest request){
System.out.println("doSome参数name:"+name+"|age:"+age);
//处理some.do的请求， doSome就相当于 Servlet的doGet
ModelAndView mv = new ModelAndView();
//调用Service处理业务，将处理结果显示到视图
mv.addObject("myname", name);
mv.addObject("myage", age);
//指定forward到视图
//setViewName("forward:视图的完整路径")
mv.setViewName("forward:/WEB-INF/jsp/show.jsp");
return mv;
}
返回值是String来实现转发操作
/**
* 处理器方法返回值是String , 使用forward转发到视图
*/
@RequestMapping("other.do")
public String doOther(){
//转发到视图页面，语法 forward:视图的完整路径
return "forward:/WEB-INF/jsp/show.jsp";
}
转发到其他的处理器， 由其他处理器方法继续处理请求。
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
index.jsp <br><br>
<form action="test/dispather.do" method="post">
姓名：<input type="text" name="name" /><br><br>
年龄：<input type="text" name="age" /> <br><br>
<input type="submit" value="post请求">
</form>
</body>
</html>
/**
* 转发到其他的处理器， 由其他处理器方法继续处理请求。
* 语法： forward:xxx.do
*/
@RequestMapping("dispather.do")
public ModelAndView doDispather(String name,Integer age){
ModelAndView mv = new ModelAndView();
//request
mv.addObject("myname", name);
mv.addObject("myage", age);
//转发到其他的处理器
mv.setViewName("forward:process.do");
return mv;
}
//处理器方法，处理转发过来的请求
@RequestMapping("process.do")
public String doProcess(){
System.out.println("==========doProcess==============");
//视图的逻辑名称 ， forward到视图页面
return "show";
}
}
注意：request作用域与param作用域的内容获取（复习一下）
今天演示EL表达式的时候发现自己jsp的基础实在是薄弱，在这个很简单的问题上迷惑了很久。
首先在看遇到的问题：
在浏览器地址输入，表示传入一个参数test，值为123
http://localhost:8888/Test/index.jsp?test=123
在index.jsp中尝试使用EL表达式取出，代码如下：
<body>
${test}
</body>
发现毫无结果，再使用requestScope尝试取出：
<body>
${requestScope.test}
</body>
发现还是毫无结果，感到非常诧异，遂干脆使用java脚本尝试取出。
<body>
<%request.getAttribute("test"); %>
</body>
依然无解。
之后发现，若使用已下代码向request作用域赋值，则用上面代码可以取出
<%
request.setAttribute("test", "123");
%>
查询资料后发现，使用以下代码可以取出之前的请求参数：
EL:
<body>
${param.test}
</body>
JAVA脚本：
<body>
<%=request.getParameter("test") %>
</body>
结论就是：${param.name} 等价于 request.getParamter("name")，这两种方法一般用于服务器从页面或者客户端获取的内容。
${requestScope.name} 等价于 request.getAttribute("name")，一般是从服务器传递结果到页面，在页面中取出服务器保存的值
18-redirect：实现重定向操作。
框架使用"redirect:" 表示重定向， 表示response.sendRedirect()
重定向的目的地：
1.重定向到视图页面（xxx.jsp）
2.重定向到其他的处理器，由其他处理器继续处理请求。
步骤：
1.新建 web project
2.导入jar:
1)spring的核心jar:spring-beans.jar,spring-core.jar,spring-context.jar,spring-expression.jar
2)spring-aop.jar
3)web相关的jar:spring-web.jar
4)springmvc的实现jar:spring-webmvc.jar
5)日志：commons-logging.jar
3.重点：修改web.xml ， 注册springmvc的核心对象：中央调度器DispatherServlet
1) 中央调度器DispatherServlet是一个Servlet
2) 中央调度器的作用：1）接收用户的请求；2）响应处理结果。
3) 中央调度器也叫做前端控制器(front controller)
4.新建jsp，发起一个请求。
定义请求参数 name ,age (使用整数表示年龄)
5.新建控制器对象，是一个普通的java类
1）在类的上面加入注解@Controller，创建处理器对象
2）在类中自定义方法，处理某个请求， 在方法的上面加入@RequestMapping.
方法定义形参 name ,age
6.新建jsp，显示请求的处理结果
7.定义springmvc的配置文件
1）声明组件扫描器，指定@Controller注解所在的包名
2）声明视图解析器，处理视图
8.修改控制器，使用逻辑视图名称
package com.bjpowernode.controllers;
import javax.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import com.bjpowernode.beans.Student;
/**
* @Contorller:创建处理器对象，默认是单例对象
* 位置：在类的上面
*
* @RequestMapping:请求映射
* value:在类的上面使用，value表示请求地址的公共部分， 我们叫做模块名称
*
*/
@Controller
@RequestMapping("test")
public class MyController {
//自定义方法处理请求。
/**
## * 处理器方法返回ModelAndView实现重定向到视图
* 语法格式： setViewName("redirect:视图的完整路径")
*
* redirect:使用特点是不和视图解析器一同工作，就当项目中没有视图解析器的。
* 优势：当项目中大多数的视图使用视图解析器，有某些视图不在视图的目录中，可以使用redirect指定到其他位置
*
*
* 重定向：
* 1.重定向，使用redirect, 不能访问受保护的/WEB-INF下面的资源
* 2.放入到ModelAndView中的简单类型的值，能够被框架转为String，
* 作为重定向的get请求的参数，传递。 放入到ModelAndView中的对象
* 类型是不能作为参数传递的。
* 3.在重定向的目标页面中，要获取get请求的参数，使用 ${param.参数名}
*/
@RequestMapping(value="some.do")
public ModelAndView doSome( Integer age,String name){
System.out.println("doSome参数name:"+name+"|age:"+age);
//处理some.do的请求， doSome就相当于 Servlet的doGet
ModelAndView mv = new ModelAndView();
//调用Service处理业务，将处理结果显示到视图
mv.addObject("myname", name);
mv.addObject("myage", age);
//将对象Student放入ModelAndView中
Student stu = new Student();
stu.setAge(20);
stu.setName("lisi001");
mv.addObject("mystudent", stu);
//指定redirect到视图
//setViewName("redirect:视图的完整路径")
//mv.setViewName("redirect:/WEB-INF/jsp/show.jsp");
mv.setViewName("redirect:/show.jsp");
//http://localhost:8080/18-redirect/show.jsp?myname=lisi&myage=26
return mv;
}
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
show.jsp 使用注解创建处理器对象 <br>
myname: ${param.myname } <br>
myage: <b>${param.myage }</b>
</body>
</html>
/**
*
## 处理器方法返回值是String , 使用redirect重定向到视图
*/
@RequestMapping("other.do")
public String doOther(){
//重定向到视图页面，语法 redirect:视图的完整路径
return "redirect:/show.jsp";
}
/**
* 重定向到其他的处理器， 由其他处理器方法处理请求。
* 语法： redirect:xxx.do
*/
@RequestMapping("dispather.do")
public ModelAndView doDispather(String name,Integer age){
ModelAndView mv = new ModelAndView();
mv.addObject("myname", name);
mv.addObject("myage", age);
//重定向到其他的处理器
mv.setViewName("redirect:process.do");
//http://localhost:8080/18-redirect/process.do?myname=lisi&myage=22
return mv;
}
//处理器方法，处理转发过来的请求
@RequestMapping("process.do")
public String doProcess(String myname,Integer myage){
System.out.println("==========doProcess===myname:"+myname+"|myage:"+myage);
//视图的逻辑名称 ， forward到视图页面
return "show";//使用了逻辑视图
}
}
1.SpringMVC异常处理之 SimpleMappingExceptionResolver（小型项目中使用《劣势：异常仅仅返回到jsp页面，如果把异常记录到数据库中那就不方便了》）
19-SimpleMappingExceptionResolver:异常的处理
框架的异常处理模型：
处理器方法抛出异常，给中央调度器， 由中央调度器捕获异常， 调用异常处理器对象，集中处理异常。
框架把实现HandlerExceptionResolver接口类的叫做异常处理器， 只有异常处理器能够处理异常。
步骤：
1.新建 web project
2.导入jar:
1)spring的核心jar:spring-beans.jar,spring-core.jar,spring-context.jar,spring-expression.jar
2)spring-aop.jar
3)web相关的jar:spring-web.jar
4)springmvc的实现jar:spring-webmvc.jar
5)日志：commons-logging.jar
3.重点：修改web.xml ， 注册springmvc的核心对象：中央调度器DispatherServlet
1) 中央调度器DispatherServlet是一个Servlet
2) 中央调度器的作用：1）接收用户的请求；2）响应处理结果。
3) 中央调度器也叫做前端控制器(front controller)
4.新建异常类， MyUserException.
子类 NameException ,AgeException
5.新建jsp，发起一个请求。
定义请求参数 name ,age (使用整数表示年龄)
6.新建控制器对象，是一个普通的java类
1）在类的上面加入注解@Controller，创建处理器对象
2）在类中自定义方法，处理某个请求， 在方法的上面加入@RequestMapping.
方法定义形参 name ,age
根据请求的参数 name， age的值分别抛出异常NameException , AgeException
7.新建jsp，显示请求的处理结果
8.定义springmvc的配置文件
1）声明组件扫描器，指定@Controller注解所在的包名
2）声明视图解析器，处理视图
3) 声明异常处理器， 处理异常
9.定义处理异常的视图页面
MyUserException 类
package com.bjpowernode.exceptions;
public class MyUserException extends Exception {
public MyUserException() {
super();
// TODO Auto-generated constructor stub
}
public MyUserException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
}
AgeException 类
package com.bjpowernode.exceptions;
public class AgeException extends MyUserException {
public AgeException() {
super();
// TODO Auto-generated constructor stub
}
public AgeException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
}
package com.bjpowernode.exceptions;
public class NameException extends MyUserException {
public NameException() {
super();
// TODO Auto-generated constructor stub
}
public NameException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
}
MyController 类
package com.bjpowernode.controllers;
import javax.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import com.bjpowernode.exceptions.AgeException;
import com.bjpowernode.exceptions.MyUserException;
import com.bjpowernode.exceptions.NameException;
/**
* @Contorller:创建处理器对象，默认是单例对象
* 位置：在类的上面
*
* @RequestMapping:请求映射
* value:在类的上面使用，value表示请求地址的公共部分， 我们叫做模块名称
*
*/
@Controller
@RequestMapping("test")
public class MyController {
//自定义方法处理请求。
/**
* 抛出异常给中央调度器， 由中央调度器处理异常
* @throws MyUserException
*/
@RequestMapping(value="some.do")
public ModelAndView doSome( Integer age,String name) throws MyUserException{
System.out.println("doSome参数name:"+name+"|age:"+age);
//根据name ,age的值抛出异常
if( !"zs".equals(name)){
throw new NameException("姓名不正确！！！");
}
if( age == null || age.intValue() > 50){
throw new AgeException("年龄太大了！！！");
}
ModelAndView mv = new ModelAndView();
mv.addObject("myname", name);
mv.addObject("myage", age);
mv.setViewName("show");
return mv;
}
}
springmvc.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:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
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
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 声明组件扫描器，指定@Controller注解的包名 -->
<context:component-scan base-package="com.bjpowernode.controllers" />
<!-- 声明视图解析器对象：框架提供的类， 处理视图的。
实现ViewResolver接口的类叫做视图解析器
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 指定前缀：表示视图文件的目录 -->
<property name="prefix" value="/WEB-INF/jsp/" />
<!-- 指定后缀：表示视图文件的扩展名 -->
<property name="suffix" value=".jsp" />
</bean>
<!-- 声明异常处理器，处理异常。异常处理器类要实现HandlerExceptionResolver -->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
<!-- 异常映射：指定异常和 对应的处理页面 -->
<property name="exceptionMappings">
<props>
<!--
key:异常的全限定名称
value:异常的处理页面( 1.视图的逻辑名称；2.视图的完整路径)
-->
<prop key="com.bjpowernode.exceptions.NameException">nameError</prop>
<prop key="com.bjpowernode.exceptions.AgeException">ageError</prop>
</props>
</property>
<!-- 指定默认异常处理页面
value:处理异常的视图页面
-->
<property name="defaultErrorView" value="defaultError" />
<!-- 指定异常对象的名称 ex表示异常对象 -->
<property name="exceptionAttribute" value="ex" />
</bean>
</beans>
nameError.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
nameError.jsp <br>
异常信息： ${ex.message }
</body>
</html>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
defaultError.jsp <br>
异常信息： ${ex.message }
</body>
</html>
ageError
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
ageError.jsp <br>
异常信息： ${ex.message }
</body>
</html>
2.SpringMVC异常处理之 自定义异常处理（大型项目中使用）
20-CustomExceptionResolver:自定义的异常处理器
实现自定义的异常处理器：
1.定义类实现HandlerExceptionResolver接口
2.在springmvc的配置文件中声明自定义异常处理器
步骤：
1.新建 web project
2.导入jar:
1)spring的核心jar:spring-beans.jar,spring-core.jar,spring-context.jar,spring-expression.jar
2)spring-aop.jar
3)web相关的jar:spring-web.jar
4)springmvc的实现jar:spring-webmvc.jar
5)日志：commons-logging.jar
3.重点：修改web.xml ， 注册springmvc的核心对象：中央调度器DispatherServlet
1) 中央调度器DispatherServlet是一个Servlet
2) 中央调度器的作用：1）接收用户的请求；2）响应处理结果。
3) 中央调度器也叫做前端控制器(front controller)
4.新建异常类， MyUserException.
子类 NameException ,AgeException
5.新建jsp，发起一个请求。
定义请求参数 name ,age (使用整数表示年龄)
6.新建控制器对象，是一个普通的java类
1）在类的上面加入注解@Controller，创建处理器对象
2）在类中自定义方法，处理某个请求， 在方法的上面加入@RequestMapping.
方法定义形参 name ,age
根据请求的参数 name， age的值分别抛出异常NameException , AgeException
7.新建jsp，显示请求的处理结果
8.定义springmvc的配置文件
1）声明组件扫描器，指定@Controller注解所在的包名
2）声明视图解析器，处理视图
3) 声明异常处理器， 处理异常
9.定义处理异常的视图页面
springmvc.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:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
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
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 声明组件扫描器，指定@Controller注解的包名 -->
<context:component-scan base-package="com.bjpowernode.controllers" />
<!-- 声明视图解析器对象：框架提供的类， 处理视图的。
实现ViewResolver接口的类叫做视图解析器
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 指定前缀：表示视图文件的目录 -->
<property name="prefix" value="/WEB-INF/jsp/" />
<!-- 指定后缀：表示视图文件的扩展名 -->
<property name="suffix" value=".jsp" />
</bean>
<!-- 声明异常处理器，处理异常。异常处理器类要实现HandlerExceptionResolver -->
<bean class="com.bjpowernode.exceptions.MyCustomExceptionResolver" />
</beans>
package com.bjpowernode.controllers;
import javax.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import com.bjpowernode.exceptions.AgeException;
import com.bjpowernode.exceptions.MyUserException;
import com.bjpowernode.exceptions.NameException;
/**
* @Contorller:创建处理器对象，默认是单例对象
* 位置：在类的上面
*
* @RequestMapping:请求映射
* value:在类的上面使用，value表示请求地址的公共部分， 我们叫做模块名称
*
*/
@Controller
@RequestMapping("test")
public class MyController {
//自定义方法处理请求。
/**
* 抛出异常给中央调度器， 由中央调度器处理异常
* @throws MyUserException
*/
@RequestMapping(value="some.do")
public ModelAndView doSome( Integer age,String name) throws MyUserException{
System.out.println("doSome参数name:"+name+"|age:"+age);
//根据name ,age的值抛出异常
if( !"zs".equals(name)){
throw new NameException("姓名不正确！！！");
}
if( age == null || age.intValue() > 50){
throw new AgeException("年龄太大了！！！");
}
ModelAndView mv = new ModelAndView();
mv.addObject("myname", name);
mv.addObject("myage", age);
mv.setViewName("show");
return mv;
}
}
MyCustomExceptionResolver
package com.bjpowernode.exceptions;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;
/**
* 自定义的异常处理器类
*
*/
public class MyCustomExceptionResolver implements HandlerExceptionResolver {
/**
* resolveException():当程序中抛出异常时，中央调度器会执行此方法，处理异常。
* 参数：
* Object handler：表示发生异常的处理器对象
* Exception exception：异常对象
*
* 返回值：ModelAndView
* ModelAndView：表示异常的数据和视图页面
*
*/
@Override
public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception exception) {
//调用Service把异常记录到数据库，记录到日志文件，发送邮件。
ModelAndView mv = new ModelAndView();
mv.addObject("ex", exception);
//判断异常的类型
if(exception instanceof NameException){
mv.addObject("tips", "姓名不正确，必须是zs!!!");
mv.setViewName("nameError");
} else if( exception instanceof AgeException){
mv.addObject("tips", "年龄不能大于50的！！！");
mv.setViewName("ageError");
} else {
//处理默认异常
mv.addObject("tips", "其他异常！！！");
mv.setViewName("defaultError");
}
return mv;
}
}
nameError.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
nameError.jsp <br>
异常信息： ${ex.message }<br>
tips: ${tips }
</body>
</html>
3.SpringMVC异常处理之 注解异常处理（大型项目中使用，建议使用）
21-AnnotationExceptionResolver:使用注解处理异常。 @ExceptionHandler
步骤：
1.新建 web project
2.导入jar:
1)spring的核心jar:spring-beans.jar,spring-core.jar,spring-context.jar,spring-expression.jar
2)spring-aop.jar
3)web相关的jar:spring-web.jar
4)springmvc的实现jar:spring-webmvc.jar
5)日志：commons-logging.jar
3.重点：修改web.xml ， 注册springmvc的核心对象：中央调度器DispatherServlet
1) 中央调度器DispatherServlet是一个Servlet
2) 中央调度器的作用：1）接收用户的请求；2）响应处理结果。
3) 中央调度器也叫做前端控制器(front controller)
4.新建异常类， MyUserException.
子类 NameException ,AgeException
5.新建jsp，发起一个请求。
定义请求参数 name ,age (使用整数表示年龄)
6.新建控制器对象，是一个普通的java类
1）在类的上面加入注解@Controller，创建处理器对象
2）在类中自定义方法，处理某个请求， 在方法的上面加入@RequestMapping.
方法定义形参 name ,age
根据请求的参数 name， age的值分别抛出异常NameException , AgeException
7.新建jsp，显示请求的处理结果
8.定义springmvc的配置文件
1）声明组件扫描器，指定@Controller注解所在的包名
2）声明视图解析器，处理视图
3) 声明异常处理器， 处理异常
9.定义处理异常的视图页面
nameError.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
nameError.jsp <br>
异常信息： ${ex.message }<br>
tips: ${tips }
</body>
</html>
以上 有点局限性，只能处理一个处理器类的异常。以下定义全局的处理器异常类。（使用@ControllerAdvice注解）
package com.bjpowernode.exceptions;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.servlet.ModelAndView;
/**
* 作为全局的异常处理器
*
*/
@ControllerAdvice
public class AppExceptionResolver {
/**
* 在处理器类中定义方法， 在方法的上面加入@ExceptionHandler
*/
//定义方法，处理NameException
@ExceptionHandler(value=NameException.class)
public ModelAndView doNameException(Exception ex){
//调用Service的方法， 进一步处理异常， 记录到数据库，写入到文件
ModelAndView mv = new ModelAndView();
mv.addObject("tips", "@ControllerAdvice使用注解处理NameException");
mv.addObject("ex", ex);
mv.setViewName("nameError");
return mv;
}
//处理AgeException
@ExceptionHandler(value=AgeException.class)
public ModelAndView doAgeException(Exception ex){
//调用Service的方法， 进一步处理异常， 记录到数据库，写入到文件
ModelAndView mv = new ModelAndView();
mv.addObject("tips", "@ControllerAdvice使用注解处理AgeException");
mv.addObject("ex", ex);
mv.setViewName("ageError");
return mv;
}
//定义方法，处理其他异常（NameException, AgeException之外的异常）
@ExceptionHandler
public ModelAndView doOtherException(Exception ex){
ModelAndView mv = new ModelAndView();
mv.addObject("tips", "@ControllerAdvice使用注解处理其他Exception");
mv.addObject("ex", ex);
mv.setViewName("defaultError");
return mv;
}
}
修改 springmvc.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:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
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
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 声明组件扫描器，指定@Controller注解的包名 -->
<context:component-scan base-package="com.bjpowernode.controllers" />
<!-- 声明组件扫描器，指定@ControllerAdvice注解所在的包名 -->
<context:component-scan base-package="com.bjpowernode.exceptions" />
<!-- 声明注解驱动 -->
<mvc:annotation-driven />
<!--
1. 加入注解驱动，能够使用推荐的处理器映射器：RequestMappingHandlerMapping
能够使用推荐的处理器视频器：RequestMappingHandlerAdapter
2. 能够使用@ControllerAdvice注解
3. 能支持使用HttpMessageConverter接口的7个实现类
4. 还能在内存中创建多个异常处理器
-->
<!-- 声明视图解析器对象：框架提供的类， 处理视图的。
实现ViewResolver接口的类叫做视图解析器
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 指定前缀：表示视图文件的目录 -->
<property name="prefix" value="/WEB-INF/jsp/" />
<!-- 指定后缀：表示视图文件的扩展名 -->
<property name="suffix" value=".jsp" />
</bean>
</beans>
回顾一下拦截器
23-interceptor2:两个拦截器
拦截器拦截用户的请求， 可以对请求做判断，处理的。 可以控制请求是否被处理。
拦截器的执行时间点：获取到处理器的适配器之后，在处理器方法执行之前，拦截用户的请求。
拦截器的数量：在一个项目中拦截器可以0-多个。
拦截器是全局的， 对所有的处理器对象都可以使用。
实现拦截器的步骤：
1.定义类实现拦截器的接口HandlerInterceptor
2.在springmvc的配置文件中，声明拦截器的存在，指定拦截器的uri地址。
步骤：
1.新建 web project
2.导入jar:
1)spring的核心jar:spring-beans.jar,spring-core.jar,spring-context.jar,spring-expression.jar
2)spring-aop.jar
3)web相关的jar:spring-web.jar
4)springmvc的实现jar:spring-webmvc.jar
5)日志：commons-logging.jar
3.重点：修改web.xml ， 注册springmvc的核心对象：中央调度器DispatherServlet
1) 中央调度器DispatherServlet是一个Servlet
2) 中央调度器的作用：1）接收用户的请求；2）响应处理结果。
3) 中央调度器也叫做前端控制器(front controller)
4.新建jsp，发起一个请求。
定义请求参数 name ,age (使用整数表示年龄)
5.新建控制器对象，是一个普通的java类
1）在类的上面加入注解@Controller，创建处理器对象
2）在类中自定义方法，处理某个请求， 在方法的上面加入@RequestMapping.
方法定义形参 name ,age
6.新建jsp，显示请求的处理结果
7.定义类实现HandlerInterceptor接口， 实现接口中的三个方法。
8.定义springmvc的配置文件
1）声明组件扫描器，指定@Controller注解所在的包名
2）声明视图解析器，处理视图
3）声明拦截器对象，指定拦截的请求uri
拦截器的执行流程：
有两个拦截器
第一拦截器preHandle= true , 第二个拦截器preHandle= true
拦截器MyInterceptor11111111的preHandle()
拦截器MyInterceptor2222222的preHandle()
this.interceptorIndex = i; // 2
执行了MyController的doSome方法
拦截器MyInterceptor2222222的postHandle()
拦截器MyInterceptor11111111的postHandle()
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);{
1. 如果有异常，处理异常：
调用mv = processHandlerException(request, response, handler, exception);
2. render(mv, request, response);
{
1.调用视图解析器，创建视图对象 InternalResourceView: name 'show'; URL [/WEB-INF/jsp/show.jsp]
2.view.render(mv.getModelInternal(), request, response); 合并数据，添加到视图
}
3. 执行拦截器的 afterCompletion()
拦截器MyInterceptor22222222的afterCompletion()
拦截器MyInterceptor111111111的afterCompletion()
}
============================================================
有两个拦截器
第一拦截器preHandle= true , 第二个拦截器preHandle= false
拦截器MyInterceptor11111111的preHandle()
拦截器MyInterceptor2222222的preHandle()
拦截器MyInterceptor111111111的afterCompletion()
===========================================================
有两个拦截器
第一拦截器preHandle= false , 第二个拦截器preHandle= true/false
拦截器MyInterceptor11111111的preHandle()
springmvc.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:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
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
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 声明组件扫描器，指定@Controller注解的包名 -->
<context:component-scan base-package="com.bjpowernode.controllers" />
<!-- 声明视图解析器对象：框架提供的类， 处理视图的。
实现ViewResolver接口的类叫做视图解析器
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 指定前缀：表示视图文件的目录 -->
<property name="prefix" value="/WEB-INF/jsp/" />
<!-- 指定后缀：表示视图文件的扩展名 -->
<property name="suffix" value=".jsp" />
</bean>
<!-- 声明拦截器对象，指定拦截器的uri -->
<mvc:interceptors>
<!-- 第一个拦截器 -->
<mvc:interceptor>
<!-- 拦截的uri -->
<mvc:mapping path="/**"/>
<!-- 指定拦截器 -->
<bean class="com.bjpowernode.interceptors.MyInterceptor" />
</mvc:interceptor>
<!-- 第二个拦截器 -->
<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="com.bjpowernode.interceptors.MyInterceptor2" />
</mvc:interceptor>
</mvc:interceptors>
</beans>
package com.bjpowernode.interceptors;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
//拦截器
public class MyInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
System.out.println("拦截器MyInterceptor11111111的preHandle()");
return false;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
ModelAndView mv) throws Exception {
System.out.println("拦截器MyInterceptor11111111的postHandle()");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
throws Exception {
System.out.println("拦截器MyInterceptor111111111的afterCompletion()");
}
}
package com.bjpowernode.interceptors;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
//拦截器
public class MyInterceptor2 implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
System.out.println("拦截器MyInterceptor2222222的preHandle()");
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
ModelAndView mv) throws Exception {
System.out.println("拦截器MyInterceptor2222222的postHandle()");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
throws Exception {
System.out.println("拦截器MyInterceptor22222222的afterCompletion()");
}
}
index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
index.jsp <br><br>
<a href="test/other.do">发起get方法some.do的请求</a>
<br>
<br>
<form action="test/some.do" method="post">
姓名：<input type="text" name="name" /><br><br>
年龄：<input type="text" name="age" /> <br><br>
<input type="submit" value="post请求">
</form>
</body>
</html>
package com.bjpowernode.controllers;
import javax.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
/**
* @Contorller:创建处理器对象，默认是单例对象
* 位置：在类的上面
*
* @RequestMapping:请求映射
* value:在类的上面使用，value表示请求地址的公共部分， 我们叫做模块名称
*
*/
@Controller
@RequestMapping("test")
public class MyController {
//自定义方法处理请求。
@RequestMapping(value="some.do")
public ModelAndView doSome( Integer age,String name){
System.out.println("执行了MyController的doSome方法");
//处理some.do的请求， doSome就相当于 Servlet的doGet
ModelAndView mv = new ModelAndView();
//调用Service处理业务，将处理结果显示到视图
mv.addObject("myname", name);
mv.addObject("myage", age);
//指定视图
mv.setViewName("show");
return mv;
}
}
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
<display-name>01-primary</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
<!-- 注册springmvc的核心对象DispatherServlet(中央调度器) -->
<!--
/WEB-INF/springmvc-servlet.xml
/WEB-INF/myweb-servlet.xml
DispatcherServlet在创建对象的时候，在init()方法中会创建springmvc的容器对象
WebApplicationContext, 创建容器的时候会读取配置文件， 创建配置文件中的所有bean对象。
默认读取的配置文件的位置是 /WEB-INF ,默认的文件名称是 <servlet-name>-servlet.xml
-->
<servlet>
<servlet-name>myweb</servlet-name>
<!-- springmvc.jar -->
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 自定义springmvc配置文件的位置和名称 -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!-- 在服务器启动的时候，创建对象 -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>myweb</servlet-name>
<!--
url-pattern是把请求交给某个Servlet处理， 我们现在要做的是把用户的请求交给SpringMVC框架中的核心对象
中央调度器， 交给中央调度器的处理的请求才能使用springmvc框架。
中央调度器是springmvc框架的入口
url-pattern的配置方式:
1.扩展名方式： *.xxxx ； xxxx是自定义的扩展名，例如 *.do , *.action, *.mvc的等等。不能使用 *.jsp
http://localhost:8080/myweb/some.do
http://localhost:8080/myweb/user/addUser.do
2.使用斜杠"/"
-->
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<!-- 注册字符集过滤器，解决post请求中乱码的问题 -->
<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<!-- 指定当前项目使用的字符编码 -->
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
<!-- 强制请求(HttpServletRequest)对象，使用encoding的字符编码 -->
<init-param>
<param-name>forceRequestEncoding</param-name>
<param-value>true</param-value>
</init-param>
<!-- 强制应答(HttpServletResponse)对象，使用encoding的字符编码 -->
<init-param>
<param-name>forceResponseEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
show.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
/WEB-INF/jsp/show.jsp 使用注解创建处理器对象 <br>
myname: ${myname } <br>
myage: ${myage }<br>
msg: ${msg }
</body>
</html>
other.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
/WEB-INF/jsp/other.jsp <br>
msg: ${msg }
</body>
</html>
模拟用户登录的拦截
24-permissonInterceptor:权限拦截器
拦截器拦截用户的请求， 可以对请求做判断，处理的。 可以控制请求是否被处理。
拦截器的执行时间点：获取到处理器的适配器之后，在处理器方法执行之前，拦截用户的请求。
拦截器的数量：在一个项目中拦截器可以0-多个。
拦截器是全局的， 对所有的处理器对象都可以使用。
实现拦截器的步骤：
1.定义类实现拦截器的接口HandlerInterceptor
2.在springmvc的配置文件中，声明拦截器的存在，指定拦截器的uri地址。
步骤：
1.新建 web project
2.导入jar:
1)spring的核心jar:spring-beans.jar,spring-core.jar,spring-context.jar,spring-expression.jar
2)spring-aop.jar
3)web相关的jar:spring-web.jar
4)springmvc的实现jar:spring-webmvc.jar
5)日志：commons-logging.jar
3.重点：修改web.xml ， 注册springmvc的核心对象：中央调度器DispatherServlet
1) 中央调度器DispatherServlet是一个Servlet
2) 中央调度器的作用：1）接收用户的请求；2）响应处理结果。
3) 中央调度器也叫做前端控制器(front controller)
4.新建jsp，发起一个请求。
定义请求参数 name ,age (使用整数表示年龄)
5.新建控制器对象，是一个普通的java类
1）在类的上面加入注解@Controller，创建处理器对象
2）在类中自定义方法，处理某个请求， 在方法的上面加入@RequestMapping.
方法定义形参 name ,age
6.新建jsp，显示请求的处理结果
7.定义类实现HandlerInterceptor接口， 实现接口中的三个方法。
在preHandle()方法中验证会话中的用户信息是否是zhangsan ,如果是zhangsan能访问系统
8.定义springmvc的配置文件
1）声明组件扫描器，指定@Controller注解所在的包名
2）声明视图解析器，处理视图
3）声明拦截器对象，指定拦截的请求uri
9.新建jsp，默认登录 login.jsp
登出系统 logout.jsp
login.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
login.jsp 登录系统<br>
<%
session.setAttribute("username", "zhangsan");
%>
</body>
</html>
logout.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
logout.jsp 登出系统
<%
session.removeAttribute("username");
%>
</body>
</html>
fail.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
fail.jsp:不能访问系统
</body>
</html>
MyInterceptor.java
package com.bjpowernode.interceptors;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
//拦截器
public class MyInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
System.out.println("拦截器MyInterceptor的preHandle()");
//实现身份的认证
String username = "";
//从Session中获取用户的信息
Object attr = request.getSession().getAttribute("username");
if( attr != null){
username = (String)attr;
}
//判断登录的用户是否是zhangsan
if(!"zhangsan".equals(username)){
//不是张三
request.getRequestDispatcher("/fail.jsp").forward(request, response);
return false;
}
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
ModelAndView mv) throws Exception {
System.out.println("拦截器MyInterceptor的postHandle()");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
throws Exception {
System.out.println("拦截器MyInterceptor的afterCompletion()");
}
}
2895
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
