2022.7.30 整合SSM

整合SSM

整合： dao：1、编写mybatis配置文件将： 1、写入要扫描的实体类包 2、写入mapper 3、写好dao层的接口和xml 2、编写database文件：driver，url，user，password 3、编写连接mybatis的spring-dao.xml配置文件： 1、关联数据库配置文件 2、写入数据库连接池：c3p0,jdbc 3、运用SqlSessionFactoryBean加入连接池和mybatis配置文件创建SqlSessionFactory 4、运用MapperScannerConfigurer 加入SqlSessionFactory，和dao层的接口配置dao扫描包 service：1、编写spring-service.xml配置文件： 1、创建service层的包和类 2、引入要扫描service层的包 3、注入service的实现类 4、写入业务管理器 controller：1、对项目添加web模块并写入jsp目录，对web.xml配置DispatcherServlet和静态资源过滤器 2、编写spring-MVC.xml配置文件： （非注解） 1、引入要扫描的controller包 2、配置适配器和映射器 3、配置视图解析器 4、配置静态资源过滤器 （注解） 1、引入要扫描的controller包 2、配置注解驱动 3、配置静态资源过滤器 4、配置视图解析器 最后：将三层spring配置import进applicationContext.xml文件

 

 

iron2Coulm补充：最后添加lib

数据库环境

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

 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,'从进门到进牢');

基本环境搭建

 

 

1、新建一Maven项目！ssmbuild ， 添加web的支持

2、导入相关的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.xing</groupId>
     <artifactId>ssm</artifactId>
     <version>1.0-SNAPSHOT</version>
 ​
     <properties>
         <maven.compiler.source>8</maven.compiler.source>
         <maven.compiler.target>8</maven.compiler.target>
     </properties>
 ​
     <dependencies>
         <!--Junit-->
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>4.12</version>
         </dependency>
         <!--数据库驱动-->
         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
             <version>8.0.29</version>
         </dependency>
         <!-- 数据库连接池 -->
         <dependency>
             <groupId>com.mchange</groupId>
             <artifactId>c3p0</artifactId>
             <version>0.9.5.5</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.1.9.RELEASE</version>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-jdbc</artifactId>
             <version>5.1.9.RELEASE</version>
         </dependency>
 ​
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
             <version>1.18.24</version>
         </dependency>
     </dependencies>
 ​
     <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> 
</project>

3、建立基本结构和配置框架！

• com.xing.pojo

• com.xing.dao

• com.xing.service

• com.xing.controller

• 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>
   ​
   </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">
   ​
   </beans>

 

Mybatis层编写

1、数据库配置文件

database.properties

 jdbc.driver=com.mysql.cj.jdbc.Driver
 jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?useSSL=true&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai 
 jdbc.username=root
 jdbc.password=123456

2、IDEA关联数据库

 

 

3、编写数据库对应的实体类

使用lombok插件！

 package com.xing.pojo;
 ​
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 ​
 @Data
 @AllArgsConstructor
 @NoArgsConstructor
 public class Books {
    
    private int bookID;
    private String bookName;
    private int bookCounts;
    private String detail;
    
 }

4、编写Dao层的 Mapper接口！

 package com.xing.mapper;
 ​
 import com.xing.pojo.Books;
 import org.apache.ibatis.annotations.Param;
 ​
 import java.util.List;
 ​
 public interface BookMapper {
 ​
    //增加一个Book
    int addBook(Books book);
 ​
    //根据id删除一个Book
    int deleteBookById(@Param("bookId") int id);
 ​
    //更新Book
    int updateBook(Books books);
 ​
    //根据id查询,返回一个Book
    Books queryBookById(@Param("bookId") int id);
 ​
    //查询全部Book,返回list集合
    List<Books> queryAllBook();
 }

5、编写接口对应的 Mapper.xml 文件

 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE mapper
         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 ​
 ​
 <mapper namespace="com.xing.mapper.BookMapper">
 ​
     <!--增加一个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>
 </mapper>

6、编写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>
         <package name="com.xing.pojo"/>
     </typeAliases>
 ​
     <mappers>
         <mapper resource="com/xing/mapper/BookMapper.xml"/>
     </mappers>
 ​
 </configuration>

7、编写Service层的接口和实现类

接口：

 package com.xing.service;
 ​
 import com.xing.pojo.Books;
 ​
 import java.util.List;
 ​
 //BookService:底下需要去实现,调用dao层
 public interface BookService {
    //增加一个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();
 }

实现类：

 package com.xing.service.impl;
 ​
 import com.xing.mapper.BookMapper;
 import com.xing.pojo.Books;
 import com.xing.service.BookService;
 ​
 import java.util.List;
 ​
 public class BookServiceImpl implements BookService {
 ​
    //调用dao层的操作，设置一个set接口，方便Spring管理
    private BookMapper bookMapper;
 ​
    public void setBookMapper(BookMapper bookMapper) {
        this.bookMapper = bookMapper;
   }
    
   
    public int addBook(Books book) {
        return bookMapper.addBook(book);
   }
    
    public int deleteBookById(int id) {
        return bookMapper.deleteBookById(id);
   }
    
    public int updateBook(Books books) {
        return bookMapper.updateBook(books);
   }
    
    public Books queryBookById(int id) {
        return bookMapper.queryBookById(id);
   }
    
    public List<Books> queryAllBook() {
        return bookMapper.queryAllBook();
   }
 }

OK，到此，底层需求操作编写完毕！

Spring层

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

2、我们去编写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.xing.mapper"/>
     </bean>
 ​
 </beans>

3、Spring整合service层

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"
        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.xing.service" />
 ​
     <!--BookServiceImpl注入到IOC容器中-->
     <bean id="BookServiceImpl" class="com.xing.service.impl.BookServiceImpl">
         <property name="bookMapper" ref="bookMapper"/>
     </bean>
 ​
     <!-- 配置事务管理器 -->
     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
         <!-- 注入数据库连接池 -->
         <property name="dataSource" ref="dataSource" />
     </bean>
 </beans>

Spring层搞定！再次理解一下，Spring就是一个大杂烩，一个容器！对吧！

 

SpringMVC层

增加web框架支持

1、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>springmvc</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>springmvc</servlet-name>
         <url-pattern>/</url-pattern>
     </servlet-mapping>
     
     <!--乱码过滤-->
     <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>

2、建立/WEB-INF/jsp 包

 

 

3、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
    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="prefix" value="/WEB-INF/jsp/" />
         <property name="suffix" value=".jsp" />
     </bean>
         
     <!-- 4.扫描web相关的bean -->
     <context:component-scan base-package="com.xing.controller" />
         
 </beans>

4、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"
        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.xing.controller" />
         
 </beans>

配置文件，暂时结束！Controller 和 视图层编写

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

 package com.xing.controller;
 ​
 import com.xing.pojo.Books;
 import com.xing.service.BookService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.RequestMapping;
 ​
 import java.util.List;
 ​
 @Controller
 @RequestMapping("/book")
 public class BookController {
 ​
    @Autowired
    @Qualifier("BookServiceImpl") //在Controller中需要注入service那么我的这个server有两个实现类如何区分开这两个impl呢？用@Qualifier
    private BookService bookService;
 ​
    // 查询全部书籍,并且返回到一个书籍展示页面  Model：让前端展示
    @RequestMapping("/allBook")
    public String list(Model model) {
        List<Books> list = bookService.queryAllBook();
        model.addAttribute("list", list);
        return "allBook";
    }
 }

2、书籍列表页面 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">
     <%--clearfix ：清除块级元素的浮动--%>
     <div class="row clearfix">
         <%--将屏幕分成12份--%>
         <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">
             <%--btn 按钮   跳转到/book/toAddBook请求--%>
             <a class="btn btn-primary" href="${pageContext.request.contextPath}/book/toAddBook">新增</a>
         </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>
 ​
                 <%--表格体 书籍从数据库中查询出来，从这个list中遍历出来--%>
                 <tbody>
                 <%--里面每一个参数命名为book  从items中遍历--%>
                 <c:forEach var="book" items="${list}">
                     <tr>
                         <td>${book.getBookID()}</td>
                         <%--<td>${book.bookID}</td>  也可以这么写--%>
                         <td>${book.getBookName()}</td>
                         <td>${book.getBookCounts()}</td>
                         <td>${book.getDetail()}</td>
                         <td>
                             <%--跳转到/book/toUpdateBook请求  并传入当前要修改书籍的id--%>
                             <a href="${pageContext.request.contextPath}/book/toUpdateBook?id=${book.getBookID()}">更改</a> |
                             <%--使用restfor风格 也可以使用上面的样式--%>
                             <a href="${pageContext.request.contextPath}/book/del/${book.getBookID()}">删除</a>
                         </td>
                     </tr>
                 </c:forEach>
                 </tbody>
             </table>
         </div>
     </div>
 </div>
 </body>

3、 编写首页 index.jsp

 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
   <title>首页</title>
   <style>
     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>

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

 package com.xing.controller;
 ​
 import com.xing.pojo.Books;
 import com.xing.service.BookService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.RequestMapping;
 ​
 import java.util.List;
 ​
 @Controller
 @RequestMapping("/book")
 public class BookController {
 ​
    @Autowired
    @Qualifier("BookServiceImpl") //在Controller中需要注入service那么我的这个server有两个实现类如何区分开这两个impl呢？用@Qualifier
    private BookService bookService;
 ​
    // 查询全部书籍,并且返回到一个书籍展示页面  Model：让前端展示
    @RequestMapping("/allBook")
    public String list(Model model) {
        List<Books> list = bookService.queryAllBook();
        model.addAttribute("list", list);
        return "allBook";
    }
 ​
     // 跳转到addBook页面
     @RequestMapping("/toAddBook")
     public String toAddPaper() {
         return "addBook";
     }
 ​
     // 增加书籍  将name
     @RequestMapping("/addBook")
     public String addPaper(Books books) {
         System.out.println(books);
         bookService.addBook(books);
         // 添加完跳转到首页 用重定向  这种重定向到一个请求,也可以直接return "allBook"
         return "redirect:/book/allBook";
     }
 }

5、添加书籍页面：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>
 ​
     <%--点击添加按钮 会提交到/book/addBook的请求--%>
     <form action="${pageContext.request.contextPath}/book/addBook"method="post">
         <%--name 要与实体类名字一样,通过name将数据传递给后端接口  required表单写完才能提交--%>
         书籍名称：<input type="text" name="bookName" required><br><br><br>
         书籍数量：<input type="text" name="bookCounts" required><br><br><br>
         书籍详情：<input type="text" name="detail" required><br><br><br>
         <input type="submit" value="添加">
     </form>
 ​
 </div>

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

 package com.xing.controller;
 ​
 import com.xing.pojo.Books;
 import com.xing.service.BookService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.RequestMapping;
 ​
 import java.util.List;
 ​
 @Controller
 @RequestMapping("/book")
 public class BookController {
 ​
    @Autowired
    @Qualifier("BookServiceImpl") //在Controller中需要注入service那么我的这个server有两个实现类如何区分开这两个impl呢？用@Qualifier
    private BookService bookService;
 ​
    // 查询全部书籍,并且返回到一个书籍展示页面  Model：让前端展示
    @RequestMapping("/allBook")
    public String list(Model model) {
        List<Books> list = bookService.queryAllBook();
        model.addAttribute("list", list);
        return "allBook";
    }
 ​
     // 跳转到addBook页面
     @RequestMapping("/toAddBook")
     public String toAddPaper() {
         return "addBook";
     }
 ​
     // 增加书籍  将name
     @RequestMapping("/addBook")
     public String addPaper(Books books) {
         System.out.println(books);
         bookService.addBook(books);
         // 添加完跳转到首页 用重定向  这种重定向到一个请求,也可以直接return "allBook"
         return "redirect:/book/allBook";
     }
 ​
     // 跳转到修改页面
     @RequestMapping("/toUpdateBook")
     public String toUpdateBook(Model model, int id) {
         Books books = bookService.queryBookById(id);
         model.addAttribute("QBook",books );
         return "updateBook";
     }
 ​
     // 修改书籍
     @RequestMapping("/updateBook")
     public String updateBook(Model model, Books book) {
         System.out.println(book);
         bookService.updateBook(book);
         Books books = bookService.queryBookById(book.getBookID());
         model.addAttribute("books", books);
         return "redirect:/book/allBook";
     }
 }

7、修改书籍页面 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>
     <%--提交到修改书籍请求/book/updateBook--%>
     <form action="${pageContext.request.contextPath}/book/updateBook"method="post">
         <%--name 要与实体类名字一样,通过name将数据传递给后端接口   value：回显一个默认值--%>
         <input type="hidden" name="bookID" value="${QBook.getBookID()}"/>
         书籍名称：<input type="text" name="bookName"value="${QBook.getBookName()}"/>
         书籍数量：<input type="text" name="bookCounts"value="${QBook.getBookCounts()}"/>
         书籍详情：<input type="text" name="detail" value="${QBook.getDetail() }"/>
         <input type="submit" value="提交"/>
     </form>
 ​
 </div>

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

 package com.xing.controller;
 ​
 import com.xing.pojo.Books;
 import com.xing.service.BookService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestMapping;
 ​
 import java.util.List;
 ​
 @Controller
 @RequestMapping("/book")
 public class BookController {
 ​
    @Autowired
    @Qualifier("BookServiceImpl") //在Controller中需要注入service那么我的这个server有两个实现类如何区分开这两个impl呢？用@Qualifier
    private BookService bookService;
 ​
    // 查询全部书籍,并且返回到一个书籍展示页面  Model：让前端展示
    @RequestMapping("/allBook")
    public String list(Model model) {
        List<Books> list = bookService.queryAllBook();
        model.addAttribute("list", list);
        return "allBook";
    }
 ​
     // 跳转到addBook页面
     @RequestMapping("/toAddBook")
     public String toAddPaper() {
         return "addBook";
     }
 ​
     // 增加书籍  将name
     @RequestMapping("/addBook")
     public String addPaper(Books books) {
         System.out.println(books);
         bookService.addBook(books);
         // 添加完跳转到首页 用重定向  这种重定向到一个请求,也可以直接return "allBook"
         return "redirect:/book/allBook";
     }
 ​
     // 跳转到修改页面
     @RequestMapping("/toUpdateBook")
     public String toUpdateBook(Model model, int id) {
         Books books = bookService.queryBookById(id);
         model.addAttribute("QBook",books );
         return "updateBook";
     }
 ​
     // 修改书籍
     @RequestMapping("/updateBook")
     public String updateBook(Model model, Books book) {
         System.out.println(book);
         bookService.updateBook(book);
         // Books books = bookService.queryBookById(book.getBookID());
         // model.addAttribute("books", books);
         return "redirect:/book/allBook";
     }
     // 使用restfor风格 也可以使用上面的样式
     @RequestMapping("/del/{bookId}")
     public String deleteBook(@PathVariable("bookId") int id) {
         bookService.deleteBookById(id);
         return "redirect:/book/allBook";
     }
 }

配置Tomcat，进行运行！

到目前为止，这个SSM项目整合已经完全的OK了，可以直接运行进行测试

终极整合

新增搜索功能

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">
     <%--clearfix ：清除块级元素的浮动--%>
     <div class="row clearfix">
         <%--将屏幕分成12份--%>
         <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">
             <%--btn 按钮   跳转到/book/toAddBook请求--%>
             <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">
             <%--点击查询跳转到/book/queryBook 请求    form-inline:框放到一行--%>
             <form class="form-inline" action="${pageContext.request.contextPath}/book/queryBook" method="post" style="float: right">
                 <%--接收model传来的信息--%>
                 <span style="color: red; font-weight: bold">${error}</span>
                 <%--传的参数名为queryBookName--%>
                 <input type="text" name="queryBookName" class="form-control" placeholder="请输入要查询的书籍名称">
                 <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>
 ​
                 <%--表格体 书籍从数据库中查询出来，从这个list中遍历出来--%>
                 <tbody>
                 <%--里面每一个参数命名为book  从items中遍历--%>
                 <c:forEach var="book" items="${list}">
                     <tr>
                         <td>${book.getBookID()}</td>
                         <%--<td>${book.bookID}</td>  也可以这么写--%>
                         <td>${book.getBookName()}</td>
                         <td>${book.getBookCounts()}</td>
                         <td>${book.getDetail()}</td>
                         <td>
                             <%--跳转到/book/toUpdateBook请求  并传入当前要修改书籍的id--%>
                             <a href="${pageContext.request.contextPath}/book/toUpdateBook?id=${book.getBookID()}">更改</a> |
                             <%--使用restfor风格 也可以使用上面的样式--%>
                             <a href="${pageContext.request.contextPath}/book/del/${book.getBookID()}">删除</a>
                         </td>
                     </tr>
                 </c:forEach>
                 </tbody>
             </table>
         </div>
     </div>
 </div>
 </body>

BookMapper

 package com.xing.mapper;
 ​
 import com.xing.pojo.Books;
 import org.apache.ibatis.annotations.Param;
 ​
 import java.awt.print.Book;
 import java.util.List;
 ​
 public interface BookMapper {
 ​
    //增加一个Book
    int addBook(Books book);
 ​
    //根据id删除一个Book
    int deleteBookById(@Param("bookId") int id);
 ​
    //更新Book
    int updateBook(Books books);
 ​
    //根据id查询,返回一个Book
    Books queryBookById(@Param("bookId") int id);
 ​
    //查询全部Book,返回list集合
    List<Books> queryAllBook();
 ​
    Books queryBookName(@Param("bookName")String bookName);
 }

BookMapper.xml

 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE mapper
         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 ​
 ​
 <mapper namespace="com.xing.mapper.BookMapper">
 ​
     <!--增加一个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="queryBookName" resultType="Books">
         select *
         from ssmbuild.books
         where bookName = #{bookName} 
     </select>
 ​
 </mapper>

BookService

 package com.xing.service;
 ​
 import com.xing.pojo.Books;
 import org.apache.ibatis.annotations.Param;
 ​
 import java.util.List;
 ​
 //BookService:底下需要去实现,调用dao层
 public interface BookService {
    //增加一个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 queryBookName(String bookName);
 }

BookServiceImpl

 package com.xing.service.impl;
 ​
 import com.xing.mapper.BookMapper;
 import com.xing.pojo.Books;
 import com.xing.service.BookService;
 ​
 import java.util.List;
 ​
 public class BookServiceImpl implements BookService {
 ​
    //调用dao层的操作，设置一个set接口，方便Spring管理
    private BookMapper bookMapper;
 ​
    public void setBookMapper(BookMapper bookMapper) {
        this.bookMapper = bookMapper;
   }
 ​
 ​
    public int addBook(Books book) {
        return bookMapper.addBook(book);
   }
    
    public int deleteBookById(int id) {
        return bookMapper.deleteBookById(id);
   }
    
    public int updateBook(Books books) {
        return bookMapper.updateBook(books);
   }
    
    public Books queryBookById(int id) {
        return bookMapper.queryBookById(id);
   }
    
    public List<Books> queryAllBook() {
        return bookMapper.queryAllBook();
   }
 ​
     @Override
     public Books queryBookName(String bookName) {
         return bookMapper.queryBookName(bookName);
     }
 }

BookController

 package com.xing.controller;
 ​
 import com.xing.pojo.Books;
 import com.xing.service.BookService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestMapping;
 ​
 import java.util.ArrayList;
 import java.util.List;
 ​
 @Controller
 @RequestMapping("/book")
 public class BookController {
 ​
    @Autowired
    @Qualifier("BookServiceImpl") //在Controller中需要注入service那么我的这个server有两个实现类如何区分开这两个impl呢？用@Qualifier
    private BookService bookService;
 ​
    // 查询全部书籍,并且返回到一个书籍展示页面  Model：让前端展示
    @RequestMapping("/allBook")
    public String list(Model model) {
        List<Books> list = bookService.queryAllBook();
        model.addAttribute("list", list);
        return "allBook";
    }
 ​
     // 跳转到addBook页面
     @RequestMapping("/toAddBook")
     public String toAddPaper() {
         return "addBook";
     }
 ​
     // 增加书籍  将name
     @RequestMapping("/addBook")
     public String addPaper(Books books) {
         System.out.println(books);
         bookService.addBook(books);
         // 添加完跳转到首页 用重定向  这种重定向到一个请求,也可以直接return "allBook"
         return "redirect:/book/allBook";
     }
 ​
     // 跳转到修改页面
     @RequestMapping("/toUpdateBook")
     public String toUpdateBook(Model model, int id) {
         Books books = bookService.queryBookById(id);
         model.addAttribute("QBook",books );
         return "updateBook";
     }
 ​
     // 修改书籍
     @RequestMapping("/updateBook")
     public String updateBook(Model model, Books book) {
         System.out.println(book);
         bookService.updateBook(book);
         // Books books = bookService.queryBookById(book.getBookID());
         // model.addAttribute("books", books);
         return "redirect:/book/allBook";
     }
     //删除书籍 使用restfor风格 也可以使用上面的样式
     @RequestMapping("/del/{bookId}")
     public String deleteBook(@PathVariable("bookId") int id) {
         bookService.deleteBookById(id);
         return "redirect:/book/allBook";
     }
 ​
     // 查询书籍
     @RequestMapping("/queryBook")
     // 参数名必须与前端传来的input name属性名一致
     public String queryBook(String queryBookName,Model model) {
         Books books = bookService.queryBookName(queryBookName);
         List<Books> list = new ArrayList<>();
         list.add(books);
 ​
         if (books == null) {
             list = bookService.queryAllBook();
             model.addAttribute("error", "未查询到信息");
         }
 ​
         model.addAttribute("list", list);
         return "allBook";
     }
 }
 ​