SSM框架整合

最新推荐文章于 2024-09-23 16:30:37 发布

chenhui_Sun

最新推荐文章于 2024-09-23 16:30:37 发布

阅读量127

点赞数 1

分类专栏： SSM框架整合

本文链接：https://blog.youkuaiyun.com/weixin_45608165/article/details/114932206

版权

SSM框架整合专栏收录该内容

1 篇文章

订阅专栏

环境要求

idea编译器
mysql8.0+
Tomcat 8
Maven 3.6.3

要求：需要熟练掌握mysql数据库、spring框架、springmvc框架、JavaWeb及Mybatis框架知识，前端知识

数据库环境搭建

创建一个存放书籍数据的数据库表

CREATE DATABASE `ssmbuild`;

USE `ssmbuild`;

DROP TABLE IF EXISTS `books`;

CREATE TABLE `books` (
`bookID` INT(10) NOT NULL AUTO_INCREMENT COMMENT '书id',
`bookName` VARCHAR(100) NOT NULL COMMENT '书名',
`bookCounts` INT(11) NOT NULL COMMENT '数量',
`detail` VARCHAR(200) NOT NULL COMMENT '描述',
KEY `bookID` (`bookID`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT  INTO `books`(`bookID`,`bookName`,`bookCounts`,`detail`)VALUES
(1,'Java',1,'从入门到放弃'),
(2,'MySQL',10,'从删库到跑路'),
(3,'Linux',5,'从进门到进牢');

项目基本环境搭建

新建Maven项目，添加web支持
在pom.xml导入需要用到的依赖

<!--        数据库连接驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>
<!--    jsp和Servlet和jstl表达式依赖-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2.1-b03</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>3.0-alpha-1</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
<!--        springMVC依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.1</version>
        </dependency>
<!--       spring-jdbc操作数据库-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.1</version>
        </dependency>
<!--        mybatis和spring框架整合-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.5</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>
<!--        springAOP横切织入依赖-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>
<!--单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
<!--       数据库连接池-->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.5</version>
        </dependency>
<!--        lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>

静态资源导出问题设置

<build>
        <!--   静态资源导出问题
        目的是把src/main/java和src/main/resource目录中的xml文件和properties配置文件包含到输出结果中，
        输出到classes目录中-->
        <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>

在项目中建立基本的结构和配置框架

com.chenhui.pojo
com.chenhui.controller
com.chenhui.dao
com.chenhui.service

Mybatis层编写

数据库配置文件 jdbc.properties

database.driver=com.mysql.cj.jdbc.Driver
database.url=jdbc:mysql://localhost:3306/ssmbuild?serverTimezone=PRC
database.username=root
database.password=root

编写Mybatis核心配置文件


<?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>
<!--日志工厂设置-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
<!--实体类别名设置-->    
    <typeAliases>
        <typeAlias type="com.chenhui.pojo.Book"/>
    </typeAliases>

</configuration>

编写数据库对应的实体类com.chenhui.pojo.Book

使用Lombok插件

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Book {
    //书id
    private int bookID;
    //书名
    private String bookName;
    //书数量
    private String bookCounts;
    //书描述
    private String detail;

}

编写dao层的Bookmapper接口

public interface BookMapper {

    //查询所有的书籍
    List<Book> queryList();

    //更新书籍
    int updateBook(Book book);

    //添加书籍
    int addBook(Book book);

    //删除书籍
    int deleteBook(@Param("bookID") int bookID);

    //根据id查询书籍
    Book queryById(@Param("bookID")int bookID);

    //根据name查询书籍
    List<Book> queryByName(@Param("bookName")String bookName);
}

编写接口对应的Bookmapper.xml

<mapper namespace="com.chenhui.dao.BookMapper">
<!--    查询所有书籍的SQL语句-->
<!--    id，表示与BookMapper中的方法名一一匹配-->
<!--    resultType，表示结果类型与javabean中的实体类一一匹配-->
    <select id="queryList" resultType="book">
        select bookID,bookName,bookCounts,detail from books
    </select>
<!--插入一本书籍的SQL语句-->
    <insert id="addBook" parameterType="book" >
        insert into books (bookName,bookCounts,detail) values(#{bookName},#{bookCounts},#{detail})
    </insert>
<!--根据书籍id查询书籍的SQL语句-->
    <select id="queryById" parameterType="_int" resultType="book">
        select bookID,bookName,bookCounts,detail from books where bookID=#{bookID}
    </select>
<!--更新一本书籍的SQL语句-->
    <update id="updateBook" parameterType="book">
        update books set bookName=#{bookName},bookCounts=#{bookCounts},detail=#{detail}
        where bookID=#{bookID}
    </update>
<!--删除一本书籍的SQL语句-->
    <delete id="deleteBook" parameterType="_int">
        delete from books where bookID =#{bookID}
    </delete>
<!--根据书籍的名字查询书籍的SQL语句-->
    <select id="queryByName" parameterType="String" resultType="book">
        select bookID,bookName,bookCounts,detail from books where bookName like "%"#{bookName}"%"
    </select>
</mapper>

编写service层的接口和实现类

package com.chenhui.service;

import com.chenhui.pojo.Book;
import org.apache.ibatis.annotations.Param;

import java.util.List;

//BookService:底下需要去实现,调用dao层
public interface BookService {

    //查询所有的书籍
    List<Book> queryList();

    //更新书籍
    int updateBook(Book book);

    //添加书籍
    int addBook(Book book);

    //删除书籍
    int deleteBook(int bookID);

    //根据id查询书籍
    Book queryById(int bookID);

    //根据name查询书籍
    List<Book> queryByName(String bookName);
}

service层接口实现类：

package com.chenhui.service;

import com.chenhui.dao.BookMapper;
import com.chenhui.pojo.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Auther Sunshine
 * @Date 2021/3/8 21:16
 */
//将该类的bean交给springIOC容器管理
@Service("bookService")
public class BookServiceImpl implements BookService{

    //自动根据bean注入dao层的bookMapper值
    @Autowired
    @Qualifier("bookMapper")
    private BookMapper bookMapper;

    //以下方法调用都是service层调用dao层的方法
    
    public List<Book> queryList() {
        return bookMapper.queryList();
    }

    public int updateBook(Book book) {
        return bookMapper.updateBook(book);
    }

    public int addBook(Book book) {
        return bookMapper.addBook(book);
    }

    public int deleteBook(int bookID) {
        return bookMapper.deleteBook(bookID);
    }

    @Override
    public Book queryById(int bookID) {
        return bookMapper.queryById(bookID);
    }

    @Override
    public List<Book> queryByName(String bookName) {
        return bookMapper.queryByName(bookName);
    }
}

Spring层编写

配置Spring整合Mybatis框架，数据源使用c3p0连接池
编写spring整合Mybatis的相关配置文件：spring-dao.xml




<!--    绑定jdbc.properties配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--    创建数据库连接池对象交给spring来管理-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${database.driver}"/>
        <property name="jdbcUrl" value="${database.url}"/>
        <property name="user" value="${database.username}"/>
        <property name="password" value="${database.password}"/>
        <!--        可以配置一些c3p0的其他属性-->
        <property name="maxPoolSize" value="20"></property>
        <property name="minPoolSize" value="10"></property>
        <!--        关闭连接后不自动提交-->
        <property name="autoCommitOnClose" value="false"></property>
        <!--        获取连接的超时时间-->
        <property name="checkoutTimeout" value="10000"></property>
        <!--        当获取连接失败的重试次数-->
        <property name="acquireRetryAttempts" value="2"></property>
    </bean>
    <!-- 配置SqlSessionFactory对象交个spring来管理 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 绑定Mybatis全局配置文件:mybatis.xml -->
        <property name="configLocation" value="classpath:mybatis.xml"/>
    </bean>


<!--配置扫描Dao接口包，动态实现Dao接口注入到spring容器中-->
<!--MapperScannerConfigurer ,它将会查找类路径下的映射器并自动将它们创建成MapperFactoryBean-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <!--使用sqlSessionFactoryBeanName属性来设置正确的bean名称来使用,注入sqlSessionFactory
    这就是它如何来配置的,注意bean的名称是必须的,而不是bean的引用,因此,value属性在这里替代通常的ref-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--basePackage 属性是让你为映射器接口文件设置基本的包路径,需要扫描Dao接口包
            你可以使用分号或逗号作为分隔符设置多于一个的包路径,
            每个映射器将会在指定的包路径中递归地被搜索到-->
        <property name="basePackage" value="com.chenhui.dao"/>
    </bean>

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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/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">

    <!-- 开启注解扫描器，扫描service层下相关的bean对象 -->
    <context:component-scan base-package="com.chenhui.service"/>


    <!-- 配置事务管理器，交给SpringIOC容器管理 -->
    <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--    引入SpringIOC容器中的数据库连接池对象进行装配    -->
        <property name="dataSource" ref="dataSource"/>
    </bean>


    
        <!-- 配置事务通知，引用事务管理器内的方法来管理事务，该通知可以对特定的方法进行特定的事务控制 -->
<!--    引用SpringIOC容器中已经注册的事务管理器-->
        <tx:advice id="txAdvice" transaction-manager="dataSourceTransactionManager">
            <tx:attributes>
    <!--            如果方法名是query开头的，设置只读-->
                <tx:method name="query*" read-only="true"/>
<!--                所有的方法名，如果没有事务支持，则默认添加一个新事务-->
                <tx:method name="*" isolation="DEFAULT"/>
            </tx:attributes>
        </tx:advice>
    <!--    aop事务支持-->
        <!-- 配置 AOP增强，把通知具体通知到某些类上 -->
        <aop:config>
<!--            引用事务通知，并配置切入点，即哪些包下，哪些类下，哪些方法需要方法增强-->
            <aop:advisor advice-ref="txAdvice" pointcut="execution( * com.chenhui.service.*Impl.*(..))"/>
        </aop:config>


</beans>

SpringMVC层

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">
<!--注册SpringMVC的Servlet-DispatcherServlet-->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
<!--            绑定DispatcherServlet启动时需要加载配置文件，我们一般加载总配置文件-->
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationcontext.xml</param-value>
        </init-param>
<!--        配置需要加载的配置文件的启动等级想·-->
        <load-on-startup>1</load-on-startup>
    </servlet>
<!--    配置DispatcherServlet请求分发的URL路径-->
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
<!--配置字符编码过滤器，用SpringMvc提供的CharacterEncodingFilter过滤器-->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
<!--            绑定该类的属性encoding-->

            <param-name>encoding</param-name>
<!--            为属性encoding设置值为utf-8-->
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
<!--配置字符过滤器需要过滤的那些URL请求，这里配置所有的请求，都会进行过滤字符编码集-->
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>


<!--配置欢迎页面-->
    <welcome-file-list>
        <welcome-file>main.jsp</welcome-file>
    </welcome-file-list>
    <!--Session过期时间,15分钟获取-->
    <session-config>
        <session-timeout>15</session-timeout>
    </session-config>
</web-app>

spring-mvc.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
        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">

<!--    静态资源默认servlet配置，即静态资源过滤-->
    <mvc:default-servlet-handler/>

    <!--开启mvc注解驱动-->
    <mvc:annotation-driven>
<!--        配置json字符中文乱码问题-->
        <mvc:message-converters register-defaults="true">
<!--            StringHttpMessageConverter转换器-->
            <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>
<!--开启注解扫描包，将相应的包下的bean交给SpringIOC容器管理-->
    <context:component-scan base-package="com.chenhui.controller"/>


<!--配置视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="viewResolver">
<!--        配置jsp视图可以使用jstl表达式进行取值及国际化支持-->
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
<!--        配置jsp前缀所在的包路径-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
<!--        配置jsp后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
		<!--导入spring-dao.xml、spring-service.xml、spring-mvc.xml相应的配置文件 -->
        <import resource="classpath:spring-dao.xml"/>
        <import resource="classpath:spring-service.xml"/>
        <import resource="classpath:spring-mvc.xml"/>
</beans>

编写Controller层类及视图层

BookController类编写：方法一：查询全部书籍allBooks()

//将该类交给SpringIOC容器管理
@Controller
//配置请求路径
@RequestMapping("/book")
public class BookController {

    //将service层的(指定名字)实现类注入到该属性中
    @Autowired
    @Qualifier("bookService")
    private BookService bookService;


    @RequestMapping("/allBook")
    //查询全部书籍的方法
    public String allBooks(Model model){
        //调用service层进行查询数据
        List<Book> books = bookService.queryList();
        //将查询的数据存入model对象中
        model.addAttribute("list",books);
        //返回视图:http://localhost:80/WEB-INF/jsp/allBook.jsp
        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

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
       <title>书籍列表</title>
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <!-- 引入 Bootstrap -->
       <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>

<div class="container">
       <div class="row clearfix">
           <div class="col-md-12 column">
               <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/toAddBook">新增书籍</a>
               <a class="btn btn-primary" href="${pageContext.request.contextPath}/book/allBook">显示全部书籍</a>
           </div>
        <div class="col-md-8 column">
            <form class="form-inline" action="${pageContext.request.contextPath}/book/queryByName" method="post" style="float:right">
                <span style="color:red;font-weight: bold">${error}</span>
                <input type="text" name="bookName" placeholder="请输入要查询的书籍名称" class="form-control">
                <input type="submit" value="查询" class="btn btn-primary">
            </form>
        </div>
       </div>
       <div class="row clearfix">
           <div class="col-md-12 column">
               <table class="table table-hover table-striped">
                   <thead>
               <tr>
                       <th>书籍编号</th>
                       <th>书籍名字</th>
                       <th>书籍数量</th>
                       <th>书籍详情</th>
                       <th>操作</th>
                   </tr>
               </thead>
                   <tbody>
               <c:forEach var="book" items="${requestScope.get('list')}">
                       <tr>
                           <td>${book.getBookID()}</td>
                           <td>${book.getBookName()}</td>
                           <td>${book.getBookCounts()}</td>
                           <td>${book.getDetail()}</td>
                           <td>
                               <a href="${pageContext.request.contextPath}/book/toUpdateBook?id=${book.getBookID()}">更改</a> |
                               <a href="${pageContext.request.contextPath}/book/del/${book.getBookID()}">删除</a>
                           </td>
                       </tr>
                   </c:forEach>
               </tbody>
               </table>
           </div>
       </div>
</div>

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

//跳转到添加书籍的页面
    @RequestMapping("/toAddBook")
    public String toAddBook(){
        return "addBook";
    }
    //执行添加书籍的业务并重定向到展示所有书籍的页面
    @PostMapping("/addBook")
    public String addBook(Book book){
        bookService.addBook(book);
        return "redirect:allBook";
    }

添加书籍的页面：addBook.jsp

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<html>
<head>
       <title>新增书籍</title>
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <!-- 引入 Bootstrap -->
       <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
       <div class="row clearfix">
           <div class="col-md-12 column">
               <div class="page-header">
                   <h1>
                       <small>新增书籍</small>
                   </h1>
               </div>
           </div>
       </div>
       <form action="${pageContext.request.contextPath}/book/addBook" method="post">
           书籍名称：<input type="text" name="bookName"><br><br><br>
           书籍数量：<input type="text" name="bookCounts"><br><br><br>
           书籍详情：<input type="text" name="detail"><br><br><br>
           <input type="submit" value="添加">
       </form>
</div>

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

  //跳转到书籍修改页面
    @RequestMapping("/toUpdateBook")
    public String toUpdateBook(int id,Model model){
        Book book = bookService.queryById(id);
        System.out.println(book);
        model.addAttribute("book",book);
        return "updateBook";
    }
    //执行修改书籍的业务并重定向到展示所有书籍的页面
    @PostMapping("/updateBook")
    public String updateBook(Book book){
        bookService.updateBook(book);
        return "redirect:allBook";
    }

修改书籍页面：updateBook.jsp

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
       <title>修改信息</title>
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <!-- 引入 Bootstrap -->
       <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
       <div class="row clearfix">
           <div class="col-md-12 column">
               <div class="page-header">
                   <h1>
                       <small>修改信息</small>
                   </h1>
               </div>
           </div>
       </div>
       <form action="${pageContext.request.contextPath}/book/updateBook" method="post">
           <input type="hidden" name="bookID" value="${book.getBookID()}"/>
           书籍名称：<input type="text" name="bookName" value="${book.getBookName()}"/>
           书籍数量：<input type="text" name="bookCounts" value="${book.getBookCounts()}"/>
           书籍详情：<input type="text" name="detail" value="${book.getDetail() }"/>
           <input type="submit" value="提交"/>
       </form>
</div>

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

 //删除书籍的业务并重定向到展示所有书籍的方法
    @GetMapping("/del/{bookID}")
    public String deleteBook(@PathVariable("bookID")int bookID){
        bookService.deleteBook(bookID);
        return "redirect:/book/allBook";
    }

BookController类编写：方法四：根据书籍名称进行查询书籍

 //根据书籍名称进行查询书籍
    @PostMapping("/queryByName")
    public String queryByName(String bookName,Model model){
        List<Book> list=bookService.queryByName(bookName.trim());
        if (bookName.trim().equals("")|| bookName==null){
            return "redirect:/book/allBook";
        }else if (list.size()==0){
            model.addAttribute("error","未找到");

        } else{
            model.addAttribute("list",list);

        }
        return "allBook";
    }

启动项目测试成功即可！
项目架构图

在这里插入图片描述

使用第二套数据源进行整合SSM框架

mybatis.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.chenhui.entity" />
    </typeAliases>

    <plugins>
        <!--
			3.4.2版本pagehelper
			<plugin interceptor="com.github.pagehelper.PageHelper">
				<property name="dialect" value="mysql"/>
			</plugin>
			 -->
        <!--5.0版本pagehelper -->
        <!--mybatis分页插件-->
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <property name="helperDialect" value="mysql"/>
        </plugin>

    </plugins>
    <!--注册mapper所在的包路径-->
    <mappers>
        <package name="com.chenhui.dao"/>
    </mappers>
</configuration>

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 http://www.springframework.org/schema/context/spring-context.xsd">

<!--    配置绑定jdbc.properties配置文件路径-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!-- 定义数据源Bean -->
    <!-- 加载数据库配置信息 -->
    <!-- Druid -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!-- 注册SqlSessionFactoryBean -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--        需要引入数据源-->
        <property name="dataSource" ref="dataSource" />
        <!-- 自动扫描mappers.xml文件 -->
        <property name="mapperLocations" value="classpath:com/chenhui/dao/*.xml" />
<!--        绑定mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis.xml"></property>
    </bean>
    <!--MapperScannerConfigurer ,它将会查找类路径下的映射器并自动将它们创建成MapperFactoryBean-->
    <!-- DAO接口所在包名，Spring会自动查找其下的类 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--basePackage 属性是让你为映射器接口文件设置基本的包路径,
            你可以使用分号或逗号作为分隔符设置多于一个的包路径,
            每个映射器将会在指定的包路径中递归地被搜索到-->
        <property name="basePackage" value="com.chenhui.dao" />
        <!--使用sqlSessionFactoryBeanName属性来设置正确的bean名称来使用,
     这就是它如何来配置的,注意bean的名称是必须的,而不是bean的引用,因此,value属性在这里替代通常的ref-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
    </bean>
</beans>

spring-service.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:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       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/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<!--扫描service下的包-->
    <!--    将我们的所有业务类，注入到spring，可以通过配置也可以通过注解-->
    <context:component-scan base-package="com.chenhui.service"/>
    
<!--    声明式事务配置-->
    <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--        需要注入数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--    aop事务支持-->
    <!-- 配置事务通知，引用事务管理器内的方法来管理事务，该通知可以对特定的方法进行特定的事务控制 -->
    <tx:advice id="txAdvice" transaction-manager="dataSourceTransactionManager">
        <tx:attributes>
<!--            SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。-->
            <!--            如果方法名是find、get、select、query开头的，设置只读-->
<!--            REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择,也是默认的-->
            <tx:method name="get*" read-only="true" propagation="SUPPORTS" />
            <tx:method name="find*" read-only="true" propagation="SUPPORTS" />
            <tx:method name="select*" read-only="true" propagation="SUPPORTS" />
            <tx:method name="query*" read-only="true" propagation="SUPPORTS" />
            <tx:method name="add*" propagation="REQUIRED" isolation="DEFAULT"/>
            <tx:method name="insert*"  propagation="REQUIRED" isolation="DEFAULT"/>
            <tx:method name="save*"  propagation="REQUIRED" isolation="DEFAULT"/>
            <tx:method name="delete*" propagation="REQUIRED" isolation="DEFAULT"/>
            <tx:method name= "update*" propagation="REQUIRED" isolation="DEFAULT"/>
        </tx:attributes>
    </tx:advice>
    <!-- 配置 AOP 增强，把通知具体通知到某些类上的方法 -->
    <aop:config>
        <aop:advisor advice-ref="txAdvice" pointcut=" execution(* com.chenhui.service..*.*(..))"/>
    </aop:config>
</beans>

spring-mvc.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:p="http://www.springframework.org/schema/p"
       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">
    <!--开启注解扫描包，将相应的包下的bean交给SpringIOC容器管理-->
    <context:component-scan base-package="com.chenhui.controller"/>
    <!--    静态资源默认servlet配置，即静态资源过滤，不会被DispatchServlet拦截请求-->
    <mvc:default-servlet-handler/>

    <!--开启mvc注解驱动-->
    <mvc:annotation-driven>
        <!--        配置json字符中文乱码问题-->
        <mvc:message-converters register-defaults="true">
            <!--            StringHttpMessageConverter转换器-->
            <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>
<!--    表示浏览器对静态资源的访问，
mapper对应的是url请求/js/**所有下面的资源都会和location服务端/js/目录下面的资源一一对应访问-->
    <mvc:resources mapping="/js/**" location="/js/"/>
    <!--配置视图解析器-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--        配置jsp前缀所在的包路径-->
        <property name="prefix" value="/WEB-INF/jsp/"></property>
        <!--        配置jsp后缀-->
        <property name="suffix" value=".jsp"></property>
    </bean>
</beans>

其他配置文件和第一种整合相同