SpringMVC详解

最新推荐文章于 2024-03-22 12:36:47 发布

置顶 .小罗同学

最新推荐文章于 2024-03-22 12:36:47 发布

阅读量1.6k

点赞数 35

分类专栏： spring 文章标签： mvc spring java

本文链接：https://blog.csdn.net/m0_60500421/article/details/136211589

版权

spring 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

SpringMVC

1、回顾mvc

1.1、什么是mvc

MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。
是将业务逻辑、数据、显示分离的方法来组织代码。
MVC主要作用是降低了视图与业务逻辑间的双向偶合。
MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。

**Model（模型）：**数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao）和服务层（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。

**View（视图）：**负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。

**Controller（控制器）：**接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。

最典型的MVC就是JSP + servlet + javabean的模式。

1.2、MVC的工作原理

用户发请求
Servlet接收请求数据，并调用对应的业务逻辑方法
业务处理完毕，返回更新后的数据给servlet
servlet转向到JSP，由JSP来渲染页面
响应给前端更新后的页面

职责分析：

Controller：控制器

取得表单数据
调用业务逻辑
转向指定的页面

Model：模型

业务逻辑
保存数据的状态

View：视图

显示页面

2、什么是SpringMVC

2.1、概述

查看官方文档:https://docs.spring.io/spring-framework/docs/current/reference/html/web.html

Spring的web框架围绕DispatcherServlet [ 调度Servlet ] 设计。

DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。

2.2、SpringMVC工作原理

在这里插入图片描述

图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。

具体的流程：

用户通过浏览器发起 HttpRequest 请求到前端控制器 (DispatcherServlet)。
DispatcherServlet 将用户请求发送给处理器映射器 (HandlerMapping)。
处理器映射器 (HandlerMapping)会根据请求，找到负责处理该请求的处理器，并将其封装为处理器执行链返回 (HandlerExecutionChain) 给 DispatcherServlet
DispatcherServlet 会根据处理器执行链中的处理器，找到能够执行该处理器的处理器适配器(HandlerAdaptor) --注，处理器适配器有多个
处理器适配器 (HandlerAdaptoer) 会调用对应的具体的 Controller
Controller 将处理结果及要跳转的视图封装到一个对象 ModelAndView 中并将其返回给处理器适配器 (HandlerAdaptor)
HandlerAdaptor 直接将 ModelAndView 交给 DispatcherServlet ，至此，业务处理完毕
业务处理完毕后，我们需要将处理结果展示给用户。于是DisptcherServlet 调用 ViewResolver，将 ModelAndView 中的视图名称封装为视图对象
ViewResolver 将封装好的视图 (View) 对象返回给 DIspatcherServlet
DispatcherServlet 调用视图对象，让其自己 (View) 进行渲染（将模型数据填充至视图中），形成响应对象 (HttpResponse)
前端控制器 (DispatcherServlet) 响应 (HttpResponse) 给浏览器，展示在页面上。

3、第一个SpringMVC程序

3.1、配置版

新建一个Moudle ， springmvc-02-hello ，添加web的支持！
确定导入了SpringMVC 的依赖！

配置web.xml ，注册DispatcherServlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>springmvc</servlet-name>
<!--        **DispatcherServlet**-->
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <!--关联一个springmvc的配置文件:【servlet-name】-servlet-mvc.xml-->
            <param-value>classpath:servlet-mvc.xml</param-value>
        </init-param>
        <!--启动级别-1-->  
        <load-on-startup>1</load-on-startup>
    </servlet>

<!--    注意这里的/是表示所有的请求，但不包括jsp-->
<!--    /*是表示所有的请求，但包括jap-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

编写SpringMVC 的配置文件！名称：springmvc-servlet.xml : [servletname]-springmvc-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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">
<!--    添加映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<!--    添加适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
<!--    添加视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
<!--        前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
<!--        后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
<!--    将自己的类交给SpringIOC容器，注册bean-->
    这个是结合第五步，先把操作业务Controller写了，然后在注册bean
    <bean id="/hello" class="edu.hunan.net.UserHello"/>
</beans>

编写我们要操作业务Controller ，要么实现Controller接口，要么增加注解；需要返回一个ModelAndView，装数据，封视图；

public class UserHello implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView mv = new ModelAndView();
        String  me = "欢迎！第一个SpringMVC程序！！";
//        相当于servlet做的事情
        mv.addObject("msg",me);
        //相当于请转发
        mv.setViewName("hello");
        return mv;
    }
}

编写一个跳转页面的jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>第一个程序</title>
</head>
<body>
${msg}
</body>
</html>

如果出现404，可能jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖！

小结：实际开发中我们并不会这样去写，一般都是使用注解版进行开发,注解版才是SpringMVC中的精髓。

3.2、使用注解配置SpringMVC

在本Maven.xml中配置

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

web.xml内容和配置版内容一致！

注解版需要引入扫描包

(注：这里的添加映射器和适配器可不写，SpringMVC自己写了(前提是开启注解驱动了),只需写视图解析器）

<?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:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <context:component-scan base-package="edu.hunan.net"/>
<!--    <mvc:default-servlet-handler/>--><!--    添加映射器-->
<!--    <mvc:annotation-driven/>--><!--    添加适配器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

使用注解方式，不使用实现Controller接口方式

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller//注解类型用于声明Spring类的实例是一个控制器
public class Hellocller {
    @RequestMapping("/c2/hello")//访问路径
    public String a(Model model){
        model.addAttribute("mas","hello,springmvc!!啊");
        return "hello";
    }
    @RequestMapping("/t1")
    public String b(Model model){
        model.addAttribute("mas","哈哈哈");
        return "hello";
    }
}

编写一个.jsp文件与配置版一致

3.3、小结

实现步骤其实非常的简单：

新建一个web项目
导入相关jar包
编写web.xml , 注册DispatcherServlet
编写springmvc配置文件
接下来就是去创建对应的控制类 , controller
最后完善前端视图和controller之间的对应
测试运行调试.

使用springMVC必须配置的三大件：

处理器映射器、处理器适配器、视图解析器

通常，我们只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可，而省去了大段的xml配置

4、RestFul 风格

4.1、概念

Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

4.2、功能

学习测试

@Controller//自动装配
public class Hellocller {
    //1.Get访问http://localhost:8080/add?a=1&b=3
    @RequestMapping("/add")//访问路径
    public String c( int a, int b, Model model){
        int s =a+b;
        model.addAttribute("mas",s);
        return "hello";
    }
    //2RestFul分格http://localhost:8080/add/1/5
    @RequestMapping("/add/{a}/{b}")//访问路径
    @PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。
    public String a(@PathVariable int a, @PathVariable int b, Model model){
        int s =a+b;
        model.addAttribute("mas",s);
        return "hello";
    }
    //3.SpringMVC默认
    @RequestMapping("/t1")
    public String b(Model model){
        model.addAttribute("mas","哈哈哈");
        return "hello";
    }
}

5、SpringMVC重定向和转发

5.1、通过SpringMVC来实现转发和重定向 - 有视图解析器；

  @RequestMapping("/d1/t1")
    public String d(Model model){
        model.addAttribute("mas","Hello1!");
        return "hello";//必须要有视图解析器
    }

5.2、通过SpringMVC来实现转发和重定向 - 无需视图解析器；

@RequestMapping("/c1/t1")
public String c(Model model){
    model.addAttribute("mas","Hello1!");
    return "/WEB-INF/jsp/hello.jsp";//转发需要绝对路径（也就是从根目录开始）无注释视图解析器
}

5.3、通过SpringMVC来实现转发和重定向 - 有无视图解析器都可以；

@RequestMapping("/a1/t1")
    public String b(Model model){
        model.addAttribute("mas","Hello1!");
        return "forward:/WEB-INF/jsp/hello.jsp";//文件夹嵌套需要绝对路径（也就是从根目录开始）有无注释视图解析器都可以
    }
@RequestMapping("/m1/t1")
    public String a(Model model){
        model.addAttribute("mas","Hello!");
        return "redirect:/index.jsp";//有无注释视图解析器都可以
    }

6、接收请求参数及数据回显

6.1、处理提交数据,接收单个值

//接收单个值
@RequestMapping("/test/{name}")
public String a(@PathVariable String name, Model model){
    System.out.println("名字为"+name);
    model.addAttribute("mas",name);
    return "hello";
}

6.2、接收一个对象

//接收多个值，取对象
@RequestMapping("/b")
public String b( User user,Model model){
    System.out.println(user);
    model.addAttribute("mas",user);
    return "hello";
}

6.3、数据显示到前端

通过ModelAndView（原始实现接口）
通过ModelMap (基本不用)
**通过Model ** (注解)

7.解决乱码问题

7.1、使用SpringMVC提供的过滤器，配置到web.xml即可

<filter>
    <filter-name>encoding</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>encoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

7.2、修改Tomcat配置文件,设置编码(一般只要使用SpringMVC提供的过滤器就可以了)

<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
          connectionTimeout="20000"
          redirectPort="8443" />

8、JSON

8.1、什么是JSON

json是一种前后端分离的数据交换格式
json本质是一个字符串

'{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串

8.2、准备工作

导入jar包

<dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-databind</artifactId>
   <version>2.9.8</version>
</dependency>

8.3、json使用（Jackson使用）

实体类

@Controller
public class Controlle {
    private String name;
    private int id;
    private int age;
    
    这里忽略构造函数、set、get、tostring方法
}

测试类

@Controller

//@RestController 和@ResponseBody的区别:
// @RestController如果有多个方法就不需要每个都写@ResponseBody直接在类的上面写@RestController即可！
//开发中，一般都是@RestController
@RestController

public class ControllerService {
    @RequestMapping("/A")
//    @ResponseBody//跳过视图解析器,返回字符串（无论用哪种，都不会返回页面）
	
    //集合类
    public  String a() throws JsonProcessingException {
        //创建一个json对象
        ObjectMapper m = new ObjectMapper();
        Controlle co = new Controlle("李四",1,2);
        Controlle co1 = new Controlle("李四",1,2);
        Controlle co4 = new Controlle("李四",1,2);
        List<Controlle> list = new ArrayList();
        list.add(co);
        list.add(co1);
        list.add(co4);
        //将我们的对象解析成json格式
        String s = m.writeValueAsString(list);
        return s;
    }
    //普通类
    @RequestMapping("/B")
    public  String b() throws JsonProcessingException {
        //创建一个json对象
        ObjectMapper m = new ObjectMapper();
        Controlle co = new Controlle("李四",1,25);
        //将我们的对象解析成json格式
        String s = m.writeValueAsString(co);
        return s;
    }
}

8.4、json乱码问题

在springmvc-servlet.xml中配置

<mvc:annotation-driven>
   <mvc:message-converters register-defaults="true">
       <bean class="org.springframework.http.converter.StringHttpMessageConverter">
           <constructor-arg value="UTF-8"/>
       </bean>
       <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
           <property name="objectMapper">
               <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                   <property name="failOnEmptyBeans" value="false"/>
               </bean>
           </property>
       </bean>
   </mvc:message-converters>
</mvc:annotation-driven>

9、SSM整合

1、坏境搭建

导入相关的依赖

<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!--        数据库启动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--        数据库连接池-->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>

        <!--        servlet-jsp-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!--        MyBatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.2</version>
        </dependency>

        <!--        Spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.10.RELEASE</version>
        </dependency>
    </dependencies>

    <!--    Maven资源过滤-->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>

    </build>

2、建立基本结构

com.kuang.pojo
com.kuang.dao
com.kuang.service
com.kuang.controller

3、配置相关xml

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <typeAliases>
        <package name="com.kuang.pojo"/>
    </typeAliases>
    <mappers>
       <mapper class="com.kuang.dao.dao"/>
    </mappers>

</configuration>

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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">

    <import resource="spring-dao.xml"/>
    <import resource="spring-service.xml"/>
    <import resource="spring-mvc.xml"/>
</beans>

4、MyBatis层

编写配置文件:database.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?characterEncoding=utf8
jdbc.username=root
jdbc.password=123456

编写数据库对应的实体类 com.kuang.pojo.Books

public class Books {
    private int bookID;
    private String bookName;
    private int bookCounts;
    private String detail;
    
    这里的set,get,等忽略了

编写Dao层的 Mapper接口！

public interface dao {
    //增加一个Book
    int addBook(Books book);

    //根据id删除一个Book
    int deleteBookById(int id);

    //更新Book
    int updateBook(Books books);

    //根据id查询,返回一个Book
    Books queryBookById(int id);

    //查询全部Book,返回list集合
    List<Books> queryAllBook();

    //搜索功能
    Books selectboooks(String select);
}

编写Dao层的 Mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.kuang.dao.dao">

    <!--增加一个Book-->
    <insert id="addBook" parameterType="Books">
      insert into ssmbuild.books(bookName,bookCounts,detail)
      values (#{bookName}, #{bookCounts}, #{detail})
   </insert>

    <!--根据id删除一个Book-->
    <delete id="deleteBookById" parameterType="int">
      delete from ssmbuild.books where bookID=#{bookID}
   </delete>

    <!--更新Book-->
    <update id="updateBook" parameterType="Books">
      update ssmbuild.books
      set bookName = #{bookName},bookCounts = #{bookCounts},detail = #{detail}
      where bookID = #{bookID}
   </update>

    <!--根据id查询,返回一个Book-->
    <select id="queryBookById" resultType="Books">
      select * from ssmbuild.books
      where bookID = #{bookID}
   </select>

    <!--查询全部Book-->
    <select id="queryAllBook" resultType="Books">
      SELECT * from ssmbuild.books
   </select>

<!--    搜索功能-->
    <select id="selectboooks" resultType="Books">
        select * from ssmbuild.books where bookName = #{select}
    </select>
</mapper>

编写Service层的接口和实现类

接口

public interface Book {
    //增加一个Book
    int addBook(Books book);
    //根据id删除一个Book
    int deleteBookById(int id);
    //更新Book
    int updateBook(Books books);
    //根据id查询,返回一个Book
    Books queryBookById(int id);
    //查询全部Book,返回list集合
    List<Books> queryAllBook();

    Books selectboooks(String select);

实现类

public class BookImple implements Book{
    private dao Dao;

    public void setDao(dao dao) {
        Dao = dao;
    }

    @Override
    public int addBook(Books book) {
        return Dao.addBook(book);
    }

    @Override
    public int deleteBookById(int id) {
        return Dao.deleteBookById(id);
    }

    @Override
    public int updateBook(Books books) {
        return Dao.updateBook(books);
    }

    @Override
    public Books queryBookById(int id) {
        return Dao.queryBookById(id);
    }

    @Override
    public List<Books> queryAllBook() {
        return Dao.queryAllBook();
    }

    @Override
    public Books selectboooks(String select) {
        return Dao.selectboooks(select);
    }
}

MyBatis层底层结束

5、Spring层

配置Spring整合MyBatis，我们这里数据源使用c3p0连接池；

我们去编写Spring整合Mybatis的相关的配置文件；spring-dao.xml

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 配置整合mybatis -->
    <!-- 1.关联数据库文件 -->
    <context:property-placeholder location="classpath:database.properties"/>

    <!-- 2.数据库连接池 -->
    <!--数据库连接池
        dbcp 半自动化操作 不能自动连接
        c3p0 自动化操作（自动的加载配置文件 并且设置到对象里面）
    -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!-- 配置连接池属性 -->
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>

        <!-- c3p0连接池的私有属性 -->
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>
        <!-- 关闭连接后不自动commit -->
        <property name="autoCommitOnClose" value="false"/>
        <!-- 获取连接超时时间 -->
        <property name="checkoutTimeout" value="10000"/>
        <!-- 当获取连接失败重试次数 -->
        <property name="acquireRetryAttempts" value="2"/>
    </bean>

    <!-- 3.配置SqlSessionFactory对象 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 配置MyBaties全局配置文件:mybatis-config.xml -->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>

    <!-- 4.配置扫描Dao接口包，动态实现Dao接口注入到spring容器中 -->
    <!--解释 ：https://www.cnblogs.com/jpfss/p/7799806.html-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 注入sqlSessionFactory -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!-- 给出需要扫描Dao接口包 -->
        <property name="basePackage" value="com.kuang.dao"/>
    </bean>

</beans>

Spring整合service层

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

    <!-- 扫描service相关的bean -->
    <context:component-scan base-package="com.kuang.service" />

    <!--BookServiceImpl注入到IOC容器中-->
    <bean id="BookServiceImpl" class="com.kuang.service.BookImple">
        <property name="dao" ref="dao"/>
    </bean>

    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource" />
    </bean>

</beans>

Spring层结束

6、SpringMVC层

添加web项目

配置Web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!--DispatcherServlet-->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <!--一定要注意:我们这里加载的是总的配置文件，之前被这里坑了！-->
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--encodingFilter-->
    <filter>
        <filter-name>encodingFilter</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>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!--Session过期时间-->
    <session-config>
        <session-timeout>15</session-timeout>
    </session-config>

</web-app>

配置SpringMVC.xml

<?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:mvc="http://www.springframework.org/schema/mvc"
       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/mvc
   https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 配置SpringMVC -->
    <!-- 1.开启SpringMVC注解驱动 -->
    <mvc:annotation-driven />
    <!-- 2.静态资源默认servlet配置-->
    <mvc:default-servlet-handler/>

    <!-- 3.配置jsp 显示ViewResolver视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 4.扫描web相关的bean -->
    <context:component-scan base-package="com.kuang.controller" />

</beans>

Spring配置整合文件，applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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">

    <import resource="spring-dao.xml"/>
    <import resource="spring-service.xml"/>
    <import resource="spring-mvc.xml"/>
</beans>

7、增删改查

BookController 类编写，方法一：查询全部书籍

@Controller
@RequestMapping("/book")
public class BookController {
        @Autowired
        @Qualifier("BookServiceImpl")
        private Book book;
        @RequestMapping("/allBook")
        public String list(Model model) {
            List<Books> list = book.queryAllBook();
            model.addAttribute("list", list);
            return "allBook";
        }

编写首页Index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<!DOCTYPE HTML>
<html>
<head>
   <title>首页</title>
   <style type="text/css">
       a {
           text-decoration: none;
           color: black;
           font-size: 18px;
      }
       h3 {
           width: 180px;
           height: 38px;
           margin: 100px auto;
           text-align: center;
           line-height: 38px;
           background: deepskyblue;
           border-radius: 4px;
      }
   </style>
</head>
<body>

<h3>
   <a href="${pageContext.request.contextPath}/book/allBook">点击进入列表页</a>
</h3>
</body>
</html>

allBook.jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>书籍展示</title>
    <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<h2>
   <div class="container">
       <div class="col-md-12 column">
           <div class="row">
               <div class="page-header">
                   <h1>
                       <small>书籍展示——————展示书籍</small>
                   </h1>
               </div>
           </div>
       </div>
       <div class="row">
           <div class="col-md-4 column">
               <a class="btn btn-primary" href ="${pageContext.request.contextPath}/book/toBook">新增</a>
               <a class="btn btn-primary" href ="${pageContext.request.contextPath}/book/allselectBooks">显示全部书籍</a>
           </div>
           <div class="col-md-4 column">
               <form action="${pageContext.request.contextPath}/book/select" method="post">
                    <span>${a}</span>
                   <input type="text" class="form-control" name="select" placeholder="请输入书籍名称"/>
                   <input type="submit" value="查询" class="btn btn-warning">
               </form>
           </div>
       </div>
       <div class="bs-example" data-example-id="hoverable-table">
           <table class="table table-hover">
               <thead>
               <tr>
                   <th>书籍编号</th>
                   <th>书籍名称</th>
                   <th>书籍数量</th>
                   <th>书籍详情</th>
                   <th>操作</th>
               </tr>
               </thead>
               <tbody>
               <c:forEach var="Books" items="${list}">
                   <tr>
                       <td>${Books.bookID}</td>
                       <td>${Books.bookName}</td>
                       <td>${Books.bookCounts}</td>
                       <td>${Books.detail}</td>
                       <td>
                           <a class="btn btn-success" href="${pageContext.request.contextPath}/book/toUpdata?id=${Books.bookID}">修改</a>
                           <a class="btn btn-danger" href="${pageContext.request.contextPath}/book/delete?id=${Books.bookID}">删除</a>
                       </td>
                   </tr>
               </c:forEach>
               </tbody>
           </table>
       </div>
   </div>
</h2>
</body>
</html>

、BookController 类编写，方法二：添加书籍

//        新增书籍
    @RequestMapping("/toBook")
    public String addBook(){
       return "addbook";
    }

//    获取并且提交书籍
    @RequestMapping("/onebook")
    public String addBoos(Books books){
        System.out.println(books);
            book.addBook(books);
            return "redirect:/book/allBook";
    }

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>新增书籍</title>
    <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<h2>
    <div class="container">
        <div class="col-md-12 column">
            <div class="row">
                <div class="page-header">
                    <h1>
                        <small>新增书籍</small>
                    </h1>
                </div>
            </div>
        </div>
        <form action="${pageContext.request.contextPath}/book/onebook" method="post">
            <div class="form-group">
                <label >书籍名称</label>
                <input type="text" name="bookName" class="form-control">
            </div>
            <div class="form-group">
                <label >书籍数量</label>
                <input type="text" name="bookCounts" class="form-control">
            </div>
            <div class="form-group">
                <label >书籍详情</label>
                <input type="text" name="detail" class="form-control">
            </div>
            <button type="submit" class="btn btn-warning">提交</button>
        </form>
    </div>
</h2>
</body>
</html>

BookController 类编写，方法三：修改书籍

//    跳转到修改书籍页面
    @RequestMapping("/toUpdata")
    public String uadateBook(int id,Model model){
        Books books = book.queryBookById(id);
        System.out.println(books);
        model.addAttribute("upda",books);
        return "update";
    }
//    修改书籍
    @RequestMapping("/updateto")
    public String updateBook (Books books) {
       book.updateBook(books);
        return "redirect:/book/allBook";
    }

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>修改书籍</title>
    <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<h2>
    <div class="container">
        <div class="col-md-12 column">
            <div class="row">
                <div class="page-header">
                    <h1>
                        <small>修改书籍</small>
                    </h1>
                </div>
            </div>
        </div>
        <form action="${pageContext.request.contextPath}/book/updateto" method="post">
            <input type="hidden" name="bookID" value="${upda.bookID}"/>
            <div class="form-group">
                <label >书籍名称</label>
                <input type="text" name="bookName" class="form-control" value="${upda.bookName}">
            </div>
            <div class="form-group">
                <label >书籍数量</label>
                <input type="text" name="bookCounts" class="form-control" value="${upda.bookCounts}">
            </div>
            <div class="form-group">
                <label >书籍详情</label>
                <input type="text" name="detail" class="form-control" value="${upda.detail}">
            </div>
            <button type="submit" class="btn btn-warning">提交</button>
        </form>
    </div>
</h2>
</body>
</html>

BookController 类编写，方法四：删除书籍

    //删除页面
    @RequestMapping("/delete")
    public String delete(int id){
       book.deleteBookById(id);
        return "redirect:/book/allBook";
    }

<a class="btn btn-danger" href="${pageContext.request.contextPath}/book/delete?id=${Books.bookID}">删除</a>

BookController 类编写，方法五：新增搜索功能

//    跳转到查询页面
    @RequestMapping("/select")
    public String select(String select,Model model){
        Books selectboooks = book.selectboooks(select);
        List<Books> list = new ArrayList();
        list.add(selectboooks);
        if (selectboooks==null){
            list=book.queryAllBook();
            model.addAttribute("a","未找到");
        }
        model.addAttribute("list", list);
        return "allBook";
    }

<div class="col-md-4 column">
               <form action="${pageContext.request.contextPath}/book/select" method="post">
                    <span>${a}</span>
                   <input type="text" class="form-control" name="select" placeholder="请输入书籍名称"/>
                   <input type="submit" value="查询" class="btn btn-warning">
               </form>
           </div>

10、拦截器

10.1、什么是拦截器()

拦截器
- 拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用
- 拦截器只会拦截访问的控制器方法，如果访问的是jsp/html/css/image/js是不会进行拦截的

10.2、自定义拦截器(判断用户是否登录)

想要自定义拦截器，必须实现 HandlerInterceptor 接口。

public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//        如果是登录页面则放行
        if(request.getRequestURI().contains("a1")){
            return true;
        }
        if(request.getRequestURI().contains("login")){
            return true;
        }
        HttpSession session = request.getSession();
//        如果是已经登录过的则放行
        if(session.getAttribute("username")!=null){
            return true;
        }
//        用户没有登录直接返回到登录页面
        request.getRequestDispatcher("/WEB-INF/jsp/main.jsp").forward(request,response);
        return false;
    }
}

配置拦截器

<!--    拦截器配置-->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean id="Interceptor" class="edu.hunan.Interceptor.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

编写controller类


@Controller
public class Mycontroller {

//    跳转到登录页面
    @RequestMapping("a1")
    public String a(){
        return "main";
    }

//    提交登录页面
    @RequestMapping("login")
    public String b(HttpSession session, String username, int password){
        session.setAttribute("username",username);
        return "login";
    }

    //直接跳转到首页
    @RequestMapping("a2")
    public String b(){
        return "login";
    }

    //注销页面
    @RequestMapping("c")
    public String c(HttpSession session){

        session.removeAttribute("username");
        return "main";
    }
}