2021-03-09-SpringMvc

一、SpringMvc的基本概念

1.1 什么是SpringMvc?

SpringMvc是一种基于java的实现MVC设计模型的请求驱动类型的轻量级web框架，属于spring后续产品

1.2 关于三层架构

B/S架构，浏览器/服务器交互，服务器端分为三层架构：第一层表现层、第二层业务层、第三层持久层。 SpringMvc负责表现层业务。
　　

1.3 MVC设计模型

model：模型一般是javaBean对象，用于封装数据（JavaBean是使用Java语言开发的一个可重用的组件）
补充javaBean的概念：

1.JavaBean本身就是一个类，属于Java的面向对象编程。

2.在JSP中如果要应用JSP提供的Javabean的标签来操作简单类的话，则此类必须满足如下的开发要求：

(1)所有的类必须放在一个包中，在WEB中没有包的是不存在的；

(2)所有的类必须声明为public class，这样才能够被外部所访问；
(3)类中所有的属性都必须封装，即：使用private声明；
(4)封装的属性如果需要被外部所操作，则必须编写对应的setter、getter方法；
(5)一个JavaBean中至少存在一个无参构造方法，此为JSP中的标签所使用
————————————————
如果在一个类中只包含属性、setter、getter方法，那么这种类就成为简单JavaBean。
对于简单的JavaBean也有几个名词：

(1)VO：与简单Java对象对应，专门用于传递值的操作上

(2)POJO：简单Java对象，一般是对应数据表的实现类

(3)TO：传输对象，进行远程传输时，对象所在的类必须实现java.io.Serializable接口。
————————————————
版权声明：本文为CSDN博主「望星空」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Joywy/article/details/7773503
版权声明：本文为CSDN博主「望星空」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Joywy/article/details/7773503

view：视图，通常说的式我们的JSP或者HTML一般用于展示数据
controller： 是应用程序中处理用户交互的部分，作用一般是处理程序逻辑

1.4 SpringMvc的优势

1. 清晰的角色划分：
   　前端控制器：DispatcherServlet
   　请求到处理映射：HandlerMapping
   　处理器适配器：HandlerAdapter
   　视图解析器：ViewResolver
   　处理器或者页面控制器：Controller
   　验证器：Validator
   　命令对象：Command 请求参数绑定到的对象就叫做命令对象
   　表单对象：Form Object
2. 分工明确，高可拓展
3. 命令对象是一个POJO，无虚继承特定API，直接使用命令对象作为业务对象
4. 和Spring框架无缝集成
5. 可适配，通过HandlerAdapter可以支持任意的类作为处理器
6. 可定制，通过HandlerMapping和ViewResolver等进行定制
7. 功能强大的数据验证、格式化、绑定机制
8. 利用Spring提供的Mock对象可以非常简单的进行web层单元测试
9. 强大的JSP标签库

1.5 SpringMvc 和 Struts2的优劣分析

1. 共同点：
   　　都是表现层框架，都是基于MVC模型编写
   　　底层都离不开原始的ServletAPI
   　　处理请求的机制都是一个核心控制器
2. 不同点
   　　SpringMvc的入口是Servlet，而Stucts2的入口是Filter
   　　SM基于方法设计，S2基于类设计
   　　SM更加简洁，同时支持JSR303，处理ajax请求更方便
   　　S2的OGNL表达式页面的开发效率相比SpringMvc更高些

二、SpringMvc的入门程序

2.1 入门程序代码是示例

第一步：新建一个web工程项目

第二步：
设计文件夹结构

第三步：导入pom依赖

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

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.itheima</groupId>
  <artifactId>springmvc_01</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>springmvc_01 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <!--版本锁定-->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <spring.version>5.0.2.RELEASE</spring.version>
  </properties>

  <dependencies>
  <!--spring依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!--spring整合web依赖-->
    <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>
    <!--servlet的API-->
    <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>

  <build>
    <finalName>springmvc_01</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

第四步：
编写web.xml文件，配置dispatcherServlet前端控制器

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!--配置前端控制器-->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--配置全局的初始化参数,加载springmvc配置文件-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <!--表示启动服务器就创建dispatcherServlet前端控制器对象
        启动即加载初始化参数，加载springmvc配置文件，扫描spring注解组件进spring容器-->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <!--配置映射-->
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

第五步：

编写请求方法：
/**
 * 控制器
 */
@Controller
public class HelloController {

    @RequestMapping("/say")
    public String sayHello(){
        System.out.println("Hello Spring");
        //return的值默认为jsp文件的名字
        //基本思路，创建名称为success的jsp文件，在springmvc.xml中配置视图解析器
        return "success";
    }
}

第六步：编写springmvc.xml配置文件
用于spring容器注解配置，开启springmvc框架注解的支持，开启视图解析器

<?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="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--表示前缀路径，即可以通过只扫描/WEB-INF/pages/目录下后缀为.jsp的文件就可以访问页面-->
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <!--表示后缀类型-->
        <property name="suffix" value=".jsp"></property>
    </bean>
    <!--开启springMvc框架注解的支持-->
    <mvc:annotation-driven></mvc:annotation-driven>
</beans>

webapp目录下的index.jsp文件

首页index.jsp页面
<%--
  Created by IntelliJ IDEA.
  User: 86185
  Date: 2021/3/9
  Time: 21:33
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h3>入门程序</h3>
<a href="/say">入门程序</a>
</body>
</html>

控制类跳转页面：
success.jsp文件位于/WEB-INF/pages目录下

<%--
  Created by IntelliJ IDEA.
  User: 86185
  Date: 2021/3/9
  Time: 21:43
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>成功了</title>
</head>
<body>

</body>
</html>

2.2 入门案例执行流程图解

2.3 springmvc各种组件的功能

2.4 RequestMapping注解的作用

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

//请求url----/say
//用于将请求URl（路径）映射关联到当前类的sayHello方法
@RequestMapping("/say")
//请求方法sayHello
    public String sayHello(){
        System.out.println("Hello Spring");

@RequestMapping注解可以放在类上或者方法上

注：超链接默认发送get请求
1.1 requestMapping注解的属性：
　　1. path 指定请求的路径
　　2. value 同path属性功能一样
　　3. method 指定方法的请求方式
　　4. params 指定限制请求参数的条件
　　5. headers 发送的请求中必须包含的请求头
可传入请求参数
请求方法：

1.2 RequestMethod

public enum RequestMethod {
    //RequestMapping源码，请求方法枚举类
	GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE

}

使用示例：

1.3 params(表示传入一个String类型的数组，作为执行方法的条件)

传入参数的两种方式，在浏览器直接输入

在超链接处直接传入参数

1.4 headers

三、请求参数的绑定

3.1 请求参数的绑定

1. 请求参数的绑定机制
　　　1. 表单提交的数据都是k=v格式 username=hhh
　　　2. SpringMVc的参数绑定过程是把表达提交的请求参数，作为控制器中的方法的参数进行绑定。
　　　3. 要求：提交表单的name和参数的名称是相同的
2. 支持的数据类型　
　　　1. 基本数据类型和字符串数据类型
　　　2. 实体类型（javaBean）
　　　3. 集合数据类型
3. 基本数据类型和字符串数据类型
　　1. 提交表单的name和参数的名称是相同的
　　2.区分大小写
4. 实体类型（JavaBean）
　　1. 提交表单的name和JavaBean中的属性名称需要一致
　　2. 如果一个JavaBean类中包含其他的引用类型，那么表单的name属性需要编写为：对象，属性，例如address.name
5. 集合数据封装

3.2 请求参数绑定的实例代码

controller类：

@Controller
@RequestMapping("/param")
public class ParamController {
    @RequestMapping("/testParam")
    public String testParam(String username){
        //获取请求参数
        System.out.println("用户名："+username);
        System.out.println("执行");
        return "success";
    }
}　

对应的.jsp文件

<%--
  Created by IntelliJ IDEA.
  User: 86185
  Date: 2021/3/10
  Time: 19:57
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<a href="/param/testParam?username=sssss">请求参数绑定</a>
</body>
</html>

访问 param.jsp文件，点击请求参数绑定按钮，发送请求，服务器自动将username=sssss和controller方法中的username绑定。

　

3.3 请求绑定JavaBean的示例

1.1 创建JavaBean对象，实现Serializable序列化接口
省略set、get和toString方法

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

1.2 创建对应实体类属性的表单jsp文件
注意：表单中的name属性必须和实体勒种的属性完全一致

<body>
   <%--表单--%>
   <form action="/java/bean" method="post">
       <%--springmvc会根据表单中name属性寻找JavaBean中对应的属性的set方法--%>
       姓名：<input type="text" name="username"/><br/>
       密码：<input type="text" name="password"/><br/>
       金额：<input type="text" name="money"/> <br/>
       <input type="submit" value="提交"/>
   </form>
</body>

1.3 创建controller类

@Controller
@RequestMapping("/java")
public class JavaBeanController {

    /**
     * 把数据封装到JavaBean的对象当中
     * @param account
     * @return
     */
    @RequestMapping("/bean")
    public String saveAccount(Account account){
        System.out.println("执行了。。。");
        System.out.println(account);
        return "success";
    }
}

1.4 浏览器访问表单jsp文件

输入所对应类型的信息，不要输中文，会乱码

1.5 点击提交按钮。post成功，客户端响应输出请求的jabaBean对象


注：对于类中类，即Acocunt中的属性引用了一个其他的实体类的情况
在绑定表单时，两个类都要有set ， get方法，想打印还需要有toString方法
在jsp文件中，表单的name属性设置如下：


成功将数据提交到后台。

3.4 配置提交操作发生中文乱码的过滤器

在web.xml文件中配置过滤器解决中文乱码的问题

 <!--配置过滤器-->
  <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>

3.5 请求参数绑定集合类型


提交到后台结果：

3.5 特殊情况自定义类型转换器

springmvc默认有自动类型转换器，我们浏览器输入的数据时String类型的，经过springmvc封装之后，会自动转换为实体类中的数据类型。可是对于日期这种类型可能会因为不同的字符串格式产生异常
1.1 自定义一个类，去实现转换

/**
 * 字符串转日期的类
 */
public class StringToDateConverter implements Converter<String,Date> {
    /**
     * 重写Converter中的方法
     * String source 传入进来字符串
     * @param source
     * @return
     */
    @Override
    public Date convert(String source) {
        if (source == null){
            throw new RuntimeException("请您传入参数");
        }
        //使用DateFormat接口，
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        try {
           return df.parse(source);
        } catch (ParseException e) {
            throw new RuntimeException("数据类型转换出现错误");
        }
    }
}

1.2 将该类注册

<!--配置自定义类型转换器-->
    <bean id="conversionServiceConverter" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters" ref="converters"></property>
    </bean>

    <!--将自定义转换类加入spring容器-->
    <bean id="converters" class="com.itheima.utils.StringToDateConverter"></bean>

1.3 在annotation-driven标签中引用配置的类型转换器

<!--开启springMvc框架注解的支持，开启自定义转换器-->
    <mvc:annotation-driven conversion-service="conversionServiceConverter"></mvc:annotation-driven>

四、SpringMvc常用注解

4.1 RequestParam

RequestParam:把请求中指定名称的参数给控制器中的形参赋值，属性value，请求参数的名称,required为了提供条件，请求参数中是否必须提供此参数。默认值为true，表示必须提供。

@Controller
@RequestMapping("/anno")
public class AnnoController {

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

jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
  <a href="/anno/testRequestParam?name=haha">RequestParam</a>
</body>
</html>

4.2 RequestBody

作用：
　用于获取请求体内容，直接使用得到的是key=value&key=value结构的数据，get请求方式不适用
属性：
　required：是否必须有请求体，默认值是true，当取值为true时，get方式报错，如果取值为false，则get请求方式得到null。　post才存在请求体
　异步会使用到—

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

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

4.3 PathVariable

作用：用于绑定url中的占位符，例如url中/delete/{id}，这个{id}就算是url占位符。URl支持占位符，是springmvc支持rest风格URL的一个重要标志。
属性：value，用于指定url中占位符的名称，required用于设置是否必须提供占位符。

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

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

4.4 SessionAttribute会话域对象

作用：用于多次执行控制器方法之间的参数共享
属性：value：用于指定存入的属性名称，type：同于指定存入的数据类型
session，可以经过多次请求

@Controller
@RequestMapping("/session")
//表示将key为msg的信息也存入到session域中一份
@SessionAttributes("msg")
public class SessionController {
    @RequestMapping("/test")
    public String testSession(Model model){
        System.out.println("testSession执行了。。。。。。。。。。");
        //调用model接口存入参数，key为msg，value为haha
        model.addAttribute("msg","haha");
        System.out.println();
        return "success";
    }
}

 <a href="/session/test">testSession</a>

<%--获取request域中的值--%>
${requestScope.msg}
<%--获取session域中的值,存储方式是map集合--%>
${sessionScope}

测试从session域中存取删除的方法：

/**
 * 使用@SessionAttributes注解，使用value属性，将会话域中的对应的信息存入到session中
 */
@Controller
@RequestMapping("/session")
//表示将key为msg的信息也存入到session域中一份
@SessionAttributes("msg")
public class SessionController {
    /**
     * 调用model的addAttribute将信息存入会话域中
     * @param model
     * @return
     */
    @RequestMapping("/test")
    public String testSession(Model model){
        System.out.println("testSession执行了。。。。。。。。。。");
        //调用model接口存入参数，key为msg，value为haha
        model.addAttribute("msg","haha");
        System.out.println();
        return "success";
    }

    /**
     * 获取会话域中对应的key的值
     * @param modelMap
     * @return
     */
    @RequestMapping("/getAttributes")
    //因为model是一个接口真正执行接口方法的是实现类
    public String getAttributes(ModelMap modelMap){
        System.out.println("getAttributes执行了。。。。。。。。。。");
        //调用modelMpa方法从session中获取值
        String msg = (String) modelMap.get("msg");
        System.out.println(msg);
        return "success";
    }

    /**
     * 删除session中的信息
     * @param status
     * @return
     */
    @RequestMapping("/deleteAttributes")
    //因为model是一个接口真正执行接口方法的是实现类
    public String deleteAttributes(SessionStatus status){
        System.out.println("deleteAttributes。。。。。。。。。。");
        //调用SessionStatus方法清除存入session中的信息
        boolean complete = status.isComplete();
        status.setComplete();
        boolean complete1 = status.isComplete();
        System.out.println("删除前："+complete+"删除后："+complete1);
        return "success";
    }
}

  <%--使用@SessionAttribute注解存入session--%>
  <a href="/session/test">testSession</a>
  <%--使用ModelMap方法获取request域中对应key的value--%>
  <a href="/session/getAttributes">getAttributes</a>
  <%--使用SessionStatus接口实现类SimpleSessionStatus的setComplete方法删除信息--%>
  <a href="/session/deleteAttributes">deleteAttributes</a>

五、SpringMvc的响应

基本开发的流程，发送请求，后台查出来，存入到model对象，转发到页面，从request域中把值取出来。

5.1 String 类型的响应

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

    @RequestMapping("/String")
    public String testString(Model  model){
        System.out.println("执行了、、、、、、、、");

        User user = new User();
        user.setUsername("ss");
        user.setPassword("bb");
        user.setAge(18);
        //model对象
        model.addAttribute("user",user);
        return "success";
    }

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h3>执行成功</h3>
${user.username}
${user.password}
${user.age}
</body>
</html>

5.2 void类型的响应以及请求转发和重定向的使用

请求转发只发送一次请求，可以直接跟具体的路径
重定向发送两次请求，要使用request.getContextPath（）+具体的jsp文件

//当返回值为void时，方法默认去寻找void.jsp文件，找不到会报404错误
    //我们使用重定向进行页面跳转，重定向不会自动调用视图解析器方法，需要手动指定跳转页面的全限定名
    //使用request中的getRequestDispatcher().forward()重定向
    @RequestMapping("/void")
    public void testVoid(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
        System.out.println("执行了、、、、、");
        //编写请求转发的程序
        request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request,response);

        //重定向，发送两次请求,第二次请求要加上请求的相对路径
        //跳转到jsp，通过tomcat生成html页面
        //response.sendRedirect(request.getContextPath()+"/index.jsp");
        //使用return终止方法
        return;
    }
}

请求转发只发送了一次请求

重定向：

直接通过流的方式，响应给浏览器

//3.直接进行响应，控制器直接通过输出流响应给浏览器
        //先设置中文乱码
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");
        //直接响应给浏览器
        response.getWriter().print("你好");
        //使用return终止方法

5.3 ModelAndView

是spring提供的一个对象，用来调整具体的jsp视图

@RequestMapping("/modelandview")
public ModelAndView testmodelandview(){
    //创建ModelAndView对象
    ModelAndView modelAndView = new ModelAndView();
    System.out.println("执行了、、、、、、、、");

    User user = new User();
    user.setUsername("ss");
    user.setPassword("bb");
    user.setAge(18);
    //调用modelAndView对象的方法，存入user对象
    modelAndView.addObject("user", user);

    //指定跳转到哪个页面(会使用视图解析器)
    modelAndView.setViewName("success");
    return modelAndView;
}

5.4 使用关键字来实现转发和重定向

(用的比较少，不能使用视图解析器)
实例代码：

@RequestMapping("/test")
public class UserController {

    @RequestMapping("/forward")
    public String testForward(){
        System.out.println("执行了、、、、、、、、");
        
        //关键字请求转发
        //return "forward:/WEB-INF/pages/success.jsp";
       
       //关键字redirect重定向 
        return "redirect:/index.jsp";
    }

5.5 ResponseBody响应json数据

DispatcherServlet会拦截到所有的资源，导致一个问题就是静态资源如：img、css、js也会被拦截到，从而不能被正常使用。结局办法就是需要配置静态资源不进行拦截，在SpringMvc配置文件添加配置

1. 发送一个ajax请求的步骤
   导入jquery.min.js文件，配置静态资源拦截器，发送请求
   
   两种方式：

<!--开启springmvc扫描-->
    <mvc:annotation-driven></mvc:annotation-driven>
    <!--第一种：配置默认的静态资源过滤器，识别为静态资源不进行拦截-->
    <mvc:default-servlet-handler/>

    <!--第二种：告诉前端控制器,设置静态资源不过滤-->
    <!--<mvc:resources mapping="/js/**" location="/js/**"></mvc:resources>-->
    <!--<mvc:resources mapping="/css/**" location="/css/**"></mvc:resources>-->
    <!--<mvc:resources mapping="/img/**" location="/img/**"></mvc:resources>-->

<head>
    <title>Title</title>
    <script src="js/jquery.min.js"></script>

    <script>
        //页面加载，绑定单击事件
        $(function() {
          $("#btn").click(function () {
             alert("hello");
          });
        });
    </script>
</head>
<body>
  <%--<a href="/test/String">testString</a><br/>
  <a href="/test/void">testVoid</a>
  <a href="/test/modelandview">modelandview</a>
  <a href="/test/forward">testForward</a>--%>

<br/>
<button id="btn">发送ajax请求</button>
</body>

5.6 响应json数据发送ajax请求

编写原生的ajax方法

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

                  }
              });
          });
        });
    </script>

拿到ajax提交的数据

@Controller
@RequestMapping("/user")
public class UserController {
    /**
     * 模拟异步的ajax请求
     */
    @RequestMapping("/testAjax")
    public void testAjax(@RequestBody String body){
        System.out.println("异步的ajax请求");
        System.out.println(body);
    }
 }

执行结果

异步的ajax请求
{"username":"hehe","password":"hehe","age":"30"}

5.7 实现json数据和javaBean的转换

导入依赖坐标

<!--引入jackson的jar包，实现json字符串和javaBean对象互相转换-->
    <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>

编写ajax代码：

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

@Controller
@RequestMapping("/user")
public class UserController {
    /**
     * 模拟异步的ajax请求
     */
    @RequestMapping("/testAjax")
    //@ResponseBody表示将返回的值转为json数据类型
    public @ResponseBody User testAjax(@RequestBody User user){
        System.out.println("异步的ajax请求");
        //将json数据封装到javabean中，要求json的key和javaBean的属性一致
        System.out.println(user);
        //做响应,模拟查询数据库
        user.setUsername("haha");
        user.setAge(40);
        //做响应
        return user;
    }

六、SpringMvc实现文件上传

6.1 传统方式实现文件上传的示例代码

需要导入pom坐标

    <!--引入文件上传的jar包-->
    <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>
  </dependencies>

配置jsp文件

<body>
   <form action="/user/fileUpload" method="post" enctype="multipart/form-data">
       选择文件:<input type="file" name="upload"><br/>
       <input type="submit" name="提交">
   </form>
</body>

配置控制器

@Controller
@RequestMapping("/user")
public class UploadController {
    /**
     * 传统的上传文件的方式
     * @param request
     * @return
     * @throws Exception
     */
    //文件会被封装到request中
    @RequestMapping("/fileUpload")
    public String fileUpload(HttpServletRequest request) throws Exception {
        System.out.println("文件上传");

        //使用fileUpload组建完成文件上传
        //上传的位置
        String realPath = request.getSession().getServletContext().getRealPath("/uploads/");
        //判断该路径是否存在
        File file = new File(realPath);
        if (!file.exists()){
            file.mkdirs();
        }
        //解析request对象，获取上传文件项
        DiskFileItemFactory factory = new DiskFileItemFactory();
        ServletFileUpload upload = new ServletFileUpload(factory);

        //解析request
        List<FileItem> fileItems = upload.parseRequest(request);
        //遍历
        for (FileItem fileItem : fileItems) {
            //进行判断当前的fileItem是不是上传文件项
            if (fileItem.isFormField()){
                //说明普通表单项

            }else{
                //说明上传文件项
                //获取上传文件的名称
                String fileName = fileItem.getName();
                //把文件的名称设置为唯一值，uuid
                String uuid = UUID.randomUUID().toString().replace("-", "");
                fileName = uuid+"_"+fileName;
                //完成文件上传
                fileItem.write(new File(realPath,fileName));
                //删除临时文件
                fileItem.delete();
            }
        }
        return "success";
    }
}

6.2 SpringMvc方式实现文件上传的原理及示例代码

实例代码：

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

springmvc配置文件添加新的组件multipartResolver

<!--配置文件解析器-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>

控制器：

@Controller
@RequestMapping("/user")
public class UploadController {
    /**
     * SpringMvc上传文件的方式
     * @param request
     * @return
     * @throws Exception
     */
    //文件会被封装到request中
    @RequestMapping("/fileUpload1")
    public String fileUpload1(HttpServletRequest request, MultipartFile upload) throws Exception {
        System.out.println("springmvc文件上传");
        //使用fileUpload组建完成文件上传
        //上传的位置
        String realPath = request.getSession().getServletContext().getRealPath("/uploads/");
        //判断该路径是否存在
        File file = new File(realPath);
        if (!file.exists()){
            file.mkdirs();
        }
        //说明上传文件项
        //获取上传文件的名称
        String fileName=upload.getOriginalFilename();
        //把文件的名称设置为唯一值，uuid
        String uuid = UUID.randomUUID().toString().replace("-", "");
        fileName = uuid+"_"+fileName;
        //完成文件上传
        upload.transferTo(new File(realPath,fileName));
        return "success";
    }
}    

6.3 SpringMvc跨服务器方式的文件上传

不同的服务器执行不同的功能，模块化

基本流程，创建两个tomcat服务器，不同的端口号，一个用来发送请求，一个用来作为存储的服务器。
创建额外的服务器：

修改本地tomcat文件中的conf包下的web.xml文件：

编写jsp请求：

   <!--跨服务器文件上传-->
   <form action="/user/fileUpload2" method="post" enctype="multipart/form-data">
       选择文件:<input type="file" name="upload"><br/>
       <input type="submit" name="提交">
   </form>

编写控制器：

@Controller
@RequestMapping("/user")
public class UploadController {
    /**
     * 跨服务器上传
     *
     * @return
     * @throws Exception
     */
    //文件会被封装到request中
    @RequestMapping("/fileUpload2")
    public String fileUpload2(MultipartFile upload) throws Exception {
        System.out.println("跨服务器文件上传。。。。。");
        //定义文件上传服务器路径
        String path = "http://localhost:8081/uploads";
        //说明上传文件项
        //获取上传文件的名称
        String fileName=upload.getOriginalFilename();
        //把文件的名称设置为唯一值，uuid
        String uuid = UUID.randomUUID().toString().replace("-", "");
        fileName = uuid+"_"+fileName;
        //跨服务器上传
        Client client = Client.create();
        //创建客户端对象
        WebResource resource = client.resource(path +"/"+ fileName);
        //和图片服务器进行连接
        resource.put(upload.getBytes());
        //上传文件
        return "success";
    }
 }

注：没有做文件夹判断的话，手动创建uploads文件夹
启动两个服务器，选择文件，提交上传

6.4 SpringMVC使用jersey插件上传文件报错UniformInterfaceException:409/403/405/404

https://blog.csdn.net/Dawn510/article/details/103915414?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&dist_request_id=1328627.24165.16154648411436587&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control

七、SpringMvc异常处理的技术

异常处理的思路：controller层调用service层，service层调用dao层，异常都是向上抛出的，最终由DispatacherServlet找异常处理器进行异常的处理。

7.1 springmvc异常处理

1. 编写异常类

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

    private String message;

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

    public String getMessage() {
        return message;
    }

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

2. 编写异常处理器

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 e) {
        //获取到异常对象
        SysException exception1 = null;

        if (exception1 instanceof SysException){
            exception1 = (SysException)e;
        }else{
            exception1 =  new SysException("系统正在维护");
        }
        //创建ModelAndView对象
        ModelAndView mv = new ModelAndView();
        //获取异常提示信息
        mv.addObject("errorMsg",exception1.getMessage());
        //跳转到error.jsp页面
        mv.setViewName("error");
        return mv;
    }
}

3. 控制器

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

    @RequestMapping("/testException")
    public String testException() throws  Exception {
        System.out.println("初始化。。。。。。。。。。。");
        try {
            //模拟异常
            int i = 10/0;
        } catch (Exception e) {
            //在控制台打印信息
            e.printStackTrace();
            //抛出自定义信息
            throw new SysException("查询所有用户出现错误");
        }
        return "success";
    }
}

4. 配置bean

 <!--配置异常处理器-->
    <bean id="sysExceptionResolver" class="com.itheima.exception.SysExceptionResolver"></bean>

jsp文件

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

error.jsp

<body>
    ${errorMsg}
</body>

八、SpringMvc中的拦截器

8.1 关于spring拦截器的基本概念和作用

SpringMvc中的拦截器类似于Servlet三大组件之一的过滤器filter，用于对处理器进行预处理和后处理，用户可以自定义拦截器来实现特定的功能。
关于拦截器链的概念：Interceptor Chain，拦截器链就是将拦截器按照一定的顺序联结成一条链，在访问被拦截的方法或者字段是，拦截器链中的拦截器按照定义的顺序被调用。一些拦截器过滤器的概念：
过滤器：servlet规范中的一部分，任何java web工程都可以使用
拦截器：SpringMvc框架自己的规范，只有使用了SpringMvc框架的工程才可以使用。
过滤器：在url-pattern中配置了/*后，可以对所有要访问的资源进行拦截
拦截器：只会拦截访问的控制器方法，如果是静态资源是不会访问的
拦截器也是AOP思想的具体应用。我们要是想要实现自定义拦截器要先实现HandlerInterceptor接口。

8.2 自定义拦截器的步骤

1. 编写自定义拦截器类

 /**
 * 自定义拦截器
 */
public class MyInterceptor1 implements HandlerInterceptor {

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

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

2. 控制类

@Controller
@RequestMapping("/user")
public class MyInterceptor implements HandlerInterceptor {

    @RequestMapping("/testIn")
    public String testIn(){
        System.out.println("自定义拦截器执行了");
        return "success";
    }
}

3. 在springmvc的xml文件中配置标签

 <!--配置默认的静态资源过滤器，识别为静态资源不进行拦截-->
    <mvc:default-servlet-handler/>
    <!--配置拦截器-->
    <mvc:interceptors>
        <!--配置拦截器-->
        <mvc:interceptor>
            <!--要拦截的具体的方法-->
            <mvc:mapping path="/user/*"/>
            <!--不要拦截的方法
            <mvc:exclude-mapping path=""/>
            -->
            <!--配置拦截器对象-->
            <bean class="com.itheima.interceptor.MyInterceptor1" />
        </mvc:interceptor>
  </mvc:interceptors>

4. jsp文件

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
   <h3>拦截成功</h3>
   <% System.out.println("success.jsp执行了..."); %>
</body>
</html>

<body>
   <h3>拦截器测试</h3>
   <a href="/user/testIn">testIn</a>
</body>

九、SSM三大框架整合（重点）

9.1 ssm三大框架整合基本思路

使用三层架构即持久层（mybatis），业务层（service），控制层（controller），其中持久层交给mybatis管理，mybatis整合到spring容器中，控制层交给springmvc单独处理。ssm项目是一个web项目，需要在web.xml文件中配置前端控制器dispatcherServlet，配置拦截器，配置监听器。
其中mybatis用来与数据库交互，spring用来管理bean，管理事务管理mybatis，springmvc用来建立客户端与浏览器页面进行交互。

9.2 示例代码演示

1. 创建一个webapp的maven工程
2. 导入依赖

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <spring.version>5.0.2.RELEASE</spring.version>
    <slf4j.version>1.6.6</slf4j.version>
    <log4j.version>1.2.12</log4j.version>
    <mysql.version>5.1.6</mysql.version>
    <mybatis.version>3.4.5</mybatis.version>
  </properties>

  <dependencies>
    <!-- spring -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.6.8</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <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>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>compile</scope>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.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>

    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>

    <!-- log start -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>${log4j.version}</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>${slf4j.version}</version>
    </dependency>

    <!-- log end -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>

    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1.2</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
  </dependencies>

3. 配置web.xml文件（需要让springmvc和spring建立联系，服务器启动即加载spring配置文件applicationContext.xml）

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!--配置监听器，默认加载WEB_INF目录下的文件，因为我们的配置文件都放在resources目录下，需要指定加载-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <!--设置配置文件的参数，指定加载spring配置文件-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>

  <!--配置防止中文乱码拦截器-->
  <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>

  <!--配置前端控制器-->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--配置全局的初始化参数,加载springmvc配置文件-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <!--表示启动服务器就创建dispatcherServlet前端控制器对象
        启动即加载初始化参数，加载springmvc配置文件，扫描spring注解组件进spring容器-->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <!--配置映射-->
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

4. 完善项目的目录结构
   
5. 配置spring配置文件

• 配置注解扫描器，指定要扫描的包，exclude@Controller注解，交给springmvc管理
• 整合mybatis，配置C3P0连接池，配置DataSource数据库信息，配置SqlSessionFactoryBean工厂，配置mapper的包扫描
• 配置spring自带的声明式事务DataSourceTransactionManager,导入dataSource
• 配置AOP事务通知，查询操作设置为只读，对于业务层实现类下的包含任意参数的任意方法进行方法增强。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--开启注解扫描-->
    <context:component-scan base-package="com.itheima">
        <!--将Controller交给springmvc处理-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!--spring整合mybatis框架-->
    <!--配置连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.DriverManagerDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///ssm?characterEncoding=UTF-8"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
    <!--配置sqlSessionFactory工厂-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--配置AccountDao接口所在包-->
    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.itheima.dao"></property>
    </bean>

    <!--配置spring框架的声明式事务管理-->
    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--配置事务通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="find" read-only="true"/>
            <tx:method name="*"></tx:method>
        </tx:attributes>
    </tx:advice>
    <!--配置AOP增强-->
    <aop:config>
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.itheima.service.impl.*ServiceImpl.*(..))"></aop:advisor>
    </aop:config>
</beans>

6. 编写springmvc控制文件，将controller加入springmvc的容器中

• 开启注解扫描，只扫描@Controller注解
• 配置视图解析器，InternalResourceViewResolver，设置解析路径和文件类型
• 过滤静态资源
• 开启springmvc注解支持

<?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">

    <!--开启注解扫描,只扫描controller注解-->
   <context:component-scan base-package="com.itheima">
       <!--只扫描@Controller注解-->
       <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
   </context:component-scan>

    <!--配置视图解析器-->
    <bean id="resourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
         <property name="prefix" value="/WEB-INF/pages/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

    <!--过滤静态资源-->
    <mvc:default-servlet-handler></mvc:default-servlet-handler>

    <!--开启SpringMvc注解的支持-->
    <mvc:annotation-driven></mvc:annotation-driven>
</beans>

9.3 logj4j可有可没有

log4j.rootCategory=info, CONSOLE, LOGFILE

log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

9.4 测试

数据表

create table account(
id int primary key auto_increment,
name varchar(20),
money double
);

dao层

@Repository
public interface AccountDao {

    /**
     * 查询全部
     * @return Account的List集合
     */
    @Select("select * from account")
     List<Account> findAll();

    /**
     * 保存Account
     * @param account
     */
    @Insert("insert into account (name, money)values(#{name},#{money})")
     void saveAccount(Account account);
}

省去service及其实现类
控制层：

@Controller
@RequestMapping("/account")
public class AccountController {
    //注入service
    @Autowired
    private AccountService accountService;

    @RequestMapping("/findAll")
    public String run1(Model model){
        //后台打印
        System.out.println("执行.......................");
        //调用业务层的方法
        List<Account> list = accountService.findAll();
        model.addAttribute("list",list);
        return "list";
    }
    @RequestMapping("/saveAccount")
    public void saveAccount(Account account, HttpServletRequest request, HttpServletResponse response) throws IOException {
        System.out.println("执行.......................");
        //调用业务层的方法
        accountService.saveAccount(account);
        //重定向到findAll方法
        response.sendRedirect(request.getContextPath()+"/account/findAll");
        return;
    }
}

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
   <a href="/account/findAll">findAll</a>

   <form action="/account/saveAccount" method="post">
        姓名：<input type="text" name="name"><br/>
        金额：<input type="text" name="money"><br/>
       <input type="submit" value="提交">
   </form>
</body>
</html>

list.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<html>
<head>
    <title>Title</title>
</head>
<body>
  <h3>成功查询所有账户信息</h3>
  <%--遍历--%>
  <c:forEach items="${list}" var="account">
      ${account.name}
      ${account.money}
  </c:forEach>
</body>
</html>

SSM整合基本完成------------------------------------------------------------------