0%

SpringMVC学习日志

SpringMVC简介

Spring MVC是当前最优秀的MVC框架,自从Spring 2.5版本发布后,由于支持注解配置,易用性有了大幅度的提高。Spring 3.0更加完善,实现了对Struts 2的超越。现在越来越多的开发团队选择了Spring MVC。
Spring3 MVC的优点:

1、Spring3 MVC使用简单,学习成本低。学习难度小于Struts2,Struts2用不上的多余功能太多。呵呵,当然这不是决定因素。

2、Spring3 MVC很容易就可以写出性能优秀的程序,Struts2要处处小心才可以写出性能优秀的程序(指MVC部分)

3、Spring3 MVC的灵活是你无法想像的,Spring框架的扩展性有口皆碑,Spring3 MVC当然也不会落后,不会因使用了MVC框架而感到有任何的限制。

SpringMVC的maven配置:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-framework-bom</artifactId>
<version>4.3.9.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>

</dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
</dependency>
</dependencies>

配置web.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<!-- 设置根上下文配置文件,与Spring Core容器有关 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:application-context.xml</param-value>
</context-param>

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

<!-- 前端控制器:导演,注册DispatcherServlet-->
<servlet>
<servlet-name>servlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<!-- 初始化参数 -->
<param-name>contextConfigLocation</param-name>
<param-value>classpath:application-servlet.xml</param-value>
</init-param>
</servlet>

<!-- 将注册的DispatcherServlet映射到'/' -->
<servlet-mapping>
<servlet-name>servlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>

配置视图解析器:
1
2
3
4
5
6
7
8
9
10
11
<!--配置JSP视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/views/"/>
<property name="suffix" value=".jsp"/>
</bean>


<!-- 扫描包 control -->
<context:component-scan base-package="com.xpu.springmvc.control"/>
<!-- 启用注解SpringMVC -->
<mvc:annotation-driven/>

一个示例Controller:
1
2
3
4
5
6
7
8
9
10
@Controller
@RequestMapping
public class IndexController {
@RequestMapping(value = {"","/index"}, method = {RequestMethod.GET})
public ModelAndView hello(){
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("welcome");//WEB-INFO/views/welcome.jsp
return modelAndView;
}
}

SpringMVC涉及的元素

mark
模型-视图-控制器(MVC模式)是一种非常经典的软件架构模式,在UI框架和UI设计思路中扮演着非常重要的角色。从设计模式的角度来看,MVC模式是一种复合模式,它将多个设计模式在一种解决方案中结合起来,用来解决许多设计问题。MVC模式把用户界面交互分拆到不同的三种角色中,使应用程序被分成三个核心部件: Model(模型)、View(视图)、Control(控制器) ,它们各自处理自己的任务:

(1)模型:模型持有所有的数据、状态和程序逻辑;模型独立于视图和控制器。
(2)视图:用来呈现模型。视图通常直接从模型中取得它需要显示的状态与数据。对于相同的信息可以有多个不同的显示形式或视图。
(3)控制器:位于视图和模型中间,负责接受用户的输入,将输入进行解析并反馈给模型,通常一个视图具有一个控制器。
mark
MVC模式将它们分离以提高系统的灵活性和复用性,不使用MVC模式,用户界面设计往往将这些对象混在一起。 MVC模式实现了模型和视图的分离,这带来了几个好处:
(1)一个模型提供不同的多个视图表现形式,也能够为一个模型创建新的视图而无须重写模型。一旦模型的数据发生变化,模型将通知有关的视图,每个视图相应地刷新自己。
(2)模型可复用。因为模型是独立于视图的,所以可以把一个模型独立地移植到新的平台工作。
(3)提高开发效率。在开发界面显示部分时,你仅仅需要考虑的是如何布局一个好的用户界面;开发模型时,你仅仅要考虑的是业务逻辑和数据维护。这样能使开发者专注于某一方面的开发,提高开发效率。

Servlet请求响应

Servlet对应的就是MVC框架模式中的控制器。Servlet负责在处理用户请求和响应,其中数据的处理,页面响应都是在Servlet里面完成的。如下图是Servlet请求响应示意图:
mark

SpringMVC请求响应

mark
上面这张图是SpringMVC请求处理的比较高层次的流程图(隐含了更多细节),从图上看它与Servlet处理请求的最大不同在于,它将视图渲染,请求处理,模型创建分离了。即遵循了MVC框架模式的基本思想。
mark
上图是将高层次的流程图细化到SpringMVC框架的具体实现上了,通过上图我们可以看出,SpringMVC的请求响应经过的7个阶段。其中2-6阶段分别对应着SpringMVC框架中的几个概念,分别是:前端控制器,处理映射器,控制器(处理器),视图解析器,视图。图中绿色部分是用户需要实现的内容

核心类的请求流程

mark
第一步:(发起)发起请求到前端控制器(DispatcherServlet)
第二步:(查找)前端控制器请求HandlerMapping查找 Handler(可以根据xml配置、注解进行查找)
第三步:(返回)处理器映射器HandlerMapping向前端控制器返回Handler,HandlerMapping会把请求映射为HandlerExecutionChain对象(包含一个Handler处理器(页面控制器)对象,多个HandlerInterceptor拦截器对象),通过这种策略模式,很容易添加新的映射策略
第四步:(调用)前端控制器调用处理器适配器去执行Handler
第五步:(执行)处理器适配器HandlerAdapter将会根据适配的结果去执行Handler
第六步:(返回)Handler执行完成给适配器返回ModelAndView
第七步:(接收)处理器适配器向前端控制器返回ModelAndView (ModelAndView是SpringMVC框架的一个底层对象,包括 Model和view)
第八步:(解析)前端控制器请求视图解析器去进行视图解析 (根据逻辑视图名解析成真正的视图(jsp)),通过这种策略很容易更换其他视图技术,只需要更改视图解析器即可
第九步:(返回)视图解析器向前端控制器返回View
第十步:(渲染)前端控制器进行视图渲染 (视图渲染将模型数据(在ModelAndView对象中)填充到request域)
第十一步:(响应)前端控制器向用户响应结果

SpringMVC核心组件(后续补充的)

DispatcherServlet 控制器入口 负责分发请求 (前置控制器)
HandlerMapping 负责根据请求 找到对应的控制器(将请求映射到Handler)
Handler 后端控制器
HandlerInterceptor 处理器拦截器
HandlerExecution 处理器执行链
HandlerAdapter 处理器适配器
ViewResolver 视图处理器 通过处理找到对应的页面
ModelAndView 封装数据信息和视图信息的
Controller 真正处理请求的控制器

mark

SpringMVC的xml配置方式

springmvc.xml配置如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<!-- 配置HandlerMapping-->
<bean id="handlerMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">

<!-- 配置Mapping -->
<property name="mappings">
<props>
<prop key="/test">testHandler</prop>
</props>
</property>
</bean>

<!-- 配置Handler -->
<bean id="testHandler" class="com.xpu.maven.MyHandler">
</bean>

<!-- 配置视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 前缀-->
<property name="prefix" value="/"></property>
<!-- 配置后缀-->
<property name="suffix" value=".jsp"></property>
</bean>

web.xml配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
<web-app>
<display-name>Archetype Created Web Application</display-name>

<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<!--要使用的字符集,一般我们使用UTF-8(保险起见UTF-8最好)-->
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<!--是否强制设置request的编码为encoding,默认false,不建议更改-->
<param-name>forceRequestEncoding</param-name>
<param-value>false</param-value>
</init-param>
<init-param>
<!--是否强制设置response的编码为encoding,建议设置为true,下面有关于这个参数的解释-->
<param-name>forceResponseEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 配置文件的路径 -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
<!-- 这个配置servlet-mapping主要是为了防止SpringMVC阻止了css文件请求 -->
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.css</url-pattern>
</servlet-mapping>

<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>

MyHandler.java
1
2
3
4
5
6
7
8
9
10
public class MyHandler implements Controller {
@Override
public ModelAndView handleRequest(HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse) throws Exception {
//装载模型数据
ModelAndView modelAndView = new ModelAndView();
modelAndView.addObject("name", "Tim");
modelAndView.setViewName("show");
return modelAndView;
}

pom.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
<properties>
<encoding>UTF-8</encoding>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>


<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
</dependency>
<!-- JSTL -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!-- JSTL实现包 -->
<dependency>
<groupId>org.apache.taglibs</groupId>
<artifactId>taglibs-standard-impl</artifactId>
<version>1.2.5</version>
</dependency>
<dependency>

<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.1.5.RELEASE</version>

</dependency>

<!-- 接收JSON数据shi时才使用 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.8</version>
</dependency>
</dependencies>

SpringMVC的数据绑定

设计一个课程类Course和一些其他的JavaBean:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//课程类
public class Course {
private int id;
private String name;
private double price;
}
//讲师类
public class Author {
private int id;
private String name;
}
//课程类的集合类
public class CourseList {
List<Course> list;
}
//课程类的集合类
public class CourseMap {
private Map<String, Course> courseMap;
}

//课程类的集合类
public class CourseSet {
private Set<Course> courseSet = new HashSet<>();

public Set<Course> getCourseSet() {
return courseSet;
}

public void setCourseSet(Set<Course> courseSet) {
this.courseSet = courseSet;
}

//主要是为了完成绑定
public CourseSet(){
courseSet.add(new Course());
courseSet.add(new Course());
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
/**
* 基本类型
*/
@RequestMapping(value = "/baseType")
@ResponseBody
public String baseType(@RequestParam(value = "id", required = false) int id){
return "baseType id:"+id;
}

/**
* 包装类类型
*/
@RequestMapping(value = "/packageType")
@ResponseBody
public String packageType(@RequestParam(value = "id") Integer id){
return "packageType id:"+id;
}

/**
* 数组类型
*/
@RequestMapping(value = "/arrayType")
@ResponseBody
public String arrayType(String[] name){
StringBuffer sb = new StringBuffer();
for(String item: name){
sb.append(item);
}
return sb.toString();
}

/**
* 对象类型
*/
@RequestMapping("/pojoType")
public ModelAndView pojoType(Course course){
ModelAndView view = new ModelAndView();
courseDao.add(course);
view.setViewName("index");
view.addObject("courses", courseDao.getAll());

return view;
}

/**
* 对象list集合
*/
@RequestMapping("/listType")
public ModelAndView listType(CourseList courseList){
for(Course course : courseList.getList()){
courseDao.add(course);
}
ModelAndView view = new ModelAndView();
view.setViewName("index");
view.addObject("courses", courseDao.getAll());
return view;
}

/**
* 对象map集合
*/
@RequestMapping("/mapType")
public ModelAndView mapType(CourseMap courseMap){
//遍历的是Key
for(String key: courseMap.getCourseMap().keySet()){
Course course = courseMap.getCourseMap().get(key);
courseDao.add(course);
}
ModelAndView view = new ModelAndView();
view.setViewName("index");
view.addObject("courses", courseDao.getAll());
return view;
}

/**
* 对象set集合
*/
@RequestMapping("/setType")
public ModelAndView setType(CourseSet courseSet){
//遍历的是Key
for(Course course: courseSet.getCourseSet()){
courseDao.add(course);
}
ModelAndView view = new ModelAndView();
view.setViewName("index");
view.addObject("courses", courseDao.getAll());
return view;
}

/**
* JSON数据类型
*/
@RequestMapping(value = "jsonType")
@ResponseBody
public Course jsonType(@RequestBody Course course){
course.setPrice(course.getPrice()+100);
return course;
}

想要支持JSON数据格式:
springmvc.xml配置:

1
2
3
4
5
6
<mvc:annotation-driven>
<mvc:message-converters>
<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
</bean>
</mvc:message-converters>
</mvc:annotation-driven>

pom.xml
1
2
3
4
5
6
<!-- 接收JSON数据时才使用 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.8</version>
</dependency>

需要注意的地方就是在接收为Set对象集合的时候需要先:
mark
在接收JSON数据的时候别忘了导入jar包,并且在springmvc.xml文件中配置!
级联属性的设定写法:
mark
还有在JSP中配置需要的配置项,方便EL表达式的使用!

1
2
3
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page isELIgnored="false" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
  • 本文作者: Tim
  • 本文链接: https://zouchanglin.cn/2595086645.html
  • 版权声明: 本博客所有文章除特别声明外,均采用 BY-NC-SA 许可协议。转载请注明出处!