SpringMVC框架学习笔记

SpringMVC 的基本概念

三层架构

  我们的开发架构一般都是基于两种形式，一种是 C/S 架构，也就是客户端/服务器，另一种是 B/S 架构，也就是浏览器服务器。在 JavaEE 开发中，几乎全都是基于 B/S 架构的开发。那么在 B/S 架构中，系统标准的三层架构包括：表现层、业务层、持久层。三层架构在我们的实际开发中使用的非常多，所以我们课程中的案例也都是基于三层架构设计的

  三层架构中，每一层各司其职，接下来我们就说说每层都负责哪些方面：

  表现层：

    也就是我们常说的web层。它负责接收客户端请求，向客户端响应结果，通常客户端使用http协议请求web 层，web 需要接收 http 请求，完成 http 响应

    表现层包括展示层和控制层：控制层负责接收请求，展示层负责结果的展示

    表现层依赖业务层，接收到客户端请求一般会调用业务层进行业务处理，并将处理结果响应给客户端

    表现层的设计一般都使用 MVC 模型。（MVC 是表现层的设计模型，和其他层没有关系）

  业务层：

    也就是我们常说的 service 层。它负责业务逻辑处理，和我们开发项目的需求息息相关。web 层依赖业务层，但是业务层不依赖 web 层

    业务层在业务处理时可能会依赖持久层，如果要对数据持久化需要保证事务一致性（也就是我们说的，事务应该放到业务层来控制）

  持久层：

    也就是我们是常说的 dao 层。负责数据持久化，包括数据层即数据库和数据访问层，数据库是对数据进行持久化的载体，数据访问层是业务层和持久层交互的接口，业务层需要通过数据访问层将数据持久化到数据库中。通俗的讲，持久层就是和数据库交互，对数据库表进行曾删改查的

MVC模型

  MVC 全名是 Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，是一种用于设计创建 Web 应用程序表现层的模式。MVC 中每个部分各司其职：

  Model（模型）：

    通常指的就是我们的数据模型,作用一般情况下用于封装数据

  View（视图）：

    通常指的就是我们的 jsp 或者 html 作用一般就是展示数据的

    通常视图是依据模型数据创建的

  Controller（控制器）：

    是应用程序中处理用户交互的部分。作用一般就是处理程序逻辑的

    它相对于前两个不是很好理解，举个例子： 例如：

     我们要保存一个用户的信息，该用户信息中包含了姓名，性别，年龄等等

     这时候表单输入要求年龄必须是 1~100 之间的整数。姓名和性别不能为空。并且把数据填充到模型之中

     此时除了 js 的校验之外，服务器端也应该有数据准确性的校验，那么校验就是控制器的该做的

     当校验失败后，由控制器负责把错误页面展示给使用者

     如果校验成功，也是控制器负责把数据填充到模型，并且调用业务层实现完整的业务需求

SpringMVC 是什么

  SpringMVC 是一种基于 Java 的实现 MVC 设计模型的请求驱动类型的轻量级 Web 框架，属于SpringFrameWork 的后续产品，已经融合在 Spring Web Flow 里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。使用 Spring 可插入的 MVC 架构，从而在使用 Spring 进行 WEB 开发时，可以选择使用 Spring的 Spring MVC 框架或集成其他 MVC 开发框架，如 Struts1(现在一般不用)，Struts2 等

  SpringMVC 已经成为目前最主流的 MVC 框架之一，并且随着 Spring3.0 的发布，全面超越 Struts2，成为最优秀的 MVC 框架

  它通过一套注解，让一个简单的 Java 类成为处理请求的控制器，而无须实现任何接口。同时它还支持RESTful 编程风格的请求

SpringMVC 的优势

  1、清晰的角色划分：

    前端控制器（DispatcherServlet）

    请求到处理器映射（HandlerMapping）

    处理器适配器（HandlerAdapter）

    视图解析器（ViewResolver）

    处理器或页面控制器（Controller）

    验证器（ Validator）

    命令对象（Command 请求参数绑定到的对象就叫命令对象）

    表单对象（Form Object 提供给表单展示和提交到的对象就叫表单对象）

2、分工明确，而且扩展点相当灵活，可以很容易扩展，虽然几乎不需要

3、由于命令对象就是一个 POJO，无需继承框架特定 API，可以使用命令对象直接作为业务对象

4、和 Spring 其他框架无缝集成，是其它 Web 框架所不具备的

5、可适配，通过 HandlerAdapter 可以支持任意的类作为处理器

6、可定制性，HandlerMapping、ViewResolver 等能够非常简单的定制

7、功能强大的数据验证、格式化、绑定机制

8、利用 Spring 提供的 Mock 对象能够非常简单的进行 Web 层单元测试

9、本地化、主题的解析的支持，使我们更容易进行国际化和主题的切换

10、强大的 JSP 标签库，使 JSP 编写更容易

………………还有比如RESTful风格的支持、简单的文件上传、约定大于配置的契约式编程支持、基于注解的零配置支持等等

RequestMapping 注解

  作用：用于建立请求 URL 和处理请求方法之间的对应关系。

  出现位置：

    类上：

     请求 URL 的第一级访问目录。此处不写的话，就相当于应用的根目录。写的话需要以/开头

     它出现的目的是为了使我们的 URL 可以按照模块化管理

    方法上：

     请求URL的第二级目录

success.jsp

<h3>入门成功h3>

@Controller
@RequestMapping(path = "/user")
public class HelloController {
     
	
	@RequestMapping(path = "/testRequestMapping")
	public String testRequestMapping(){
     
        System.out.println("测试RequestMapping注解...");
        return "success";
    }
}

index.jsp

<a href="user/testRequestMapping">RequestMapping注解a>

  属性：

   value：用于指定请求的 URL。它和 path 属性的作用是一样的

   method：用于指定请求的方式

   params：用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的 key 和 value 必须和配置的一模一样

   例如：

    params = {“accountName”}，表示请求参数必须有 accountName

    params = {“moeny!100”}，表示请求参数中 money 不能是 100

    headers：用于指定限制请求消息头的条件

  注意：

    以上四个属性只要出现 2 个或以上时，他们的关系是与的关系

请求参数的绑定

请求参数的绑定说明

  绑定机制

   1. 表单提交的数据都是k=v格式的 username=haha&password=123

   2. SpringMVC的参数绑定过程是把表单提交的请求参数，作为控制器中方法的参数进行绑定的

   3. 要求：提交表单的name和参数的名称是相同的

  支持的数据类型

   1. 基本数据类型和字符串类型

   2. 实体类型（JavaBean）

   3. 集合数据类型（List、map集合等）

请求绑定入门

基本数据类型和字符串类型

@Controller
@RequestMapping("/param")
public class ParamController {
     
    /**
     * 请求参数绑定入门
     * @return
     */
    @RequestMapping("/testParam")
    public String testParam(String username,String password){
     
        System.out.println("执行了...");
        System.out.println("用户名："+username);
        System.out.println("密码："+password);
        return "success";
    }
}

param.jsp

<%--请求参数绑定--%>
    <a href="param/testParam?username=hehe&password=123">请求参数绑定a>

实体类型（JavaBean）

public class Account implements Serializable {
     
    private String username;
    private String password;
    private Double money;

    public String getUsername() {
     
        return username;
    }

    public void setUsername(String username) {
     
        this.username = username;
    }

    public String getPassword() {
     
        return password;
    }

    public void setPassword(String password) {
     
        this.password = password;
    }

    public Double getMoney() {
     
        return money;
    }

    public void setMoney(Double money) {
     
        this.money = money;
    }

    @Override
    public String toString() {
     
        return "Account{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", money=" + money +
                '}';
    }
}

param.jsp

 把数据封装Account类中
 <form action="param/saveAccount" method="post">
        姓名：<input type="text" name="username" /><br>
        密码：<input type="text" name="password" /><br>
        金额：<input type="text" name="money" /><br>
        <input type="submit" name="提交" />
    form>

/**
     * 请求参数绑定把数据封装到JavaBean的类中
     * @return
     */
    @RequestMapping("/saveAccount")
    public String saveAccount(Account account){
     
        System.out.println("执行了...");
        System.out.println(account);
        return "success";
    }

如果Account类里有一个引用类型

public class Account implements Serializable {
     
    private String username;
    private String password;
    private Double money;

	private User user;

	//生成他们的set  get方法...代码太长我就省略了
	
    public User getUser() {
     
        return user;
    }

    public void setUser(User user) {
     
        this.user = user;
    }

    @Override
    public String toString() {
     
        return "Account{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", money=" + money +
                ", user=" + user + 
                '}';
    }
}

public class User implements Serializable {
     
    private String uname;
    private Integer age;
	//生成他们的set  get方法...

    @Override
    public String toString() {
     
        return "User{" +
                "uname='" + uname + '\'' +
                ", age=" + age +
                '}';
    }
}

param.jsp

	把数据封装Account类中
    <form action="param/saveAccount" method="post">
        姓名：<input type="text" name="username" /><br>
        密码：<input type="text" name="password" /><br>
        金额：<input type="text" name="money" /><br>
        用户姓名：<input type="text" name="user.uname" /><br>
        用户年龄：<input type="text" name="user.age" /><br>
        <input type="submit" name="提交" />
    form>

/**
     * 请求参数绑定把数据封装到JavaBean的类中
     * @return
     */
    @RequestMapping("/saveAccount")
    public String saveAccount(Account account){
     
        System.out.println("执行了...");
        System.out.println(account);
        return "success";
    }

如果上面提交了中文后台会乱码

配置解决中文乱码的过滤器

  <filter>
    <filter-name>characterEncodingFilterfilter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
    <init-param>
      <param-name>encodingparam-name>
      <param-value>UTF-8param-value>
    init-param>
  filter>
  <filter-mapping>
    <filter-name>characterEncodingFilterfilter-name>
    <url-pattern>/*url-pattern>
  filter-mapping>

集合数据类型（List、map集合等）

public class Account implements Serializable {
     
    private String username;
    private String password;
    private Double money;
	//生成他们的set get方法...

    private List<User> list;
    private Map<String,User> map;

    public List<User> getList() {
     
        return list;
    }

    public void setList(List<User> list) {
     
        this.list = list;
    }

    public Map<String, User> getMap() {
     
        return map;
    }

    public void setMap(Map<String, User> map) {
     
        this.map = map;
    }

    @Override
    public String toString() {
     
        return "Account{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", money=" + money +
                ", list=" + list +
                ", map=" + map +
                '}';
    }
}

param.jsp

	把数据封装Account类中，类中存在list和map的集合
    <form action="param/saveAccount" method="post">
        姓名：<input type="text" name="username" /><br>
        密码：<input type="text" name="password" /><br>
        金额：<input type="text" name="money" /><br>

        用户姓名：<input type="text" name="list[0].uname" /><br>
        用户年龄：<input type="text" name="list[0].age" /><br>

        用户姓名：<input type="text" name="map['one'].uname" /><br>
        用户年龄：<input type="text" name="map['one'].age" /><br>
        <input type="submit" name="提交" />
    form>

/**
     * 请求参数绑定把数据封装到 集合数据类型 中
     * @return
     */
    @RequestMapping("/saveAccount")
    public String saveAccount(Account account){
     
        System.out.println("执行了...");
        System.out.println(account);
        return "success";
    }

自定义类型转换器

   1. 表单提交的任何数据类型全部都是字符串类型，但是后台定义Integer类型，数据也可以封装上，说明Spring框架内部会默认进行数据类型转换

   2. 如果想自定义数据类型转换，可以实现Converter的接口

例：

public class User implements Serializable {
     
    private String uname;
    private Integer age;

    private Date date;

    public String getUname() {
     
        return uname;
    }

    public void setUname(String uname) {
     
        this.uname = uname;
    }

    public Integer getAge() {
     
        return age;
    }

    public void setAge(Integer age) {
     
        this.age = age;
    }

    public Date getDate() {
     
        return date;
    }

    public void setDate(Date date) {
     
        this.date = date;
    }

    @Override
    public String toString() {
     
        return "User{" +
                "uname='" + uname + '\'' +
                ", age=" + age +
                ", date=" + date +
                '}';
    }
}

param.jsp

    自定义类型转换器
   <form action="param/saveUser" method="post">
        用户姓名：<input type="text" name="uname" /><br>
        用户年龄：<input type="text" name="age" /><br>
        用户生日：<input type="text" name="date" /><br>
        <input type="submit" name="提交" />
    form>

/**
     * 自定义类型转换器
     * @param user
     * @return
     */
    @RequestMapping("/saveUser")
    public String saveUser(User user){
     
        System.out.println("执行了...");
        System.out.println(user);
        return "success";
    }

  输入2000/11/121不会报错

  输入2000-11-11 就会报错

  解决方法：

   定义一个类，实现 Converter 接口，该接口有两个泛型

/**
 * 把字符串转换日期
 */
public class StringToDateConverter implements Converter<String, Date> {
     

    /**
     * String source 传进来字符串
     * @param source
     * @return
     */
    public Date convert(String source) {
     
        //判断
        if (source == null){
     
            throw new RuntimeException("请您传入数据");
        }
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd");

        try {
     
            //把字符串转换日期
            return df.parse(source);
        } catch (Exception e) {
     
            throw new RuntimeException("数据类型转换出现错误");
        }
    }
}

   配置自定义类型转换器

springmvc.xml

    <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
       
        <property name="converters">
            <set>
                <bean class="cn.itcast.utils.StringToDateConverter"/>
            set>
        property>
    bean>
 
 
    <mvc:annotation-driven conversion-service="conversionService"/>

在控制器中使用原生的ServletAPI对象

  只需要在控制器的方法参数定义HttpServletRequest和HttpServletResponse对象

  例：

param.jsp

<a href="param/testServlet">Servlet原生的APIa>

/**
     * 原生的API
     * @return
     */
    @RequestMapping("/testServlet")
    public String testServlet(HttpServletRequest request, HttpServletResponse response){
     
        System.out.println("执行了...");
        System.out.println(request);

        HttpSession session = request.getSession();
        System.out.println(session);

        ServletContext servletContext = session.getServletContext();
        System.out.println(servletContext);

        System.out.println(response);
        return "success";
    }

常用注解

RequestParam

.  作用：

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

  属性：

   value：请求参数中的名称

   required：请求参数中是否必须提供此参数，默认值是true，必须提供

anno.jsp

	常用的注解
    <a href="anno/testRequestParam?name=哈哈">RequestParama>

/**
 * 常用的注解
 */
@Controller
@RequestMapping("/anno")
public class AnnoController {
     

    @RequestMapping("/testRequestParam")
    public String testRequestParam(@RequestParam(name = "name") String username){
     
        System.out.println("执行了...");
        System.out.println(username);
        return "success";
    }

RequestBody

  作用：

   用于获取请求体内容。直接使用得到是 key=value&key=value…结构的数据

   get 请求方式不适用

  属性：

   required：是否必须有请求体。默认值是:true。当取值为 true 时,get 请求方式会报错。如果取值为 false，get 请求得到是 null

anno.jsp

<form action="anno/testRequestBody" method="post">
        用户姓名：<input type="text" name="username" /><br>
        用户年龄：<input type="text" name="age" /><br>
        <input type="submit" name="提交" />
    form>

/**
     * 获取到请求体的内容
     * @param body
     * @return
     */
    @RequestMapping("/testRequestBody")
    public String testRequestBody(@RequestBody String body){
     
        System.out.println("执行了...");
        System.out.println(body);
        return "success";
    }

PathVaribale

  作用：

   用于绑定 url 中的占位符。例如：请求 url 中 /delete/{id}，这个{id}就是 url 占位符

   url 支持占位符是 spring3.0 之后加入的。是 springmvc 支持 rest 风格 URL 的一个重要标志

  属性：

   value：用于指定 url 中占位符名称

   required：是否必须提供占位符

anno.jsp

<a href="anno/testPathVariable/10">testPathVariablea>

/**
     * PathVariable注解
     * @param id
     * @return
     */
    @RequestMapping("/testPathVariable/{sid}")
    public String testPathVariable(@PathVariable(name = "sid") String id){
     
        System.out.println("执行了...");
        System.out.println(id);
        return "success";
    }

REST 风格 URL

  什么是 rest：

    REST（英文：Representational State Transfer，简称 REST）描述了一个架构样式的网络系统，比如 web 应用程序。它首次出现在 2000 年 Roy Fielding 的博士论文中，他是 HTTP 规范的主要编写者之一。在目前主流的三种 Web 服务交互方案中，REST 相比于 SOAP（Simple Object Access protocol，简单对象访问协议）以及 XML-RPC 更加简单明了，无论是对 URL 的处理还是对 Payload 的编码，REST 都倾向于用更加简单轻量的方法设计和实现。值得注意的是 REST 并没有一个明确的标准，而更像是一种设计的风格。它本身并没有什么实用性，其核心价值在于如何设计出符合 REST 风格的网络接口

  restful 的优点：

    它结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多网站的采用

  restful 的特性：

   资源（Resources）：

    网络上的一个实体，或者说是网络上的一个具体信息

    它可以是一段文本、一张图片、一首歌曲、一种服务，总之就是一个具体的存在。可以用一个 URI（统一资源定位符）指向它，每种资源对应一个特定的 URI 。要获取这个资源，访问它的 URI 就可以，因此 URI 即为每一个资源的独一无二的识别符

  表现层（Representation）：

    把资源具体呈现出来的形式，叫做它的表现层 （Representation）

    比如，文本可以用 txt 格式表现，也可以用 HTML 格式、XML 格式、JSON 格式表现，甚至可以采用二进制格式

  状态转化（State Transfer）：

    每发出一个请求，就代表了客户端和服务器的一次交互过程

    HTTP 协议，是一个无状态协议，即所有的状态都保存在服务器端。因此，如果客户端想要操作服务器，必须通过某种手段，让服务器端发生“状态转化”（State Transfer）。而这种转化是建立在表现层之上的，所以就是 “表现层状态转化”。具体说，就是 HTTP 协议里面，四个表示操作方式的动词：GET 、POST 、PUT、DELETE。它们分别对应四种基本操作：GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE 用来删除资源

  restful 的示例：

     /account/1 HTTP GET ： 得到 id = 1 的 account

     /account/1 HTTP DELETE： 删除 id = 1 的 account

     /account/1 HTTP PUT： 更新 id = 1 的 account

     /account HTTP POST： 新增 account

RequestHeader

  作用：

   用于获取请求消息头

  属性：

   value：提供消息头名称

   required：是否必须有此消息头

anno.jsp

<a href="/anno/testRequestHeader">RequestHeadera>

/**
     * 获取请求头的值
     * @param header
     * @return
     */
    @RequestMapping(value = "/testRequestHeader")
    public String testRequestHeader(@RequestHeader(value = "Accept") String header){
     
        System.out.println("执行了...");
        System.out.println(header);
        return "success";
    }

CookieValue

  作用：

   用于把指定 cookie 名称的值传入控制器方法参数

  属性：

   value：指定 cookie 的名称

   required：是否必须有此 cookie

anno.jsp

<a href="anno/testCookieValue">CookieValuea>

/**
     * 获取Cookie的值
     * @param cookieValue
     * @return
     */
    @RequestMapping(value = "/testCookieValue")
    public String testCookieValue(@CookieValue(value = "JSESSIONID") String cookieValue){
     
        System.out.println("执行了...");
        System.out.println(cookieValue);
        return "success";
    }

ModelAttribute

  作用：

   该注解是 SpringMVC4.3 版本以后新加入的。它可以用于修饰方法和参数

   出现在方法上，表示当前方法会在控制器的方法执行之前，先执行。它可以修饰没有返回值的方法，也可以修饰有具体返回值的方法

   出现在参数上，获取指定的数据给参数赋值

  属性：

   value：用于获取数据的 key。key 可以是 POJO 的属性名称，也可以是 map 结构的 key

  应用场景：

   当表单提交数据不是完整的实体类数据时，保证没有提交数据的字段使用数据库对象原来的数据

  例如：

   我们在编辑一个用户时，用户有一个创建信息字段，该字段的值是不允许被修改的。在提交表单数据是肯定没有此字段的内容，一旦更新会把该字段内容置为 null，此时就可以使用此注解解决问题

anno.jsp

<form action="anno/testModelAttribute" method="post">
        用户姓名：<input type="text" name="uname" /><br>
        用户年龄：<input type="text" name="age" /><br>
        <input type="submit" name="提交" />
    form>

/**
     * ModelAttribute注解
     * @return
     */
    @RequestMapping(value = "/testModelAttribute")
    public String testModelAttribute(User user){
     
        System.out.println("testModelAttribute执行了...");
        return "success";
    }
	
	/**
	 * 该方法会先执行
	 **/
    @ModelAttribute
    public User showUser(String uname){
     
        System.out.println("showUser执行了...");
        //通过用户查询数据库（模拟）
        User user = new User();
        user.setUname(uname);
        user.setAge(20);
        user.setDate(new Date());
        return user;
    }

如果没有返回值

/**
     * ModelAttribute注解
     * @return
     */
    @RequestMapping(value = "/testModelAttribute")
    public String testModelAttribute(@ModelAttribute("abc") User user){
     
        System.out.println("testModelAttribute执行了...");
        return "success";
    }

    public void showUser(String uname, Map<String,User> map) {
     
        System.out.println("showUser执行了...");
        //通过用户查询数据库（模拟）
        User user = new User();
        user.setUname(uname);
        user.setAge(20);
        user.setDate(new Date());
        map.put("abc",user);
    }

SessionAttribute

  作用：

   用于多次执行控制器方法间的参数共享

  属性：

   value：用于指定存入的属性名称

   type：用于指定存入的数据类型

anno.jsp

 <a href="anno/testSessionAttributes">testSessionAttributesa>

success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
    <title>Titletitle>
head>
<body>
    <h3>入门成功h3>
    	
    ${ requestScope }

body>
html>

 /**
     * SessionAttributes的注解
     * @return
     */
    @RequestMapping(value = "/testSessionAttributes")
    public String testSessionAttributes(Model model){
     
        System.out.println("testModelAttribute执行了...");
        //底层会存储到request域对象中
        model.addAttribute("msg","美美");
        return "success";
    }

success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
    <title>Titletitle>
head>
<body>
    <h3>入门成功h3>

    ${ requestScope.msg }

    ${ sessionScope }
    
body>
html>

/**
 * 常用的注解
 */
@Controller
@RequestMapping("/anno")
@SessionAttributes(value = {
     "msg"})  //把msg=美美存入到session域对象中
public class AnnoController {
     
	/**
     * SessionAttributes的注解
     * @return
     */
    @RequestMapping(value = "/testSessionAttributes")
    public String testSessionAttributes(Model model){
     
        System.out.println("testModelAttribute执行了...");
        //底层会存储到request域对象中
        model.addAttribute("msg","美美");
        return "success";
    }

}

取值

anno.jsp

<a href="anno/getSessionAttributes">getSessionAttributesa>

/**
     * 获取值
     * @param modelMap
     * @return
     */
    @RequestMapping(value = "/getSessionAttributes")
    public String getSessionAttributes(ModelMap modelMap){
     
        System.out.println("getSessionAttributes...");
        String msg = (String) modelMap.get("msg");
        System.out.println(msg);
        return "success";
    }

清除值

anno.jsp

<a href="anno/delSessionAttributes">delSessionAttributesa>

/**
     * 清除
     * @param status
     * @return
     */
    @RequestMapping(value = "/delSessionAttributes")
    public String delSessionAttributes(SessionStatus status){
     
        System.out.println("getSessionAttributes...");
        status.setComplete();
        return "success";
    }

响应数据和结果视图

返回字符串

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

response.jsp

<a href="user/testString">testStringa>

public class User implements Serializable {
     

    private String username;
    private String password;
    private Integer age;

    public String getUsername() {
     
        return username;
    }

    public void setUsername(String username) {
     
        this.username = username;
    }

    public String getPassword() {
     
        return password;
    }

    public void setPassword(String password) {
     
        this.password = password;
    }

    public Integer getAge() {
     
        return age;
    }

    public void setAge(Integer age) {
     
        this.age = age;
    }
}

@Controller
@RequestMapping("/user")
public class UserController {
     

    /**
     * 返回String
     * @param model
     * @return
     */
    @RequestMapping("/testString")
    public String testString(Model model){
     
        System.out.println("testString方法执行了...");
        //模拟从数据库中查询出User对象
        User user = new User();
        user.setUsername("美美");
        user.setPassword("123");
        user.setAge(30);
        //model对象
        model.addAttribute("user",user);
        return "success";
    }

}

success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
    <title>Titletitle>
head>
<body>

    <h3>执行成功h3>

    ${user.username}
    ${user.password}

body>
html>

返回值是void

  如果控制器的方法返回值编写成void，执行程序报404的异常，默认查找JSP页面没有找到

  默认会跳转到@RequestMapping(value="/initUpdate") initUpdate的页面

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

response.jsp

<a href="user/testVoid">testVoida>

index.jsp

<h3>重定向h3>

/**
     * 返回值类型是void
     * 请求转发一次请求，不用编写项目的名称
     */
    @RequestMapping("/testVoid")
    public void testVoid(HttpServletRequest request, HttpServletResponse response) throws Exception {
     
        System.out.println("testVoid方法执行了...");
        //编写请求转发的程序
        //request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request,response);

        //重定向
        //response.sendRedirect(request.getContextPath()+"/index.jsp");

        //设置中文乱码
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");

        //直接会进行响应
        response.getWriter().print("你好");

        return;
    }

编写请求转发

重定向

直接进行响应

返回值是ModelAndView对象

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

response.jsp

<a href="user/testModelAndView">testModelAndViewa>

/**
     * 返回testModelAndView
     * @return
     */
    @RequestMapping("/testModelAndView")
    public ModelAndView testModelAndView(){
     
        //创建ModelAndView对象
        ModelAndView mv = new ModelAndView();
        System.out.println("testModelAndView方法执行了...");
        //模拟从数据库中查询出User对象
        User user = new User();
        user.setUsername("小凤");
        user.setPassword("456");
        user.setAge(30);

        //把user对象存储到mv对象中，也会把user对象存入到request对象
        mv.addObject("user",user);

        //跳转到哪个页面
        mv.setViewName("success");

        return mv;
    }

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

response.jsp

<a href="user/testForwardOrRedirect">testForwardOrRedirecta>

/**
     * 使用关键字的方式进行转发或者重定向
     * @return
     */
    @RequestMapping("/testForwardOrRedirect")
    public String testForwardOrRedirect(){
     
        System.out.println("testForwardOrRedirect方法执行了...");

        //请求的转发
        //return "forward:/WEB-INF/pages/success.jsp";

        //重定向
        return "redirect:/index.jsp";
    }

请求的转发

重定向

ResponseBody响应json数据

过滤静态资源

  DispatcherServlet会拦截到所有的资源，导致一个问题就是静态资源（img、css、js）也会被拦截到，从而不能被使用。解决问题就是需要配置静态资源不进行拦截，在springmvc.xml配置文件添加如下配置

response.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Titletitle>

    <script src="js/jquery.min.js">script>

    <script>
        //页面加载，绑定单击事件
        $(function () {
      
            $("#btn").click(function () {
      
                alert("hello btn");
            });
        });
    script>
    <button id="btn">发送ajax请求button>

body>
html>

点击按钮没反应

   mvc:resources 标签配置不过滤

     location元素表示webapp目录下的包下的所有文件

     mapping元素表示以/static开头的所有请求路径，如/static/a 或者/static/a/b

Springmvc.xml

<mvc:resources location="/css/" mapping="/css/**"/> 
<mvc:resources location="/images/" mapping="/images/**"/> 
<mvc:resources location="/js/" mapping="/js/**"/> 

发送AJAX请求

response.jsp

    <script>
        //页面加载，绑定单击事件
        $(function () {
      
            $("#btn").click(function () {
      
                //alert("hello btn");
                //发送ajax请求
                $.ajax({
      
                    //编写json格式，设置属性和值
                    url:"user/testAjax",
                    contentType:"application/json;charset=UTF-8",
                    data:'{"username":"hehe","password":"123","age":30}',
                    dataType:"json",
                    type:"post",
                    success:function (data) {
      
                        //data服务器端响应的json的数据，进行解析
                    }
                })
            });
        });
    script>

/**
     * 模拟异步请求响应
     */
    @RequestMapping("/testAjax")
    public void testAjax(@RequestBody String body){
     
        System.out.println("testAjax方法执行了...");
        System.out.println(body);
    }

响应json格式数据

导入jar包

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

pom.xml

<dependency>
	<groupId>com.fasterxml.jackson.coregroupId>
	<artifactId>jackson-databindartifactId>
	<version>2.9.0version>
dependency>

<dependency>
	<groupId>com.fasterxml.jackson.coregroupId>
	<artifactId>jackson-coreartifactId>
	<version>2.9.0version>
dependency>

<dependency>
	<groupId>com.fasterxml.jackson.coregroupId>
	<artifactId>jackson-annotationsartifactId>
	<version>2.9.0version>
dependency>

response.jsp

<script>
        //页面加载，绑定单击事件
        $(function () {
      
            $("#btn").click(function () {
      
                //alert("hello btn");
                //发送ajax请求
                $.ajax({
      
                    //编写json格式，设置属性和值
                    url:"user/testAjax",
                    contentType:"application/json;charset=UTF-8",
                    data:'{"username":"hehe","password":"123","age":30}',
                    dataType:"json",
                    type:"post",
                    success:function (data) {
      
                        //data服务器端响应的json的数据，进行解析
                        alert(data);
                        alert(data.username);
                        alert(data.password);
                        alert(data.age);
                    }
                })
            });
        });
    script>

/**
     * 模拟异步请求响应
     */
    @RequestMapping("/testAjax")
    public @ResponseBody User testAjax(@RequestBody User user){
     
        System.out.println("testAjax方法执行了...");
        //客户端发送ajax的请求，传的是json字符串，后端把json字符串封装到user对象中
        System.out.println(user);
        //做响应，模拟查询数据库
        user.setUsername("haha");
        user.setAge(40);
        //做响应
        return user;
    }

文件上传

文件上传的回顾

  文件上传的必要前提

     form 表单的 enctype 取值必须是：multipart/form-data

        (默认值是:application/x-www-form-urlencoded)

        enctype:是表单请求正文的类型

     method 属性取值必须是 Post

     提供一个文件选择域

  文件上传的原理分析

    当 form 表单的 enctype 取值不是默认值后，request.getParameter()将失效

    enctype=”application/x-www-form-urlencoded”时，form 表单的正文内容是：key=value&key=value&key=value

    当 form 表单的 enctype 取值为 Mutilpart/form-data 时，请求正文内容就变成：

    每一部分都是 MIME 类型描述的正文

    -----------------------------7de1a433602ac    分界符

    Content-Disposition: form-data; name=“userName”     协议头

    aaa         协议的正文

    -----------------------------7de1a433602ac

    Content-Disposition: form-data; name=“file”;

    filename="C:\Users\zhy\Desktop\fileupload_demofile\b.txt"

    Content-Type: text/plain       协议的类型（MIME 类型）

    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

    -----------------------------7de1a433602ac–

  借助第三方组件实现文件上传

    使用 Commons-fileupload 组件实现文件上传，需要导入该组件相应的支撑 jar 包：Commons-fileupload 和commons-io。commons-io 不属于文件上传组件的开发 jar 文件，但Commons-fileupload 组件从 1.1 版本开始，它工作时需要 commons-io 包的支持

导入jar包

pom.xml

<dependency>
	<groupId>commons-fileuploadgroupId>
	<artifactId>commons-fileuploadartifactId>
	<version>1.3.1version>
dependency>

<dependency>
	<groupId>commons-iogroupId>
	<artifactId>commons-ioartifactId>
	<version>2.4version>
dependency>

success.jsp

<h3>文件上传成功h3>

index.jsp

<h3>传统文件上传h3>

    <form action="/user/fileuoload1" method="post" enctype="multipart/form-data">
        选择文件: <input type="file" name="upload" /><br/>
        <input type="submit" value="上传" />
    form>

@Controller
@RequestMapping("/user")
public class UserController {
     
	/**
     * 传统方式文件上传
     * @return
     */
    @RequestMapping("/fileuoload1")
    public String fileuoload1(HttpServletRequest request) throws Exception {
     
        System.out.println("文件上传...");

        //使用fileupload组件完成文件上传
        //上传的位置
        String path = request.getSession().getServletContext().getRealPath("/uploads/");
        //判断，该路径是否存在
        File file = new File(path);
        if (!file.exists()) {
     
            //创建该文件夹
            file.mkdirs();
        }

        //解析request对象，获取上传文件项
        DiskFileItemFactory factory = new DiskFileItemFactory();
        ServletFileUpload upload = new ServletFileUpload(factory);
        //解析request
        List<FileItem> items = upload.parseRequest(request);
        //遍历
        for (FileItem item : items) {
     
            //进行判断，当前item对象是否是上传文件项
            if (item.isFormField()) {
     
                //说明普通表单项
            } else {
     
                //说明上传文件项
                //获取上传文件的名称
                String filename = item.getName();
                //把文件的名称设置唯一值，uuid
                String uuid = UUID.randomUUID().toString().replace("-","");
                filename = uuid+"_"+filename;
                //完成文件上传
                item.write(new File(path, filename));
                //删除临时文件
                item.delete();
            }
        }

        return "success";
    }
}

Springmvc方式文件上传

SpringMVC框架提供了MultipartFile对象，该对象表示上传的文件，要求变量名称必须和表单file标签的name属性名称相同

index.jsp

<h3>Springmvc文件上传h3>

    <form action="/user/fileuoload2" method="post" enctype="multipart/form-data">
        选择文件: <input type="file" name="upload" /><br/>
        <input type="submit" value="上传" />
    form>

springmvc.xml

    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="10485760" />
    bean>

/**
     * SpringMVC文件上传
     * @return
     */
    @RequestMapping("/fileuoload2")
    public String fileuoload2(HttpServletRequest request, MultipartFile upload) throws Exception {
     
        System.out.println("springmvc文件上传...");

        //使用fileupload组件完成文件上传
        //上传的位置
        String path = request.getSession().getServletContext().getRealPath("/uploads/");
        //判断，该路径是否存在
        File file = new File(path);
        if (!file.exists()) {
     
            //创建该文件夹
            file.mkdirs();
        }

                //说明上传文件项
                //获取上传文件的名称
                String filename = upload.getOriginalFilename();
                //把文件的名称设置唯一值，uuid
                String uuid = UUID.randomUUID().toString().replace("-","");
                filename = uuid+"_"+filename;
                //完成文件上传
                upload.transferTo(new File(path,filename));

        return "success";
    }

SpringMVC跨服务器方式文件上传

分服务器的目的

  在实际开发中，我们会有很多处理不同功能的服务器。例如：

    应用服务器：负责部署我们的应用

    数据库服务器：运行我们的数据库

    缓存和消息服务器：负责处理大并发访问的缓存和消息

    文件服务器：负责存储用户上传文件的服务器

    (注意：此处说的不是服务器集群）

分服务器处理的目的是让服务器各司其职，从而提高我们项目的运行效率

在同一台电脑上模拟

先创建一个图片服务器

然后再导入TOMCAT服务器就好了

导入跨服务器上传的jar包

pom.xml

<dependency>
	<groupId>com.sun.jerseygroupId>
	<artifactId>jersey-coreartifactId>
	<version>1.18.1version>
dependency>

<dependency>
	<groupId>com.sun.jerseygroupId>
	<artifactId>jersey-clientartifactId>
	<version>1.18.1version>
dependency>

index.jsp

<h3>跨服务器文件上传h3>

    <form action="/user/fileuoload3" method="post" enctype="multipart/form-data">
        选择文件: <input type="file" name="upload" /><br/>
        <input type="submit" value="上传" />
    form>

/**
     * 跨服务器文件上传
     * @return
     */
    @RequestMapping("/fileuoload3")
    public String fileuoload3(MultipartFile upload) throws Exception {
     
        System.out.println("跨服务器文件上传...");

        //定义上传文件服务器路径
        String path = "http://localhost:9090/fileuploadserver_war_exploded/uploads/";

        //说明上传文件项
        //获取上传文件的名称
        String filename = upload.getOriginalFilename();
        //把文件的名称设置唯一值，uuid
        String uuid = UUID.randomUUID().toString().replace("-","");
        filename = uuid+"_"+filename;

        //创建客户端的对象
        Client client = Client.create();

        //和图片服务器进行连接
        WebResource webResource = client.resource(path+filename);

        //上传文件
        webResource.put(upload.getBytes());

        return "success";
    }

SpringMVC 中的异常处理

  异常处理的思路

    系统中异常包括两类：预期异常和运行时异常 RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试通过手段减少运行时异常的发生

    系统的 dao、service、controller 出现都通过 throws Exception 向上抛出，最后由 springmvc 前端控制器交由异常处理器进行异常处理，如下图：

index.jsp

<h3>异常处理h3>

    <a href="user/testException" >异常处理a>

success.jsp

<h3>执行成功h3>

@Controller
@RequestMapping("/user")
public class UserController {
     

    @RequestMapping("/testException")
    public String testException() throws SysException{
     
        System.out.println("testException执行了...");

        try {
     
            //模拟异常
            int a = 10/0;
        } catch (Exception e) {
     
            //打印异常信息
            e.printStackTrace();
            //抛出自定义异常信息
            throw new SysException("查询所有用户出现错误了...");
        }

        return "success";
    }
}

/**
 * 自定义异常类
 */
public class SysException extends Exception{
     

    //存储提示信息
    private String message;

    @Override
    public String getMessage() {
     
        return message;
    }

    public void setMessage(String message) {
     
        this.message = message;
    }

    public SysException(String message) {
     
        this.message = message;
    }
}

public class SysExceptionResolver implements HandlerExceptionResolver {
     

    /**
     * 处理异常业务逻辑
     * @param httpServletRequest
     * @param httpServletResponse
     * @param o
     * @param e
     * @return
     */
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception ex) {
     
        //获取到异常对象
        SysException e = null;
        if (ex instanceof SysException){
     
            e = (SysException)ex;
        }else {
     
            e = new SysException("系统正在维护...");
        }
        //创建ModelAndView对象
        ModelAndView mv = new ModelAndView();
        mv.addObject("errorMsg",e.getMessage());
        mv.setViewName("error");
        return mv;
    }
}

springmvc.xml

    <bean id="sysExceptionResolver" class="cn.itcast.exception.SysExceptionResolver" />

error.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
    <title>Titletitle>
head>
<body>

    ${errorMsg}

body>
html>

SpringMVC 中的拦截器

  拦截器的作用

    Spring MVC 的处理器拦截器类似于 Servlet 开发中的过滤器 Filter，用于对处理器进行预处理和后处理

    用户可以自己定义一些拦截器来实现特定的功能

    谈到拦截器，还要向大家提一个词——拦截器链（Interceptor Chain）。拦截器链就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用

    拦截器和过滤器的区别：

    过滤器是 servlet 规范中的一部分，任何 java web 工程都可以使用

    拦截器是 SpringMVC 框架自己的，只有使用了 SpringMVC 框架的工程才能用

    过滤器在 url-pattern 中配置了/*之后，可以对所有要访问的资源拦截

    拦截器它是只会拦截访问的控制器方法，如果访问的是 jsp，html,css,image 或者 js 是不会进行拦截的

    它也是 AOP 思想的具体应用

    我们要想自定义拦截器， 要求必须实现：HandlerInterceptor 接口

@Controller
@RequestMapping("/user")
public class UserController {
     

    @RequestMapping("/testInterceptor")
    public String testInterceptor() {
     
        System.out.println("testInterceptor执行了...");
        return "success";
    }
}

/**
 * 自定义拦截器
 */
public class MyInterceptor1 implements HandlerInterceptor {
     
    /**
     * 预处理，controller方法执行前
     * return true 放行，执行下一个拦截器，如果没有，执行controller中的方法
     * return false 不放行
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
     
        System.out.println("MyInterceptor1执行了...");
        return true;
    }
}

springmvc.xml

 
    <mvc:interceptors>
        
        <mvc:interceptor>
            
            <mvc:mapping path="/user/*"/>
            
            
            <bean class="cn.itcast.controller.cn.itcast.interceptor.MyInterceptor1"/>
        mvc:interceptor>
    mvc:interceptors>

success.jsp

    <h3>执行成功h3>

    <% System.out.println("success.jsp执行了..."); %>

index.jsp

    <h3>拦截器h3>

    <a href="user/testInterceptor" >拦截器a>

HandlerInterceptor接口中的方法

  preHandle方法是controller方法执行前拦截的方法

    1. 可以使用request或者response跳转到指定的页面

    2. return true放行，执行下一个拦截器，如果没有拦截器，执行controller中的方法

    3. return false不放行，不会执行controller中的方法

/**
 * 自定义拦截器
 */
public class MyInterceptor1 implements HandlerInterceptor {
     
    /**
     * 预处理，controller方法执行前
     * return true 放行，执行下一个拦截器，如果没有，执行controller中的方法
     * return false 不放行
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
     
        System.out.println("MyInterceptor1执行了...前");
        //request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
        //return false;
        return true;
    }
}

error.jsp

<h3>错误页面h3>

  postHandle是controller方法执行后执行的方法，在JSP视图执行前

    1. 可以使用request或者response跳转到指定的页面

    2. 如果指定了跳转的页面，那么controller方法跳转的页面将不会显示

/**
     * 后处理方法 controller方法执行后，success.jsp执行之前
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView ) throws Exception {
     
        System.out.println("MyInterceptor1执行了...后");
    }

不管是预处理还是后处理都可以指定页面跳转

  postHandle方法是在JSP执行后执行

    request或者response不能再跳转页面了

/**
     * success.jsp页面执行后，该方法会执行
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
     
        System.out.println("MyInterceptor1执行了...最后");
    }

配置多个拦截器

第一个

/**
 * 自定义拦截器
 */
public class MyInterceptor1 implements HandlerInterceptor {
     
    /**
     * 预处理，controller方法执行前
     * return true 放行，执行下一个拦截器，如果没有，执行controller中的方法
     * return false 不放行
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
     
        System.out.println("MyInterceptor1执行了...111");
        // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
        return true;
    }

    /**
     * 后处理方法，controller方法执行后，success.jsp执行之前
     */
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
     
        System.out.println("MyInterceptor1执行了...后111");
        // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
    }

    /**
     * success.jsp页面执行后，该方法会执行
     */
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
     
        System.out.println("MyInterceptor1执行了...最后111");
    }
}

第二个

/**
 * 自定义拦截器
 */
public class MyInterceptor1 implements HandlerInterceptor {
     
    /**
     * 预处理，controller方法执行前
     * return true 放行，执行下一个拦截器，如果没有，执行controller中的方法
     * return false 不放行
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
     
        System.out.println("MyInterceptor1执行了...222");
        // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
        return true;
    }

    /**
     * 后处理方法，controller方法执行后，success.jsp执行之前
     */
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
     
        System.out.println("MyInterceptor1执行了...后222");
        // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
    }

    /**
     * success.jsp页面执行后，该方法会执行
     */
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
     
        System.out.println("MyInterceptor1执行了...最后222");
    }
}

springmvc.xml

    <mvc:interceptors>
        
        <mvc:interceptor>
            
            <mvc:mapping path="/user/*"/>
            
            
            <bean class="cn.itcast.interceptor.MyInterceptor1" />
        mvc:interceptor>

		
        <mvc:interceptor>
            
            <mvc:mapping path="/**"/>
            
            
            <bean class="cn.itcast.interceptor.MyInterceptor2" />
        mvc:interceptor>
		
    mvc:interceptors>