0%

SpringMVC

SpringMVC的基本概念

关于三层架构和MVC

三层架构

  • 开发服务器端的程序,一般都是基于两种形式,分别叫做B/S即浏览器服务器,和C/S即客户端服务器。
  • 使用Java语言基本上都是开发B/S架构的程序,B/S架构又分成了三层架构
  • 三层架构:
    • 表现层:WEB层,用来和客户端进行交互的,表现层一般会使用MVC的设计模型
    • 业务层:处理公司具体的业务逻辑
    • 持久层:用来操作数据库

MVC模型

  • MVC全名是Model View Controller模型视图控制器,每个部分各司其职。
  • Model:数据模型,Java Bean的类,用来进行数据封装
  • View: 指JSP、HTML等用来展示数据给用户
  • Controller: 用来接受用户的请求,整个流程的控制器。用来进行数据校验等。

三层架构

SpringMVC的入门案例

SpringMVC的概述

  • SpringMVC的概述:
    • 是一种基于Java程序实现的MVC设计模型的请求驱动类型的轻量级WEB框架
    • 属于SpringFrameworks的后续产品,现在已经融合在Spring Web Flow里面。提供了构建Web应用程序的全功能MVC模块
    • 使用Sprint可插入MVC架构从而使使用Spring进行WEB开发时,可以选择使用Spring的SpringMVC框架或者集成其他MVC框架
  • SpringMVC框架在三层架构中的位置:表现层框架
  • SpringMVC框架的优势

SpringMVC的入门程序

创建WEB工程,引入JAR包

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
  
<!-- 版本锁定 --> <properties>
<spring.version>5.0.2.RELEASE</spring.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.0</version>
<scope>provided</scope>
</dependency>
</dependencies>

配置核心的控制器(配置DispatcherServlet)

在web.xml配置文件中核心控制器DispatcherServlet

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!-- SpringMVC的核心控制器 --> <servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-
class>
<!-- 配置Servlet的初始化参数,读取springmvc的配置文件,创建spring容器 --> <init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!-- 配置servlet启动时加载对象 -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>

编写springmvc.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
 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 配置spring创建容器时要扫描的包 -->
<context:component-scan base-package="com.itheima"></context:component-scan>
<!-- 配置视图解析器 -->
<bean id="viewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/pages/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
<!-- 配置spring开启注解mvc的支持
<mvc:annotation-driven></mvc:annotation-driven>-->
</beans>

编写index.jsp

1
2
3
4
5
 
<body>
<h3>入门案例</h3>
<a href="${ pageContext.request.contextPath }/hello">入门案例</a>
</body>

HelloController控制器类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 package cn.itcast.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* 控制器
* @author rt */
@Controller
public class HelloController {
/**
* 接收请求 * @return */
@RequestMapping(path="/hello")
public String sayHello() {
System.out.println("Hello SpringMVC!!");
return "success";
}
}

在WEB-INF目录下创建pages文件夹,编写success.jsp的成功页面

1
2
3
<body>
<h3>入门成功!!</h3>
</body>

入门案例的执行过程分析

  1. 入门案例的执行流程

    1. 当启动tomcat服务器的时候因为配置了load-on-start标签,所以会创建dispatchServlet对象,就会加载Springmvc.xml配置文件
    2. 开启了注解扫描,那么hello controller就会被创建
    3. 从index.jsp发送请求,请求会首先到达DispatchServlet核心控制器,再根据配置@PequestMapping注解找到执行的具体方法
    4. 根据执行方法的返回值,再根据配置试图解析器,去指定的目录下寻找jsp文件
    5. Tomcat服务器响应

    MVC执行过程

  2. 入门案例中的组件分析

    1. 前端控制器(DispatcherServlet)
    2. 处理器映射器(HandlerMapping)
    3. 处理器(Handler)
    4. 处理器适配器(HandlAdapter)
    5. 视图解析器(View Resolver)
    6. 视图(View)
  3. RequestMapping注解

    1. RequestMapping注解的作用是建立请求URL和处理方法之间的对应关系
    2. RequestMapping注解可以作用在方法和类上
      1. 作用在类上:第一级的访问目录
      2. 作用在方法上:第二级的访问目录
      3. 细节:路径可以不编写 / 表示应用的根目录开始
      4. 细节:${ pageContext.request.contextPath }也可以省略不写,但是路径上不能写 /
    3. RequestMapping的属性
      1. path : 默认
      2. value
      3. mthod
      4. params
      5. headers 发送的请求中必须包含的请求头

请求参数的绑定

请求参数的绑定说明

  • 绑定机制

    • 表单提交的数据都是k-v格式的 username=xiaomei&password=123
    • Spring MVC的参数绑定过程及欧式把表单提交的请求参数,作为控制器中的方法的参数来进行绑定
    • 要求是:提交表单的name和参数的名称是一样的
  • 支持的数据类型

    • 基本数据类型和字符串类型
    • 实体类型:那么与属性名称一致,假如包含其他引用类型,则写成对象.属性的方式:address.name
    • 集合数据类型(List、Map集合等) JSP页面编写方式:list[0].属性
    • 基本数据类型和字符串数据类型区分大小写
  • 解决中文乱码的问题

    • 在web.xml中配置Spring提供的过滤器类
1
2
3
4
5
6
7
8
9
10
11
12
13
<!-- 配置过滤器,解决中文乱码的问题 --> <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>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
  • 自定义类型转换器
    • 表单中提交的任何数据类型全部都是字符串类型,但是 后台定义的Integer类型也能封装上,说明Spring框架内会进行默认的数据类型转换
    • 如果想要自定义数据类型转化,可以实现Converter的接口
      • 自定义类型转换器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package cn.itcast.utils;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.core.convert.converter.Converter;
/**
* 把字符串转换成日期的转换器 * @author rt
*/
public class StringToDateConverter implements Converter<String, Date>{
/**
* 进行类型转换的方法 */
public Date convert(String source) { // 判断
if(source == null) {
throw new RuntimeException("参数不能为空");
}
try {
DateFormat df = new SimpleDateFormat("yyyy-MM-dd"); // 解析字符串
Date date = df.parse(source);
return date;
} catch (Exception e) {
throw new RuntimeException("类型转换错误");
}}
}

注册自定义类型转换器,在springmvc.xml配置文件中编写配置

1
2
3
4
5
6
7
8
9
10
11
12
 
<!-- 注册自定义类型转换器 -->
<bean id="conversionService"
class="org.springframework.context.support.ConversionServiceFactoryBean">
<property name="converters">
<set>
<bean class="cn.itcast.utils.StringToDateConverter"/>
</set>
</property>
</bean>
<!-- 开启Spring对MVC注解的支持 -->
<mvc:annotation-driven conversion-service="conversionService"/>

在控制器中使用原生的ServletAPI对象:只需要在控制器的方法参数定义HttpServletRequest和HttpServletResponse对象

常用的注解

@RequestParam注解

  • 作用:把请求中的指定名称的参数传递给控制器中的形参赋值

  • 属性:

    • value:请求参数中的名称
    • required:请求参数中是否必须提供此参数,默认值是true,必须提供
  • 代码

    1
    2
    3
    4
    5
    6
    7
    8
     /**
    * 接收请求 * @return */
    @RequestMapping(path="/hello")
    public String sayHello(@RequestParam(value="username",required=false)String name) {
    System.out.println("aaaa");
    System.out.println(name);
    return "success";
    }

@RequestBody注解

  • 作用:用于获取请求体的内容(注意:get方法不可以)

  • 属性

  • required:是否必须有请求体,默认值是true

  • 代码

    1
    2
    3
    4
    5
    6
    7
    8
     /**
    * 接收请求 * @return */
    @RequestMapping(path="/hello")
    public String sayHello(@RequestBody String body) {
    System.out.println("aaaa");
    System.out.println(body);
    return "success";
    }

@PathVariable注解

  • 作用:拥有绑定url中的占位符的。例如:url中有/delete/{id},{id}就是占位符

  • 属性

  • value:指定url中的占位符名称

  • Restful风格的URL

    • 请求路径一样,可以根据不同的请求方式去执行后台的不同方法
    • restful风格的URL优点
      • 结构清晰
      • 符合标准
      • 易于理解
      • 扩展方便
  • 代码如下

    1
    2
    3
    4
    5
    6
    7
    8
     <a href="user/hello/1">入门案例</a>
    /**
    * 接收请求 * @return */
    @RequestMapping(path="/hello/{id}")
    public String sayHello(@PathVariable(value="id") String id) {
    System.out.println(id);
    return "success";
    }

@RequestHeader注解

  • 作用:获取请求头的值

  • 属性

    • value:请求头的名称
  • 代码

    1
    2
    3
    4
    5
    @RequestMapping(path="/hello")
    public String sayHello(@RequestHeader(value="Accept") String header) {
    System.out.println(header);
    return "success";
    }

CookieValue注解

1
2
3
4
5
 @RequestMapping(path="/hello")
public String sayHello(@CookieValue(value="JSESSIONID") String cookieValue) {
System.out.println(cookieValue);
return "success";
}

ModelAttribute注解

1
2
3
4
5
6
7
8
9
10
11
12
@ModelAttribute
public User showUser(String name) {
System.out.println("showUser执行了..."); // 模拟从数据库中查询对象
User user = new User(); user.setName("哈哈");
user.setPassword("123"); user.setMoney(100d);
return user;
}
@RequestMapping(path="/updateUser")
public String updateUser(User user) {
System.out.println(user);
return "success";
}
1
2
3
4
5
6
7
8
9
10
11
@ModelAttribute
public void showUser(String name,Map<String, User> map) {
System.out.println("showUser执行了..."); // 模拟从数据库中查询对象
User user = new User(); user.setName("哈哈"); user.setPassword("123"); user.setMoney(100d);
map.put("abc", user);
}
@RequestMapping(path="/updateUser")
public String updateUser(@ModelAttribute(value="abc") User user) {
System.out.println(user);
return "success";
}

SessionAttributes注解

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
@Controller
@RequestMapping(path="/user")
@SessionAttributes(value= {"username","password","age"},types=
{String.class,Integer.class})
public class HelloController {
/**
* 向session中存入值 * @return
*/
// 把数据存入到session域对象中
@RequestMapping(path="/save")
public String save(Model model) {
System.out.println("向session域中保存数据");
model.addAttribute("username", "root");
model.addAttribute("password", "123");
model.addAttribute("age", 20);
return "success";
}
@RequestMapping(path="/find")
public String find(ModelMap modelMap) {
String username = (String) modelMap.get("username");
String password = (String) modelMap.get("password");
Integer age = (Integer) modelMap.get("age");
System.out.println(username + " : "+password +" : "+age);
return "success";
}

@RequestMapping(path="/delete")
public String delete(SessionStatus status) {
status.setComplete();
return "success";
}

Controller响应数据和结果试图

返回值分类

返回字符串

Controller方法返回字符串可以指定逻辑视图的名称,根据视图解析器为物理视图的地址

1
2
3
4
5
@RequestMapping(value="/hello")
public String sayHello() {
System.out.println("Hello SpringMVC!!"); // 跳转到XX页面
return "success";
}

响应的数据:使用model.addAttribute("user", user)

1
2
3
4
5
6
7
8
9
   @RequestMapping(value="/initUpdate")
public String initUpdate(Model model) {
// 模拟从数据库中查询的数据
User user = new User(); user.setUsername("张三");
user.setPassword("123"); user.setMoney(100d);
user.setBirthday(new Date());
model.addAttribute("user", user);
return "update";
}
1
2
3
4
5
6
7
8
9
<h3>修改用户</h3>
${ requestScope }
<form action="user/update" method="post">

姓名:<input type="text" name="username" value="${ user.username }">
<br> 密码:<input type="text" name="password" value="${ user.password }">
<br> 金额:<input type="text" name="money" value="${ user.money }">
<br> <input type="submit" value="提交">
</form>

返回值是void

如果控制器的方法返回值编写成void,会自动跳转到方法名所在的JSP页面-@RequestMapping(value=”/initUpdate”) initUpdate的页面。

可以请求转发或者重定向到指定的页面

1
2
3
4
5
6
7
8
9
10
11
@RequestMapping(value="/initAdd")
public void initAdd(HttpServletRequest request,HttpServletResponse response) throws Exception {
System.out.println("请求转发或者重定向");
// 请求转发
// request.getRequestDispatcher("/WEBINF/pages/add.jsp").forward(request,response);
// 重定向
// response.sendRedirect(request.getContextPath()+"/add2.jsp");
response.setCharacterEncoding("UTF-8");
response.setContentType("text/html;charset=UTF-8");
// 直接响应数据 response.getWriter().print("你好"); return;
}

返回值是ModelAndView对象 ModelAndView对象是Spring提供的一个对象,可以用来调整具体的JSP视图

1
2
3
4
5
6
7
8
9
10
11
12
13
@RequestMapping(value="/findAll")
public ModelAndView findAll() throws Exception {
ModelAndView mv = new ModelAndView();
// 跳转到list.jsp的页面 mv.setViewName("list");
// 模拟从数据库中查询所有的用户信息 List<User> users = new ArrayList<>(); User user1 = new User(); user1.setUsername("张三"); user1.setPassword("123");
User user2 = new User();
user2.setUsername("赵四");
user2.setPassword("456");
users.add(user1);
users.add(user2);
// 添加对象 mv.addObject("users", users);
return mv;
}

SpringMVC框架提供的转发和重定向

forward请求转发

controller方法返回String类型,想进行请求转发也可以编写成return "forward:/user/findAll"

1
2
3
4
5
6
7
8
9
10
11
12
 
/**
* 使用forward关键字进行请求转发
* "forward:转发的JSP路径",不走视图解析器了,所以需要编写完整的路径 * @return
* @throws Exception
*/
@RequestMapping("/delete")
public String delete() throws Exception {
System.out.println("delete方法执行了...");
// return "forward:/WEB-INF/pages/success.jsp";
return "forward:/user/findAll";
}

redirect重定向

controller方法返回String类型,想进行重定向也可以编写成return "redirect:/add.jsp"

1
2
3
4
5
6
7
8
9
10
 /**
* 重定向
* @return
* @throws Exception */
@RequestMapping("/count")
public String count() throws Exception {
System.out.println("count方法执行了...");
return "redirect:/add.jsp";
// return "redirect:/user/findAll";
}

ResponseBody响应json数据

DispatcherServlet会拦截到所有的资源,导致一个问题就是静态资源(img、css、js)也会被拦截到,从而

不能被使用。解决问题就是需要配置静态资源不进行拦截,在springmvc.xml配置文件添加如下配置

1
2
3
4
<!-- 设置静态资源不过滤 -->
<mvc:resources location="/css/" mapping="/css/**"/> <!-- 样式 -->
<mvc:resources location="/images/" mapping="/images/**"/> <!-- 图片 -->
<mvc:resources location="/js/" mapping="/js/**"/> <!-- javascript -->

json字符串和JavaBean对象互相转换的过程中,需要使用jackson的jar包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.9.0</version>
</dependency>

使用@RequestBody获取请求体数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$(function(){
// 绑定点击事件 $("#btn").click(function(){
$.ajax({
url:"user/testJson",
contentType:"application/json;charset=UTF-8",
data:'{"addressName":"aa","addressNum":100}',
dataType:"json",
type:"post",
success:function(data){
alert(data);
alert(data.addressName);
}
}); });
});
1
2
3
4
5
6
* 获取请求体的数据 * @param body
*/
@RequestMapping("/testJson")
public void testJson(@RequestBody String body) {
System.out.println(body);
}

使用@RequestBody注解把json的字符串转换成JavaBean的对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$(function(){
// 绑定点击事件 $("#btn").click(function(){
$.ajax({
url:"user/testJson",
contentType:"application/json;charset=UTF-8",
data:'{"addressName":"aa","addressNum":100}',
dataType:"json",
type:"post",
success:function(data){
alert(data);
alert(data.addressName);
}
}); });
});
1
2
3
4
5
6
7
/**
* 获取请求体的数据 * @param body
*/
@RequestMapping("/testJson")
public void testJson(@RequestBody Address address) {
System.out.println(address);
}

使用@ResponseBody注解把JavaBean对象转换成json字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$(function(){
// 绑定点击事件 $("#btn").click(function(){
$.ajax({
url:"user/testJson",
contentType:"application/json;charset=UTF-8",
data:'{"addressName":"哈哈","addressNum":100}',
dataType:"json",
type:"post",
success:function(data){
alert(data);
alert(data.addressName);
}
}); });
});
1
2
3
4
@RequestMapping("/testJson")
public @ResponseBody Address testJson(@RequestBody Address address) {
System.out.println(address); address.setAddressName("上海"); return address;
}

SpringMVC实现文件上传

文件上传的回顾

导入文件上传的maven依赖

1
2
3
4
5
6
7
8
9
10
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.1</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.4</version>
</dependency>

添加multipartResolver的Bean配置

1
2
3
4
5
<!-- 配置multipartResolver-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<!-- 设置上传文件的最大尺寸为 50MB -->
<property name="maxUploadSize" value="52428800"/>
</bean>

编写文件上传的JSP页面

1
2
3
4
5
6
<h3>测试文件上传</h3>
<form action="fileupload" method="post" enctype="multipart/form-data">
选择文件:<input type="file" name="file"/><br/>
选择描述:<input type="text" name="desc"/><br/>
<input type="submit" value="上传文件"/>
</form>

编写文件上传的Controller控制器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
* 文件上传
* @throws Exception */
@Controller
public class UploadController {

@RequestMapping("fileupload")
public String testupload(String desc,MultipartFile file
) throws IOException {
System.out.println(desc);
System.out.println(file.getOriginalFilename());
System.out.println(file.getInputStream());
return "success";
}
}

多文件上传MultipartFile[] file + 遍历

SpringMVC的拦截器

SpringMVc提供了拦截器机制;允许运行目标方法之前进行一些拦截工作,或者在目标方法运行之后进行一些其他处理;

就和JavaWEB中的Filter过滤器很像

通过一个接口:HandlerIntercepter,有三个方法

  • preHandle:在目标运行之前调用;返回一个boolean;是否放行

  • postHandle:在目标运行之后调用:

  • afterCompletion:在请求整个完成之后;来到目标页面之后

拦截器是一个接口,所以要使用它的实现方法

执行顺序是

  • 拦截器的preHandle-目标方法-拦截器postHandle-页面-拦截器的afterCompletion

其他流程:

  • 只要不放行就不会有后面的流程
  • 已经放行的拦截器的afterCompletion总会执行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class MyIntercepter implements HandlerInterceptor {

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

System.out.println("pre");
return true;
}

@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("post");
}

@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("after");
}
}

SpringMVC的异常处理

Controller调用service,service调用dao,异常都是向上抛出的,最终有DispatcherServlet找异常处理器进 行异常的处理。

在本类里面写的异常处理可以处理本类里的异常

ExceptionHandler

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Controller
public class MyException {
@RequestMapping("testException")
public String handle01(){
System.out.println("handle01");
System.out.println( 10 / 0);
return "success";
}

@ExceptionHandler(value = ArithmeticException.class)
public String handle01Execption(Exception exception){
return "false";
}
}

也可以将异常处理写成全局

1
2
3
4
5
6
7
@ControllerAdvice
public class MyException {
@ExceptionHandler(value = ArithmeticException.class)
public String handle01Execption(Exception exception){
return "false";
}
}

ResponseStatus

自定义异常

1
2
3
4
5
6
7

@ResponseStatus(reason = "找不到",value = HttpStatus.NOT_FOUND)
public class NotFoundException extends RuntimeException {

private static final long serialVersionUID = 1L;

}