Spring MVC 编程基础

p.MsoNormal,li.MsoNormal,div.MsoNormal { margin: 0cm; margin-bottom: .0001pt; text-align: justify; font-size: 12.0pt; font-family: Consolas }
h1 { margin-top: 17.0pt; margin-right: 0cm; margin-bottom: 16.5pt; margin-left: 21.25pt; text-align: justify; text-indent: -21.25pt; line-height: 240%; page-break-after: avoid; font-size: 18.0pt; font-family: Consolas; font-weight: bold }
h2 { margin-top: 13.0pt; margin-right: 0cm; margin-bottom: 13.0pt; margin-left: 1.0cm; text-align: justify; text-indent: -1.0cm; line-height: 173%; page-break-after: avoid; border: none; padding: 0cm; font-size: 14.0pt; font-family: Arial; font-weight: bold }
h3 { margin-top: 13.0pt; margin-right: 0cm; margin-bottom: 13.0pt; margin-left: 0cm; text-align: justify; text-indent: 0cm; line-height: 172%; page-break-after: avoid; border: none; padding: 0cm; font-size: 10.5pt; font-family: 微软雅黑; font-weight: bold }
h5 { margin-top: 14.0pt; margin-right: 0cm; margin-bottom: 14.5pt; margin-left: 0cm; text-align: justify; line-height: 156%; page-break-after: avoid; font-size: 14.0pt; font-family: Consolas; font-weight: bold }
p.MsoToc1,li.MsoToc1,div.MsoToc1 { margin: 0cm; margin-bottom: .0001pt; text-align: justify; font-size: 12.0pt; font-family: Consolas }
p.MsoToc2,li.MsoToc2,div.MsoToc2 { margin-top: 0cm; margin-right: 0cm; margin-left: 21.0pt; margin-bottom: .0001pt; text-align: justify; font-size: 12.0pt; font-family: Consolas }
p.MsoToc3,li.MsoToc3,div.MsoToc3 { margin-top: 0cm; margin-right: 0cm; margin-left: 42.0pt; margin-bottom: .0001pt; text-align: justify; font-size: 12.0pt; font-family: Consolas }
p.MsoToc4,li.MsoToc4,div.MsoToc4 { margin-top: 0cm; margin-right: 0cm; margin-left: 63.0pt; margin-bottom: .0001pt; text-align: justify; font-size: 12.0pt; font-family: Calibri }
p.MsoToc5,li.MsoToc5,div.MsoToc5 { margin-top: 0cm; margin-right: 0cm; margin-left: 84.0pt; margin-bottom: .0001pt; text-align: justify; font-size: 12.0pt; font-family: Calibri }
p.MsoToc6,li.MsoToc6,div.MsoToc6 { margin-top: 0cm; margin-right: 0cm; margin-left: 105.0pt; margin-bottom: .0001pt; text-align: justify; font-size: 12.0pt; font-family: Calibri }
p.MsoToc7,li.MsoToc7,div.MsoToc7 { margin-top: 0cm; margin-right: 0cm; margin-left: 126.0pt; margin-bottom: .0001pt; text-align: justify; font-size: 12.0pt; font-family: Calibri }
p.MsoToc8,li.MsoToc8,div.MsoToc8 { margin-top: 0cm; margin-right: 0cm; margin-left: 147.0pt; margin-bottom: .0001pt; text-align: justify; font-size: 12.0pt; font-family: Calibri }
p.MsoToc9,li.MsoToc9,div.MsoToc9 { margin-top: 0cm; margin-right: 0cm; margin-left: 168.0pt; margin-bottom: .0001pt; text-align: justify; font-size: 12.0pt; font-family: Calibri }
p.MsoFootnoteText,li.MsoFootnoteText,div.MsoFootnoteText { margin: 0cm; margin-bottom: .0001pt; font-size: 9.0pt; font-family: Consolas }
p.MsoHeader,li.MsoHeader,div.MsoHeader { margin: 0cm; margin-bottom: .0001pt; text-align: center; border: none; padding: 0cm; font-size: 9.0pt; font-family: Consolas }
p.MsoFooter,li.MsoFooter,div.MsoFooter { margin: 0cm; margin-bottom: .0001pt; font-size: 9.0pt; font-family: Consolas }
span.MsoFootnoteReference { vertical-align: super }
a:link,span.MsoHyperlink { color: blue; text-decoration: underline }
a:visited,span.MsoHyperlinkFollowed { color: purple; text-decoration: underline }
p.MsoDocumentMap,li.MsoDocumentMap,div.MsoDocumentMap { margin: 0cm; margin-bottom: .0001pt; text-align: justify; background: navy; font-size: 12.0pt; font-family: Consolas }
p { margin-right: 0cm; margin-left: 0cm; font-size: 12.0pt; font-family: 宋体 }
code { font-family: 宋体 }
pre { margin: 0cm; margin-bottom: .0001pt; background: #F3F5F7; border: none; padding: 0cm; font-size: 12.0pt; font-family: Courier }
p.MsoAcetate,li.MsoAcetate,div.MsoAcetate { margin: 0cm; margin-bottom: .0001pt; text-align: justify; font-size: 9.0pt; font-family: Calibri }
p.MsoListParagraph,li.MsoListParagraph,div.MsoListParagraph { margin: 0cm; margin-bottom: .0001pt; text-align: justify; text-indent: 21.0pt; font-size: 10.5pt; font-family: Consolas }
span.1
{ font-family: Consolas; font-weight: bold }
span.2
{ font-family: Arial; font-weight: bold }
span.3
{ font-family: 微软雅黑; font-weight: bold }
span.5
{ font-family: Consolas; font-weight: bold }
span.Char { font-family: Consolas }
span.color-new { }
span.color-comment { }
span.line-heading { }
span.apple-converted-space { }
span.a { }
span.HTML { font-family: Courier; background: #F3F5F7 }
span.a0 { font-family: Consolas }
span.a1 { font-family: Consolas }
span.10
{ font-family: "Times New Roman" }
span.a2 { font-family: Consolas }
span.HTML1 { font-family: Courier }
span.a3 { font-family: Consolas; background: navy }
p.a4,li.a4,div.a4 { margin: 0cm; margin-bottom: .0001pt; text-indent: 21.0pt; font-size: 10.5pt; font-family: Consolas }
span.msoIns { text-decoration: underline; color: teal }
span.msoDel { text-decoration: line-through; color: red }
span.SpellE { }
span.GramE { }
.MsoChpDefault { font-family: Calibri }
div.WordSection1 { }
ol { margin-bottom: 0cm }
ul { margin-bottom: 0cm }

 

Spring MVC

编程基础

1.   Spring MVC 概述. 6

1.1.        企业级应用基本架构. 6

1.2.        Web MVC架构及分析. 7

1.3.        Spring MVC 架构及分析. 7

2.   Spring MVC 编程基础. 8

2.1.        Spring MVC 编程基本步骤. 8

2.2.        Spring MVC 编程基础实现（重点）. 8

2.2.1.           创建Maven WEB 项目并添加Spring MVC 依赖. 8

2.2.2.           添加Spring MVC配置文件并进行基本配置. 13

2.2.3.           配置Spring MVC前端控制器. 14

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

2.2.5.           创建JSP页面对象. 15

2.2.6.           部署并运行项目以及请求响应流程分析. 15

3.   Spring MVC 请求处理. 17

3.1.        请求路径映射. 17

3.1.1.           普通url映射. 17

3.1.2.           Rest风格url映射. 17

3.2.        请求方式映射. 18

3.2.1.           请求方式限定. 18

3.2.2.           请求方式组合. 18

3.3.        请求参数映射(重点)19

3.3.1.           标准Servlet API（了解）. 19

3.3.2.           直接量对象（重点）. 19

3.3.3.           Java bean对象（重点）. 20

3.3.4.           集合Map对象对象（了解）. 21

3.3.5.           Rest url数据（重点）. 21

3.3.6.           请求头数据（了解）. 21

4.   Spring MVC 响应处理. 23

4.1.        响应数据封装. 23

4.1.1.           Servlet API 对象（了解）. 23

4.1.2.           ModelAndView 对象（重点）. 25

4.1.3.           Model对象（重点）. 25

4.1.4.           Map对象（了解）. 25

4.2.        响应数据转换JSON（重点）. 26

4.2.1.           JSON 应用概述. 26

4.2.2.           Spring 集成jackson库. 26

5.   总结. 28

5.1.        重点和难点分析. 28

5.2.        课后必须完成作业. 28

5.3.        课后扩展作业. 28

6.   Spring IOC 应用进阶. 31

6.1.        Bean对象属性值的注入. 31

6.1.1.           直接量值的注入. 32

6.1.2.           集合对象值的注入:34

6.1.3.           依赖对象值的注入. 35

6.2.        Bean对象属性值自动装配（了解）. 37

7.   课后总结. 37

7.1.        重点和难点分析. 37

7.2.        作业. 38

8.   Spring IOC 注解基本应用. 41

8.1.        Spring Bean 注解描述. 41

8.2.        Spring Bean 注解应用. 42

8.2.1.           Bean对象声明注解应用. 42

8.2.2.           Bean对象作用域注解应用. 43

8.2.3.           Bean对象生命周期方法注解应用. 44

8.2.4.           Bean对象自动装配注解应用. 44

9.   Spring IOC 注解应用进阶. 45

9.1.        @ComponentScan注解应用. 45

9.2.        @Bean注解应用. 46

9.3.        @Value与@PropertySource注解应用. 47

10.            总结. 48

10.1.               重点和难点分析. 48

10.2.               作业. 48

11.            Spring MVC拦截器应用. 51

11.1.               Spring MVC拦截器概述. 51

11.2.               Spring MVC拦截器编写及基本配置. 53

11.3.               Spring MVC拦截器链及配置实现. 54

12.            Spring MVC异常处理. 56

12.1.               Spring MVC 异常概述. 56

12.2.               Spring MVC 异常处理. 57

13.            Spring MVC 文件上传(课后扩展)58

13.1.               文件上传业务场景. 58

13.2.               Spring MVC 文件上传基本步骤. 59

13.2.1.                  添加依赖. 59

13.2.2.                  配置对象解析. 59

13.2.3.                  定义upload.jsp60

13.2.4.                  定义UploadController60

14.            总结. 61

14.1.               重点和难点分析. 61

14.2.               常见FAQ61

14.3.               作业. 61

15.            Spring AOP 概述. 66

15.1.               AOP是什么？. 66

15.2.               AOP要解决什么问题？. 66

15.3.               AOP实际项目应用场景？. 67

15.4.               AOP底层原理实现分析？. 67

15.5.               AOP 相关术语. 67

16.            Spring AOP 编程基础. 68

16.1.               AOP 基本步骤. 68

16.2.               AOP 基于xml实现. 68

16.2.1.                  创建项目添加依赖. 69

16.2.2.                  添加spring配置文件. 69

16.2.3.                  创建核心业务类. 70

16.2.4.                  创建日志处理类. 70

16.2.5.                  配置bean对象. 70

16.2.6.                  编写测试类. 71

16.2.7.                  原理分析. 72

16.3.               AOP 基于注解实现. 72

16.3.1.                  创建maven 项目添加依赖. 72

16.3.2.                  创建核心业务类. 73

16.3.3.                  创建时间处理类. 73

16.3.4.                  配置AOP实现. 74

16.3.5.                  编写测试类. 75

17.            Spring AOP 编程增强. 76

17.1.               切面表达式增强. 76

17.1.1.                  Bean表达式应用增强. 77

17.1.2.                  Within表达式应用增强. 77

17.1.3.                  Execution表达式应用增强. 77

17.1.4.                  @annotation表达式应用增强. 78

17.2.               切面通知增强. 78

17.2.1.                  Xml方式通知配置增强（了解）. 78

17.2.2.                  注解方式通知配置增强. 79

17.3.               切面执行顺序配置增强. 80

17.3.1.                  Xml方式配置执行顺序. 80

17.3.2.                  注解方式配置执行顺序. 81

18.            总结. 82

18.1.               重点和难点分析. 82

18.2.               常见FAQ82

18.3.               作业. 82

19.            Spring 事务管理. 87

19.1.               Spring 事务概述. 87

19.2.               Spring事务案例分析. 87

20.            Spring 声明式事务处理. 88

20.1.               基于注解方式实现. 89

20.2.               基于xml方式实现. 90

21.            Spring事务增强. 91

21.1.               Spring 事务的传播特性. 91

21.2.               Spring 事务的隔离级别. 92

22.            总结. 94

22.1.               重点和难点分析. 94

22.2.               常见FAQ94

23.            Ajax 概述. 99

23.1.               Ajax 是什么. 99

23.2.               Ajax 解决了什么问题. 99

23.3.               Ajax 应用模型. 100

24.            Ajax 编程实现. 101

24.1.               Ajax 编程步骤. 101

24.2.               Ajax编程实现（了解）. 102

24.2.1.                  Ajax 异步GET请求. 102

24.2.2.                  Ajax 异步post请求. 104

25.            JQuery中的Ajax应用. 104

25.1.               ajax 函数应用. 104

25.2.               load函数应用. 105

25.3.               getJson函数应用. 106

25.4.               post 函数应用. 106

25.1.               。。。。. 106

26.            总结. 107

26.1.               重点和难点分析. 107

26.2.               常见FAQ107

<![if !supportLists]>1.<![endif]>Spring MVC 概述

<![if !supportLists]>1.1.        <![endif]>企业级应用基本架构

企业级应用中的软件的分层的基本架构

<![if !vml]><![endif]>

说明：分层架构的本质是分而治之，已达到分解问题复杂性的目的，从而更好的进行设计与实现。Ss

<![if !supportLists]>1.2.        <![endif]>Web MVC架构及分析

基于servlet，jsp，javabean技术实现的MVC架构,具体架构图如下：

<![if !vml]><![endif]>

<![if !supportLists]>1.3.        <![endif]>Spring MVC 架构及分析

Spring MVC是MVC架构模式的一种完美实现，它简化了Java WEB 中基于MVC架构的编程过程，是Spring中的WEB应用模块。

Spring MVC 底层核心架构图及工作流程（先了解，写完项目案例再重点强化）

<![if !vml]><![endif]>

Spring MVC 中的核心组件：

<![if !supportLists]>1)    <![endif]>DispatcherServlet（前端控制器, 处理请求的入口）

<![if !supportLists]>2)    <![endif]>HandlerMapping（映射器对象, 用于管理url与对应controller的映射关系）

<![if !supportLists]>3)    <![endif]>Interceptors（拦截器,实现请求响应的共性处理）

<![if !supportLists]>4)    <![endif]>Controller （后端控制器, 负责处理请求的控制逻辑）

<![if !supportLists]>5)    <![endif]>ViewResolver（视图解析器,解析对应的视图关系：前缀+view+后缀）

备注：假如希望了解Spring MVC的详细处理流程可以基于断点调试法进行跟踪。

<![if !supportLists]>2.<![endif]>Spring MVC 编程基础

<![if !supportLists]>2.1.        <![endif]>Spring MVC 编程基本步骤

Step01：创建maven web 项目并解决项目中的错误问题

Step02：添加Spring MVC项目核心依赖

Step03：配置Spring MVC项目核心组件

Step04：创建Spring MVC 后端控制器及页面

Step05：部署及测试spring mvc 项目应用。

<![if !supportLists]>2.2.        <![endif]>Spring MVC 编程基础实现（重点）

<![if !supportLists]>2.2.1.    <![endif]>创建Maven WEB 项目并添加Spring MVC 依赖

Step01:创建maven web项目

<![if !supportLists]>1)  <![endif]>项目名 CGB-SPRING-MVC-01

<![if !vml]><![endif]>

<![if !vml]><![endif]>

<![if !supportLists]>2)  <![endif]>Web项目打包方式为war方式

<![if !vml]><![endif]>

Step02:配置maven web项目

<![if !supportLists]>1)  <![endif]>生成web.xml

<![if !vml]><![endif]>

<![if !supportLists]>2)  <![endif]>Web项目的target runtimes为tomcat

<![if !vml]><![endif]>

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

<![if !vml]><![endif]>

Step03： 添加Spring MVC项目依赖

<dependencies>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-webmvc</artifactId>

<version>4.3.9.RELEASE</version>

</dependency>

</dependencies>

<![if !supportLists]>2.2.2.    <![endif]>添加Spring MVC配置文件并进行基本配置

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

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

<beans default-lazy-init="true"

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

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

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

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

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-4.3.xsd 

       http://www.springframework.org/schema/mvc  

       http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd  

       http://www.springframework.org/schema/tx  

       http://www.springframework.org/schema/tx/spring-tx-4.3.xsd  

       http://www.springframework.org/schema/aop

       http://www.springframework.org/schema/aop/spring-aop-4.3.xsd

       http://www.springframework.org/schema/util

       http://www.springframework.org/schema/util/spring-util-4.3.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/context

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

<!--配置组件扫描 -->

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

<!—启用MVC默认配置 (@RequestMapping) -->

<mvc:annotation-driven/>

<!--配置视图解析器 -->

<bean  id="viewResolver"   class="org.springframework.web.servlet.view.InternalResourceViewResolver">

<property name="prefix" value="/WEB-INF/pages/"/>

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

</bean>

</beans>

说明：配置文件的名字可以自己指定。

<![if !supportLists]>2.2.3.    <![endif]>配置Spring MVC前端控制器

打开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>

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

其中

<![if !supportLists]>1)  <![endif]>load-on-startup 表示启动时则加载此servlet,数字越小优先级越高.

<![if !supportLists]>2)  <![endif]>init-param中的参数名不能变（此名字在DispatcherServlet父类中定义）

<![if !supportLists]>2.2.4.    <![endif]>创建并配置Spring MVC后端控制器

编写Spring MVC后端控制器

@Controller

@RequestMapping("/")

publicclass HelloController{

@RequestMapping("doSayHello")

public ModelAndView doSayHello(String msg) {

ModelAndView mv=new ModelAndView("hello");

mv.addObject("message", "helloworld");

returnmv;

}

}

其中:

1）通过@RequestMapping注解定义url到controller具体方法的映射,这个映射信息会被存储,一般是存储到一个HandlerMapping对象中.

2）ModelAndView对象为一个模型与视图对象，内置一个map对象，主要用于封装业务数据和视图名。

3）ModelAndView构造方法中传递的为视图名，addObject方法可以以key/value形式存储数据。

4）ModelAndView对象返回时会被spring mvc自动存储到请求作用域，在对应的视图页面可以直接从此作用域获取对应的值。

<![if !supportLists]>2.2.5.    <![endif]>创建JSP页面对象

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

?

<body>

<h1>${message}</h1>

</body>

?

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

<![if !supportLists]>2.2.6.    <![endif]>部署并运行项目以及请求响应流程分析

将项目部署到tomcat，然后启动运行，在地址栏输入具体url访问对应controller对象。

问题分析：

<![if !supportLists]>1）<![endif]>tomcat启动时出现ClassNotFoundException，而这个class又不是我们自己的类，此时要重新maven update，重新发布(右键tomcat 重新publish)，多次尝试还是不可以，此时重启eclipse。

<![if !supportLists]>2）<![endif]>404异常，一般表示服务端资源没找到,首先检测访问路径是否正确，然后还可以在项目的部署目录中去查找对应的资源，必须确保资源是存在的，假如资源不存在，说明代码没有正常编译。（很常见）

<![if !supportLists]>3）<![endif]>如何解决这种项目不编译的问题？

step01) 停止tomcat将tomcat下的项目移除，并clean你的tomcat服务器(两个clean)

step03) 对项目进行maven clean操作(清除原先编译结构，然后重新编译)

step04) 再次对项目进行clean操作（菜单栏中的project clean）

step05) 重新部署项目，启动tomcat运行

step06) 假如经历了以上几个步骤，还没解决此问题，重启eclipse再试

说明：假如你的eclipse经常出现类似问题，换jdk。

<![if !supportLists]>4）<![endif]>运行项目时尽量不要右键运行选在run as /run on server

项目的请求处理流程结构及过程解析：

<![if !vml]><![endif]>

Step01:客户端向服务服务端发请求

Step02:服务端对请求信息进行过滤(Filter)

Step03:请求到达前端控制DispatcherServlet

Step04:前端控制器基于url在HandlerMapping中的映射找请求执行链

Step05:执行执行链中的拦截器(Interceptor)方法

Step06:执行执行链中的控制器(Controller)方法

Step07:对象控制层返回的视图进行解析

Step08:向客户端返回一个响应结果。

<![if !supportLists]>3.<![endif]>Spring MVC 请求处理

<![if !supportLists]>3.1.        <![endif]>请求路径映射

实际项目中我们要借助@RequestMapping注解定义映射路径。其注解应用位置

<![if !supportLists]>ü  <![endif]>类定义处： 提供初步的请求映射信息。

<![if !supportLists]>ü  <![endif]>方法定义处： 提供进一步的细分映射信息

<![if !supportLists]>3.1.1.    <![endif]>普通url映射

@RequestMapping(value={"/doSayHello", "/user/doSayWelcome"})：

多个URL路径可以映射到同一个处理器的功能处理方法。

<![if !supportLists]>3.1.2.    <![endif]>Rest风格url映射

REST即表述性状态传递（英文：Representational State Transfer，简称REST），是一种软件架构编码风格，是基于网络应用进行设计和开发的编码方式。可以降低开发的复杂度，提高程序的可伸缩性。例如：

@RequestMapping("/msg/{xxx}")

请求的URL可以是“/msg/hello”或“/msg/welcome”

@RequestMapping("/msg/{id}/create")：

请求的URL可以是“/users/1/create”。

@RequestMapping("/msg/{mId}/topics/{tId}")

这样也是可以的，请求的URL可以是“/users/10/topics/12”。

说明：通过@PathVariable可以提取URI模板模式中的{×××}中的×××变量。

http://localhost:8080/项目名/doUpdate/1.do

<![if !supportLists]>3.2.        <![endif]>请求方式映射

<![if !supportLists]>3.2.1.    <![endif]>请求方式限定

项目中Controller层对象的每个方法默认可以处理任意方式的请求，假如要指定控制层方法只能处理GET或只能处理POST请求，那该如何实现呢？

借助@RequestMapping注解中的method属性指定具体的请求处理方式，例如

@RequestMapping(value=”doSaveObj”,

method=RequestMethod.POST)

public String doSaveObject(Object obj){?.}

知识点扩展：

1)@GetMapping 注解应用(定义的映射只能处理get请求）

2)@PostMapping 注解应用(定义的映射只能处理post请求)

<![if !supportLists]>3.2.2.    <![endif]>请求方式组合

项目中还可在控制层方法上借助@RequestMapping注解中的method属性指定使用哪几种方式处理请求。

@RequestMapping(value=”doSaveObj”,

method={RequestMethod.POST，

RequestMethod.GET})

public String doSaveObject(Object obj){?.}

提示：一般浏览器只支持GET或POST方式。

<![if !supportLists]>3.3.        <![endif]>请求参数映射(重点)

<![if !supportLists]>3.3.1.    <![endif]>标准Servlet API（了解）

请求映射方法中可以直接使用ServletAPI中的对象获取参数数据，例如

HttpServletRequest，HttpSession对象等，例如：

@RequestMapping(value="withRequest",method=RequestMethod.GET)

@ResponseBody

public String withRequest(HttpServletRequest request){

System.out.println(request.getRequestURI());

return "Obtainer ‘foo‘ query parameter value

‘"+request.getParameter("gid")+"‘";

}

提示：@ResponseBody注解作用：该注解作用于将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区，使用情况：返回的数据不是Html标签的页面，而是其他数据格式的数据时，（如Json、xml，普通文本等）使用；

<![if !supportLists]>3.3.2.    <![endif]>直接量对象（重点）

SpringMVC请求一个控制层资源时，可以在对应方法中直接使用参数变量接收参数数据，但参数变量的类型建议为对象类型。

使用String类型变量接受请求参数的值：

@RequestMapping(value="withStringParam",method=RequestMethod.GET)

@ResponseBody

public String withStringParam(@RequestParam String foo) {

return "Obtained ‘foo‘ query parameter value ‘" + foo + "‘";

}

提示：@RequestParam注解用于接收请求参数中名字为foo的参数值，假如请求参数名与方法中的参数名一致，@RequestParam注解可以省略。假如不一致则可以使用@RequestParam注解定义新的参数名直接接收页面数据，然后传递给方法名，还有就是请求参数中包含特殊字符时，需要借助@RequestParam注解对参数进行声明。例如

@RequestMapping(value="withStringParam", method=RequestMethod.GET)

@ResponseBody

public String withStringParam(

@RequestParam(value="param-01",required=false) String foo) {

return "Obtained ‘foo‘ query parameter value ‘" + foo + "‘";

}

提示：required=false表示，参数可以不存在，假如为true（默认），参数不存在时会抛出异常(400异常)。

使用Date类型变量接受请求日期参数的值：

@RequestMapping(value="withDateParam")

@ResponseBody

public String withDateParam(Date birthday) {

return "Obtained date parameter value ‘" + birthday + "‘";

}

Spring MVC 默认支持yyyy/MM/dd格式日期转换，假如日期格式不匹配会报400异常

使用Integer类型的可变参数或数组接收请求数据

@RequestMapping(value="withVarParam")

@ResponseBody

public String withVarParam(Integer? ids) {

return "Obtained ids parameter value ‘" + ids + "‘";

}

<![if !supportLists]>3.3.3.    <![endif]>Java bean对象（重点）

当请求中多个参数时可以通过在方法中定义多个参数接收参数数据，也可以利用一个javabean对象接收多个参数数据以简化多个参数变量的定义。

@RequestMapping(value="withParamGroup",method=RequestMethod.GET)

@ResponseBody

public String withParamGroup(SysLog entity) {

return "Obtained javabean parameter group " + entity;

}

提示：当使用javabean接收请求参数数据时，bean中需要有与参数名对应的set方法。

<![if !supportLists]>3.3.4.    <![endif]>集合Map对象对象（了解）

说明：通过map接收页面参数时，需要使用@RequestParam注解声明

@RequestMapping("doMap02")

public String withParamGroup (

@RequestParam Map<String,Object> map) {

return "Obtained map parameter group " + map;

}

提示：此时的map不能再作为响应数据的封装对象

<![if !supportLists]>3.3.5.    <![endif]>Rest url数据（重点）

SpringMVC请求资源路径的URL可以通过{XXX}形式指定动态的URL，动态URL中的这个可变参数的值可以直接注入到方法对应的参数中。

@RequestMapping(value="path/{var}",method=RequestMethod.GET)

@ResponseBody

public String withPathVariable(@PathVariable String var) {

return "Obtained ‘var‘ path variable value ‘" + var + "‘";

}

通过@PathVariable注解指定参数变量var获取请求url中{var}数据

<![if !supportLists]>3.3.6.    <![endif]>请求头数据（了解）

当服务端要获取客户端请求头中数据信息时，可通过@RequestHeader即可将请求头中

的属性值绑定到处理方法的入参中，例如获取请求中Accept属性的值，然后传入到对应方法的参数中。

@RequestMapping(value="header", method=RequestMethod.GET)

@ResponseBody

public String withHeader(@RequestHeader String Accept) {

return "Obtained ‘Accept‘ header ‘" + Accept + "‘";

}

假如希望在此方法中直接从cookie取值，可以定义参数时使用@CookieValue对参数进行修饰，参数名一般要与cookie对象中的key相同

@RequestMapping(value="withCookie")

@ResponseBody

public String withCooke(

@CookieValue String JSESSIONID) {

return "Obtained COOKIE Value ‘" + JSESSIONID + "‘";

}

提示：方法中的参数名需要与请求头参数中某个参数名相同，具体请求头相关信息可以在浏览器控制台查看。

当应用中要获取请求中所有数据时可以在请求方法中定义一个HttpEntity<String>参数，通过此参数获取请求头及请求体中数据，例如

@RequestMapping(value="entity", method=RequestMethod.POST)

public @ResponseBody String withEntity(

HttpEntity<String> entity) {

return "Posted request body " + entity.getBody() + "

headers = " + entity.getHeaders();

}

如上写法：了解

<![if !supportLists]>4.<![endif]>Spring MVC 响应处理

<![if !supportLists]>4.1.        <![endif]>响应数据封装

<![if !supportLists]>4.1.1.    <![endif]>Servlet API 对象（了解）

将请求数据直接封装到Request 对象

@RequestMapping("doResponse01")

public String doResponse01(HttpServletRequest request) {

request.setAttribute("data", "hello..");

return"response";

}

在response.jsp页面可以直接借助${data}方式获取数据。

当方法中直接返回一个页面时，默认执行的是请求转发，假如需要实现重定向,

可以在返回的地址后添加redirect,例如

return "redirect:responseUI.do"; 其中responseUI.do对应一个请求url.

@RequestMapping("doResponse02")

public String doResponse02(HttpServletRequest request) {

request.setAttribute("data", "hello..");

return"redirect:responseUI.do";

}

在如上方法中可以重定向到一个responseUI对应的新的URL。

@RequestMapping("responseUI")

public String responseUI() {

return"response";

}

在新的请求中不能直接获取上一个请求作用域的数据。

回顾请求转发与重定向：

1）请求转发(forward)

<![if !vml]><![endif]>

<![if !supportLists]>3)  <![endif]>重定向(redirect)

<![if !vml]><![endif]>

课堂练习：

例如: 将响应数据封装1到Session,然后在客户端获取作用域数据

@RequestMapping("doResponse03")

public String doResponse03(HttpSession session) {

session.setAttribute("data", "map..");

return"response";

}

<![if !supportLists]>4.1.2.    <![endif]>ModelAndView对象（重点）

在对服务端响应数据进行封装时,可以直接在方法参数中定义一个ModelAndView类型的参数,借助ModelAndView对象封装响应数据.

@RequestMapping("doModelAndView")

public ModelAndView doModelAndView(ModelAndView mv) {

//ModelAndView mv=new ModelAndView();

mv.addObject("data", "model and view");

mv.setViewName("response");//view

returnmv;

}

提示:ModelAndView 对象由Spring创建,并可以将数据存储到ModelAndView对象的ModalMap类型的属性中(可参考源代码).

<![if !supportLists]>4.1.3.    <![endif]>Model对象（重点）

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

@RequestMapping("doModel")

public String doModel(Model model) {

model.addAttribute("data", "modal");

return"response";

}

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

<![if !supportLists]>4.1.4.    <![endif]>Map对象（了解）

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

@RequestMapping("doMap01")

public String doMap01(Map<String,Object> map) {

map.put("data", "map..");

return"response";

}

<![if !supportLists]>4.2.        <![endif]>响应数据转换JSON（重点）

<![if !supportLists]>4.2.1.    <![endif]>JSON 应用概述

JSON(JavaScript Object Notation):一种轻量级数据交换格式,通常作为客户端与服务端进行数据交互的一种标准。

企业级Java项目数据传输方式：

<![if !vml]><![endif]>

reponse.getWriter().write(jsonStr);

客户端访问服务端时，服务器从数据库取出数据进行封装，然后再将对象转换为json串，通过网络传输到客户端。

<![if !supportLists]>4.2.2.    <![endif]>Spring 集成jackson库

spring 中默认支持jackson应用的，但使用时需要添加jackson依赖，例如

<dependency>

<groupId>com.fasterxml.jackson.core</groupId>

<artifactId>jackson-databind</artifactId>

<version>2.8.5</version>

</dependency>

创建Controller中例如ResponseController，然后在类中添加对应方法。例如

将Map对象内容转换为字符串（spring底层会直接访问jackson api将对象转换为字符串）

@RequestMapping("doMap")

@ResponseBody

public Map<String,Object> doMap(){

Map<String,Object> map=

new HashMap<>();

map.put("id", 100);

map.put("name", "AAA");

returnmap;

}

将JavaBean对象转换为JSON串

@RequestMapping("doUser")

@ResponseBody

public SysLog doLog(){

SysLog log=new SysLog ();

log.setId(100);

log.setUsername("CCC");

log.setIP("192.168.1.12");

returnlog;

}

将Java List集合转换为JSON串。

@RequestMapping("doList")

@ResponseBody

public List<SysLog> doList(){

List<SysLog> list=new ArrayList<>();

SysLog log=new SysLog ();

log.setId(100);

log.setUsername("CCC");

log.setIP("192.168.1.12");

list.add(log);

log=new SysLog ();

log.setId(100);

log.setUsername("CCC");

log.setIP("192.168.1.12");

list.add(log);

returnlist;

}

备注：将来controller中数据来自服务端数据。

<![if !supportLists]>5.<![endif]>总结

<![if !supportLists]>5.1.        <![endif]>重点和难点分析

<![if !supportLists]>1.   <![endif]>Spring MVC 组件的核心架构及基本组件?

<![if !supportLists]>2.   <![endif]>Spring MVC 请求响应流程分析?

<![if !supportLists]>5.2.        <![endif]>课后必须完成作业

<![if !supportLists]>1.   <![endif]>总结课堂知识点

<![if !supportLists]>2.   <![endif]>熟练掌握spring MVC项目的创建及基本配置

<![if !supportLists]>3.   <![endif]>强化理解spring MVC中请求和响应数据的处理

<![if !supportLists]>5.3.        <![endif]>课后扩展作业

思考：如何使用Spring 集成fastjson库（阿里巴巴的高性能JSON库）

spring 中默认不支持fastjson api直接将java对象转换为json串，假如需要使用fastjson实现对象的转换，现阶段我们需要手动进行转换。

Step01：项目中添加fastjson依赖

<dependency>

<groupId>com.alibaba</groupId>

<artifactId>fastjson</artifactId>

<version>1.2.38</version>

</dependency>

Step02: 配置fastjson为默认json转换器

<mvc:annotation-driven>

<!--设置fastjson的转换器对象 -->

<mvc:message-converters register-defaults="true">

<bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">

<property name="supportedMediaTypes">

<list>

<value>text/html;charset=utf-8</value>

<value>application/json;charset=utf-8</value>

</list>

</property>

</bean>

</mvc:message-converters>

</mvc:annotation-driven>

Step03: 应用fastjson,控制层的方法可以直接返回javabean或对应的map对象

@RequestMapping("doRespJSON01")

@ResponseBody

public Map<String,Object> doRespJSON01(){

Map<String,Object> map=

new HashMap<String, Object>();

map.put("id", 100);

map.put("name","tmooc");

returnmap;

}

访问对象方法此时方法的返回对象会由FastJsonHttpMessageConverter对象转换为JSON格式的字符串.

 

原文地址：https://www.cnblogs.com/wood-life/p/10291801.html

时间： 2024-07-28 22:31:09

Spring MVC 编程基础的相关文章

Spring MVC之基础知识：HTTP

故事还得从30年前的某个夜晚说起......这是我们经常在电视里看到的经典台词.借用一下,对于Spring MVC,我们还得从HTTP协议说起. HTTP协议 HTTP协议是一个应用层.基于请求/响应模型.无状态的协议.无状态意味着每个请求都是独立的,换而言之,各个请求之间如果需要互相传递信息,协议本身是无法帮我们完成的.这就是为什么需要额外的技术用于保存请求之间的状态,例如:cookie在客户端保存某些状态信息或是session在服务器保存状态信息. 统一资源定位符(URL) 统一资源定位符(

Spring MVC　基础

Spring MVC 项目案件见附件 导包 配置web.xml启动Spring MVC<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http

Spring MVC的基础知识

web服务器每天24小时不间断运行,并等待HTTP客户端(通常是Web浏览器)来连接并请求资源.通常,客户端发起一个连接,服务端不会主动连接客户端.(其实服务端可以通过WebSocket协议主动发起同客户端的会话通信) 一台计算机可以托管不止一个域名,因此,不同的域名可能指向同一个IP.(IP才是计算机的真实存在) HTTP请求头信息和请求正文用一行空行分隔,HTTP服务器根据此判断请求正文的起始位置.因此,在一些关于互联网的书籍中,CRLF被称为HTTP请求的第四种组件. CGI技术为每一个请

Spring MVC框架搭建

Spring MVC篇一.搭建Spring MVC框架 本项目旨在搭建一个简单的Spring MVC框架,了解Spring MVC的基础配置等内容. 一.项目结构 本项目使用idea intellij创建,配合maven管理.整体的目录结构如图: 其中java文件夹是sources文件夹,resources是资源文件夹.spring文件夹里是Spring上下文配置和Spring MVC配置文件. 需要注意的是,项目自动生成以后会有两个web文件目录,一个是web文件夹(我这里已经删除了),另一个

Spring MVC篇一、搭建Spring MVC框架

本项目旨在搭建一个简单的Spring MVC框架,了解Spring MVC的基础配置等内容. 一.项目结构 本项目使用idea intellij创建,配合maven管理.整体的目录结构如图: 其中java文件夹是sources文件夹,resources是资源文件夹.spring文件夹里是Spring上下文配置和Spring MVC配置文件. 需要注意的是,项目自动生成以后会有两个web文件目录,一个是web文件夹(我这里已经删除了),另一个是默认的webapp文件夹.我这里使用默认的目录,也就是

玩转Spring MVC(三)----spring基本配置文件

这篇文章总结一下spring mvc的基本配置,首先贴一张我的项目的目录截图,有一些多余的文件,大家不必在意: 用到的一些jar包在这:<a>http://download.csdn.net/detail/u012116457/8426199</a> 接下来是web.xml的配置: <?xml version="1.0" encoding="UTF-8"?> <web-app version="3.0"

Spring MVC 基础

Spring MVC 基础 1.Web MVC基础 MVC的本质是表现层模式,我们以视图模型为中心,将视图和控制器分离出来.就如同分层模式一样,我们以业务逻辑为中心,把表现层和数据访问层代码分离出来是一样的方法.框架只能在技术层面上给我们帮助,无法在思考和过程上帮助我们,而我们很多人都不喜欢思考和尝试. 2.实现Web MVC的基础 实现Web MVC基础可以概括为1个前段控制器和2个映射. (1)前端控制器FrontController ASP.NET和JSP都是以Page路径和URL一一对应

Extjs5.0从入门到实战开发信息管理系统（Extjs基础、Extjs5新特性、Spring、Spring mvc、Mybatis）视频教程

Extjs5.0从入门到实战开发信息管理系统(Extjs基础.Extjs5新特性.Spring.Spring mvc.Mybatis)视频教程下载   联系QQ:1026270010 Extjs作为一款优秀的JS前端开发框架以其良好的架构.丰富的UI组件库.完善的文档和社区支持等诸多优点拥有广泛的市场应用空间,开发人员无需过多的关注HTML.CSS甚至各种常用JS算法,只需把精力放在业务逻辑上,利用各种组件的相互组合调用便可轻松而高效的开发出系统的前端页面. Extjs5在之前版本的基础上又推出

Spring MVC 基础篇 1

Spring MVC基础篇  @RequestMapping使用 [email protected]RequestMapping 注解 进行请求映射 (1)指定Controller或者Method可以处理那些url请求. (2)适用范围:类定义上或者方法定义上都可以加. (3)在类定义处添加该注解是相对于WEB应用的根目录,在方法处是对类定义的请求处理的进一步细化.可以在类定义上没有添加该注解,但是方法定义上有该注解,此时 方法处的该注解标记的URL就是相对于WEB应用根目录. (4) 思考:此