SSM整合

最新推荐文章于 2024-08-12 15:45:48 发布

kalen12138

最新推荐文章于 2024-08-12 15:45:48 发布

阅读量156

点赞数

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

本文链接：https://blog.csdn.net/weixin_45699919/article/details/124852027

版权

spring 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

SpringMVC

回顾Servlet

1.建立项目，添加web app依赖

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

2.编写一个Servlet类，用来处理用户请求

    public class HelloServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            //1.获取前端参数
            String method = req.getParameter("method");
            if(method.equals("add")) req.getSession().setAttribute("msg","执行了add方法");
            if(method.equals("delete")) req.getSession().setAttribute("msg","执行了delete方法");
            //2.调用业务层
    
            //3.视图转发或者重定向
            req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);//重定向
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doGet(req, resp);
        }
    }

3.写完servlet后，在web.xml中注册servlet

    <?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>hello</servlet-name>
            <servlet-class>com.ckl.servlet.HelloServlet</servlet-class>
        </servlet>
        <servlet-mapping>
            <servlet-name>hello</servlet-name>
            <url-pattern>/hello</url-pattern>
        </servlet-mapping>
    
    <!--    配置session超时时间-->
    <!--    <session-config>-->
    <!--        <session-timeout>15</session-timeout>-->
    <!--    </session-config>-->
    
    <!--    欢迎界面-->
    <!--    <welcome-file-list>-->
    <!--        <welcome-file>index.jsp</welcome-file>-->
    <!--    </welcome-file-list>-->
    </web-app>

3.1同时编写test.jsp

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>hello</title>
    </head>
    <body>
    #{msg}
    </body>
    </html>

4.编写表单页面from.jsp

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>biaodan</title>
    </head>
    <body>
    <form action="/hello" method="post">
        <input name="method" type="text">
        <input type="submit">
    </form>
    </body>
    </html>

5.配置tomcat并运行测试

http://localhost:8080/0514_SpringMVC_Servlet/hello?method=delete

http://localhost:8080/0514_SpringMVC_Servlet/hello?method=add

SpringMVC步骤

1.新建一个maven项目，添加web支持

2.确定导入SpringMVC依赖

3.配置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">
    
    <!--    1.注册DispatcherServlet-->
        <servlet>
            <servlet-name>springmvc</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <!--    关联一个springmvc的配置文件：【servlet-nome】-servlet.xml-->
            <init-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath:springmvc-servlet.xml</param-value>
            </init-param>
            <!--            启动级别：1-->
            <load-on-startup>1</load-on-startup>
        </servlet>
        
        <servlet-mapping>
            <servlet-name>springmvc</servlet-name>
            <url-pattern>/</url-pattern>
        </servlet-mapping>
    
    </web-app>

4.编写springmvc配置文件

【springmvc-servlet.xml】：[servletname]-servlet.xml 按照官方来

    <?xml version="1.0" encoding="UTF-8"?><!-- applicationContext.xml -->
    <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>
    </beans>

5.编写具体的业务操作Controller

要么实现Controller接口，要么增加注解；需要返回一个ModelAndView，装数据，封视图

    public class HelloController implements Controller {
        public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse)
                throws Exception {
            //ModelAndView 模型和视图
            ModelAndView mv = new ModelAndView();
    
            //封装对象，放在mv中
            mv.setViewName("hello"); // /WEB-INF/jsp/hello,jsp
            return mv;
        }
    }

6.将自己的类交给SpringIOC容器，注册bean（springmvc-servlet.xml）

    <!--    Handler-->
        <bean id="/hello" class="com.ckl.controller.HelloController"/>

7.编写要跳转的jsp页面，显示ModelAndView存放的数据，以及我们的正常页面

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

8.配置Tomact运行测试

http://localhost:8080/hello

如果访问出现404,

1.查看控制台输出，看一下是不是缺少什么jar包

2.如果jar存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖

3.重启Tomcat

lib文件夹在WEB-INF文件夹里面

SpringMVC使用注解开发

1.新建一个maven项目

pom.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>

2.在pom.xml中引入相关依赖

Spring框架核心库、SPringMVC、servlet，JSTL等

3.配置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>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <init-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath:springmvc-servlet.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>
    </web-app>

4.添加SPring MVC配置文件

springmvc-servlet.xml：

让IOC的注解生效；静态资源过滤：HTML，JS，CSS，图片，视频…

MVC的注解驱动；配置视图解析器

    <?xml version="1.0" encoding="UTF-8"?><!-- applicationContext.xml -->
    <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
            http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
    <!--    自动扫描包，让指定包下的注解生效，由IOC容器统一管理-->
        <context:component-scan base-package="com.ckl.controller"/>
    <!--    让Spring MVC不处理静态资源-->
        <mvc:default-servlet-handler/>
    
    	<mvc:annotation-driven/>
    <!--    支持mvc注解驱动:
            在spring中一般采用@RequestMapping注解来完成映射关系
            要想使@RequestMapping生效 ， 必须向上下文中注解DefaultAnnotationHandlerMapping
            和一个AnnotationMethodHandlerAdapter实例
            这两个实例分别在类级别和方法级别处理。
            而annotation-driver配置帮助我们自动完成上述两个实例的注入   -->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
    <!--        前缀-->
            <property name="prefix" value="WEB-INF/jsp/"/>
    <!--        后缀-->
            <property name="suffix" value=".jsp"/>
        </bean>
    </beans>

在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下，这样可以保证视图安全，又因为这个目录下的文件，客户端不能直接访问。

5.创建Controller

编写一个java控制类，com.ckl.controller.HelloController

    @Controller//就不需要去xml中注册bean
    @RequestMapping("/hello"）
    public class HelloController {
    
        @RequestMapping("/h1")//视图跳转
        public String hello(Model model){//localhost:8080/hello/h1
            //封装数据
            model.addAttribute("msg","Hello,Spring MVC Annotation");
    
            return "hello"; //会被视图解析器处理
        }
    
        @RequestMapping("/h1")
        public String hello2(Model model){
            //封装数据
            model.addAttribute("msg","Hello,Spring MVC Annotation 2");
    
            return "hello"; //会被视图解析器处理
        }
    }

Controller 是为了让Spring IOC容器初始化时自动扫描到
@RequestMapping是为了映射请求路径，这里因为类与方法上都有映射所有访问时应该是/HelloController/hello
方法中声明Model类型的参数是为了把Action中的数据带到视图中
方法返回的结果是视图的名称hello，加上配置文件中的前后缀编程WEB-INF/jsp/hello.jsp

6.创建视图层

hello.jsp

7.配置Tomcat运行测试

注意点：

使用Spring MVC 必须配置三大件：处理器映射器、处理器适配器、视图解析器

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

配置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>

JackSon使用

1.导入依赖包

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

2.配置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">
    
        <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:springmvc-servlet.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>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>
    </web-app>

springmvc-servlet.xml

    <?xml version="1.0" encoding="UTF-8"?><!-- applicationContext.xml -->
    <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
            http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
        <!--    自动扫描包，让指定包下的注解生效，由IOC容器统一管理-->
        <context:component-scan base-package="com.ckl.controller"/>
       
        <!--    视图解析器-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
            <!--        前缀-->
            <property name="prefix" value="WEB-INF/jsp/"/>
            <!--        后缀-->
            <property name="suffix" value=".jsp"/>
        </bean>
    </beans>

3.创建相应的com.ckl.controller包，jsp包

4.编写pojo类：User

    public class User {
        private String name;
        private int age;
        private String sex;
     	/*无参构造，有参构造，get(),set()...*/
    }

5.编写controller类:UserController

    @Controller
    public class UserController {
    
        //@RequestMapping(value="/j1",produces = "application/json;charset=utf-8")
        @RequestMapping("j1")
        @ResponseBody //不会走视图解析器，会直接返回一个字符串
        public String json1() throws JsonProcessingException {
            //jackson objectMapper
            ObjectMapper mapper = new ObjectMapper();
            //创建一个对象
            User user = new User("1号",3,"男");
            String str = mapper.writeValueAsString(user);
            return str;
        }
    
        @RequestMapping("j2")
        @ResponseBody
        public String json2() throws JsonProcessingException {
    
            ObjectMapper mapper = new ObjectMapper();
            //创建一个集合
            List<User> list = new ArrayList<User>();
            User user1 = new User("1号",1,"男");
            User user2 = new User("2号",2,"男");
            User user3 = new User("3号",3,"女");
            User user4 = new User("4号",4,"男");
            list.add(user1);list.add(user2);list.add(user3);list.add(user4);
            String str = mapper.writeValueAsString(list);
            return str;
        }
    
        @RequestMapping("j3")
        @ResponseBody
        public String json3() throws JsonProcessingException {
    
            ObjectMapper mapper = new ObjectMapper();
            /*使用ObjectMapper来格式输出   , 不使用时间戳的方式*/
            mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
    
            SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            mapper.setDateFormat(sd);
            Date date = new Date();
    
    
            //SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            //sd.format(date);
            //ObjectMapper，时间解析后的默认格式为：Timestamp  时间戳
            //String str = mapper.writeValueAsString(sd);
            String str = mapper.writeValueAsString(date);
            return str;
        }
    }

注意：使用json注意处理乱码问题

可以用过Spring配置统一指定，就不需要每次都去处理

在springmvc-servlet.xml中添加一段消息StringHttpMessageConverter转换配置

    <!--    JSON乱码问题配置-->
    <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>

SSM整合

1.新建项目，导入依赖

pom.xml

    <?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>org.example</groupId>
        <artifactId>SSM</artifactId>
        <packaging>pom</packaging>
        <version>1.0-SNAPSHOT</version>
        <modules>
            <module>0516_SSM_Build</module>
        </modules>
    <!--依赖: junit  数据库驱动  连接池  servlet  jsp  mybatis  mybatis-spring -->
        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.13.2</version>
                <scope>test</scope>
            </dependency>
            <dependency>
                <!-- 数据库驱动-->
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.25</version>
            </dependency>
            <dependency>
                <!-- 连接池-->
                <groupId>com.mchange</groupId>
                <artifactId>c3p0</artifactId>
                <version>0.9.5.4</version>
            </dependency>
    
            <!-- servlet  jsp -->
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>servlet-api</artifactId>
                <version>2.5</version>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>jstl</artifactId>
                <version>1.2</version>
            </dependency>
    
            <dependency>
                <!-- mybatis -->
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.5.2</version>
            </dependency>
            <dependency>
                <!-- mybatis-spring-->
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>2.0.2</version>
            </dependency>
    
            <!-- spring-->
            <dependency>
                <!-- spring mvc-->
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>5.3.8</version>
            </dependency>
            <dependency>
                <!-- spring jdbc-->
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>5.3.8</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>

2.连接数据库

3.创建所需包，配置文件

在这里插入图片描述

4.关联数据库

database.properties

    jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/ssm?characterEncoding=UTF-8"
    jdbc.username=root
    jdbc.password=123456

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.ckl.pojo"/>
        </typeAliases>
    
        <!-- 配置数据源，交给spring去做了
    	spring-dao.xml  -->
    </configuration>

5.创建实体类：

Books：

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Books {
        private int bookID;
        private String bookName;
        private int bookCounts;
        private String detail;
    }

6.创建接口及xml

开始编写dao层，dao层只是完成增删查改，service层才会在增删查改的基础上加上逻辑判断等

创建实体类的接口去进行业务操作：

BookMapper接口：

    public interface BookMapper {
        public int addBook(Books books);//添加书籍
    
        public int deleteBookById(int id);//删除书籍
    
        public int updateBook(Books books);//修改一本书
    
        public Books queryBookById(int id);//查询一本书
    
        public List<Books> queryAllBook();//查询所有书籍
    }

BooksMapper.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.ckl.dao.BookMapper">
        <insert id="addBook" parameterType="Books">
            insert into ssm.books (bookName, bookCounts, detail)
            values (#{bookName}, #{bookCounts}, #{detail});
        </insert>
    
        <delete id="deleteBook" parameterType="int">
            delete from ssm.books where bookID = #{bookID};
        </delete>
    
        <update id="updateBook" parameterType="Books">
            update ssm.books set bookName = #{bookName},bookCounts=#{bookCounts},detail=#{detail}
            where bookID=#{bookID};
        </update>
    
        <select id="queryBookById" resultType="Books">
            select * from ssm.books where bookID = #{bookID};
        </select>
    
        <select id="queryAllBook" resultType="Books">
            select * from ssm.books;
        </select>
    </mapper>

也可以使用注解的方式，不用xml，比如：

    public interface BookMapper {
    
        @Insert("insert into ssm.books (bookName, bookCounts, detail) values (#{bookName}, #{bookCounts}, #{detail}")
        public int addBook(Books books);//添加书籍
    
        public int deleteBookById(@Param("bookID")int id);//删除书籍
    
        public int updateBook(Books books);//修改一本书
    
        public Books queryBookById(@Param("bookID")int id);//查询一本书
    
        public List<Books> queryAllBook();//查询所有书籍
    }

7.將BooksMapper.xml绑定到配置文件中

mybatis-config.xml

    <mappers>
        <mapper class="com.ckl.dao.BookMapper"></mapper>
    </mappers>
    ```

### 8.编写业务层

dao层完成后，开始编写业务层[service]：BookService接口
```java
    public interface BookService {
    
        public int addBook(Books books);//添加书籍
    
        public int deleteBookById(int id);//删除书籍
    
        public int updateBook(Books books);//修改一本书
    
        public Books queryBookById(int id);//查询一本书
    
        public List<Books> queryAllBook();//查询所有书籍
    
    }

然后再编写他的实现类：BookServiceImpl.java

service层调dao层 dao层只是完成增删查改，service层才会在增删查改的基础上加上逻辑判断等

    public class BookServiceImpl implements BookService{
        private BookMapper bookMapper;
    
        public BookServiceImpl(BookMapper bookMapper) {
            this.bookMapper = bookMapper;
        }
    
        public int addBook(Books books) {
            return bookMapper.addBook(books);
        }
    
        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();
        }
    }

9.编写spring-dao.xml配置文件

以上完成了mybatis层，然后开始整合spring层

spring-dao.xml

    <?xml version="1.0" encoding="UTF-8"?><!-- applicationContext.xml -->
    <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">
    
    <!--    1.关联数据库配置文件-->
        <context:property-placeholder location="classpath:database.properties"/>
    
    <!--    2.连接池-->
        <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}"/>
        </bean>
    <!--    3.sqlsessionFactory-->
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource"/>
    <!--        绑定mybaits配置文件-->
            <property name="configLocation" value="classpath:mybatis-config.xml"/>
        </bean>
    
        <!-- 配置dao接口扫描包，动态的实现了Dao接口可以注入到Spring容器中
            之前是在BookMapperImpl中继承SQLSessionDaoSport  可以直接调用getSession()
            或者是new一个SqlSessionFactoryBean...然后去获取SqlSession
            用下面的配置，可以动态的注入
        -->
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <!--   注入sqlSessionFactory-->
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
            <!--   要扫描的包-->
            <property name="basePackage" value="com.ckl.dao"/>
        </bean>
    
    </beans>

10.绑定service层

spring-service.xml

    <?xml version="1.0" encoding="UTF-8"?><!-- applicationContext.xml -->
    <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">
    
    <!--    1.扫描service下的包-->
        <context:component-scan base-package="com.ckl.service"/>
    <!--    2.将所有的业务类，注入到Spring中，可以通过配置，或者注解实现-->
        <bean id="BookServiceImpl" class="com.ckl.service.BookServiceImpl">
            <property name="bookMapper" ref="bookMapper"/>
        </bean>
    
    <!--    3.声明式事务-->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--        注入数据源-->
            <property name="dataSource" ref="dataSource"/>
        </bean>
    
    <!--    4.AOP事务支持
            上面的配置，就会有一个默认的
    -->
    
    </beans>

配置中的第2 点，注入spring，注解版：

    @Service
    public class BookServiceImpl implements BookService{
    @Autowired
        private BookMapper bookMapper;
    }

11.增加web支持

spring层整合完成，然后这个spring mvc层

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:spring-mvc.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>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>
    
    <!--    可以设置 Session默认超时 时间-->
        <session-config>
            <session-timeout>15</session-timeout>
        </session-config>
    </web-app>

spring-mvc.xml:

    <?xml version="1.0" encoding="UTF-8"?><!-- applicationContext.xml -->
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           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/mvc
            http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    
    <!--    1.注解驱动-->
        <mvc:annotation-driven/>
    <!--    2.静态资源过滤-->
        <mvc:default-servlet-handler/>
    <!--    3.扫描包-->
        <context:component-scan base-package="com.ckl.controller"/>
    <!--    4.视图解析器-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="WEB-INF/jsp/"/>
            <property name="suffix" value=".jsp"/>
        </bean>
    </beans>

然后就在WEB-INF/创建jsp包

框架整合完成！然后就开始业务编写

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-color: aqua;
            border-radius: 5px;
          }
        </style>
      </head>
      <body>
    <h3>
      <a href="${pageContext.request.contextPath}/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>Books Show</title>
        <link href="https://cdn.staticfile.org/twitter-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 class="row">
                <div class="col-md-4 column">
                    <a class="btn btn-primary" href="${pageContext.request.contextPath}/toAddBook">新增书籍</a>
                </div>
            </div>
        </div>
        <div class="row clearfix">
            <div class="col-md-12 column">
                <table class="table tale-hover table-striped">
                    <thead>
                        <tr>
                            <th>书籍编号</th>
                            <th>书籍名称</th>
                            <th>书籍数量</th>
                            <th>书籍详情</th>
                            <th>操作</th>
                        </tr>
                    </thead>
                    <tbody>
                        <c:forEach var="book" items="${list}">
                            <tr>
                                <td>${book.bookID}</td>
                                <td>${book.bookName}</td>
                                <td>${book.bookCounts}</td>
                                <td>${book.detail}</td>
                                <td>
                                    <a href="${pageContext.request.contextPath}/toUpdateBook?id=${book.bookID}">修改</a>
                                    &nbsp; | &nbsp;
                                    <a href="${pageContext.request.contextPath}/deleteBook/${book.bookID}">删除</a>
                                </td>
                            </tr>
                        </c:forEach>
                    </tbody>
                </table>
            </div>
        </div>
    </div>
    
    
    </div>
    </body>
    </html>

addBook.jsp

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>新增书籍</title>
        <link href="https://cdn.staticfile.org/twitter-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}/addBook" method="post">
            <div class="form-group">
                <label>书籍名称: </label>
                <input type="text" name="bookName" class="form-controller" required/>
            </div>
            <div class="form-group">
                <label>书籍数量: </label>
                <input type="text" name="bookCounts" class="form-controller" required/>
            </div>
            <div class="form-group">
                <label>书籍描述: </label>
                <input type="text" name="detail" class="form-controller" required/>
            </div>
            <div class="form-group">
                <input type="submit" class="form-controller" value="添加"/>
            </div>
        </form>
    
    </div>
    
    
    </body>
    </html>

updateBook.jsp

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>修改书籍信息</title>
        <link href="https://cdn.staticfile.org/twitter-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}/updateBook" method="post">
            <input type="hidden" name="bookID" value="${QBook.bookID}">
            <div class="form-group">
                <label>书籍名称: </label>
                <input type="text" name="bookName" class="form-controller" value="${QBook.bookName}" required/>
            </div>
            <div class="form-group">
                <label>书籍数量: </label>
                <input type="text" name="bookCounts" class="form-controller" value="${QBook.bookCounts}"required/>
            </div>
            <div class="form-group">
                <label>书籍描述: </label>
                <input type="text" name="detail" class="form-controller" value="${QBook.detail}"required/>
            </div>
            <div class="form-group">
                <input type="submit" class="form-controller" value="修改"/>
            </div>
        </form>
    
    </div>
    
    
    </body>
    </html>

添加AOP事务

pom.xml

    <!--        横切需要的包-->
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.8.13</version>
            </dependency>

spring-service.xml

    <!-- 结合AOP 实现事务的织入-->
    <!-- 配置事务通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!-- 给哪些方法配置事务-->
        <!-- parpagation 配置事务的传播特性[7种] REQUIRED:默认-->
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    <!-- 配置事务的切入点-->
    <aop:config>
        <aop:pointcut id="txPointCut" expression="execution(* com.ckl.dao.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>

添加日志

LOG4J，在myBatis核心文件中添加日志工厂

mybatis-config.xml

    <!-- 添加日志工厂 -->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

controller.java

    @Controller
    public class BookController {
        /*
        *   通过index.jsp跳转到controller再跳转到jsp页面
        *   可以防止用户直接在url栏直接跳转
        * */
    
        //controller 调 service层
        @Autowired
        @Qualifier("BookServiceImpl")
        private BookService bookService;
    
        //跳转到展示所有书籍的页面
        @RequestMapping("/allBook")
        public String list(Model model){
            List<Books> list = bookService.queryAllBook();
            model.addAttribute("list",list);
            return "allBook";
        }
    
        //跳转到添加书籍的页面
        @RequestMapping("/toAddBook")
        public String toAddPaper(){
            return "addBook";
        }
    
        //处理添加书籍的请求
        @RequestMapping("/addBook")
        public String addBook(Books books){
            bookService.addBook(books);
            return "redirect:/allBook";
        }
    
        //跳转到修改页面
        @RequestMapping("/toUpdateBook")
        public String toUpdateBook(int id,Model model){
            Books books = bookService.queryBookById(id);
            model.addAttribute("QBook",books);
            return "updateBook";
        }
    
        //处理修改书籍信息的请求
        @RequestMapping("/updateBook")
        public String updateBook(Books books){
            bookService.updateBook(books);
            System.out.println("updateBook"+books+"***********");
            return "redirect:/allBook";
        }
    
    
        //处理书籍删除信息的请求  restful风格
        @RequestMapping("/deleteBook/{bookID}")
        public String deleteBook(@PathVariable("bookID") int id){
            bookService.deleteBookById(id);
            return "redirect:/allBook";
        }
        /*
        <a href="${pageContext.request.contextPath}/deleteBook?id=${book.bookID}">删除</a>
    
        @RequestMapping("/deleteBook")
        public String deleteBook(int id){
            bookService.deleteBookById(id);
            return "redirect:/allBook";
        }
        */
    }

新增查询功能

    @Controller
    public class BookController {
        /*
        *   通过index.jsp跳转到controller再跳转到jsp页面
        *   可以防止用户直接在url栏直接跳转
        * */
    
        //controller 调 service层
        @Autowired
        @Qualifier("BookServiceImpl")
        private BookService bookService;
    
        //查询书籍
        @RequestMapping("/queryBook")
        public String queryBook(String queryBookName,Model model){
            Books books = bookService.queryBookByName(queryBookName);
            List<Books> list = new ArrayList<Books>();
            list.add(books);
            if(books==null){
                list = bookService.queryAllBook();
                model.addAttribute("error","没有此书!");
            }
            model.addAttribute("list",list);
            return "allBook";
        }
    }

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>Books Show</title>
        <link href="https://cdn.staticfile.org/twitter-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 class="row">
                <div class="col-md-4 column">
                    <a class="btn btn-primary" href="${pageContext.request.contextPath}/toAddBook">新增书籍</a>
                    <a class="btn btn-primary" href="${pageContext.request.contextPath}/allBook">显示所有书籍</a>
                </div>
                <div class="col-md-8 column">
                    <%--  查询书籍--%>
                    <form class="form-inline" action="${pageContext.request.contextPath}/queryBook" method="post" style="float: right">
                        <span style="color: red;font-width: bold;">${error}</span>
                        <input type="text" name="queryBookName" class="form-control" placeholder="请输入要查询的书籍的名称"/>
                        <input type="submit" value="查询" class="btn btn-primary">
                    </form>
                </div>
            </div>
        </div>
        <div class="row clearfix">
            <div class="col-md-12 column">
                <table class="table tale-hover table-striped">
                    <thead>
                        <tr>
                            <th>书籍编号</th>
                            <th>书籍名称</th>
                            <th>书籍数量</th>
                            <th>书籍详情</th>
                            <th>操作</th>
                        </tr>
                    </thead>
                    <tbody>
                        <c:forEach var="book" items="${list}">
                            <tr>
                                <td>${book.bookID}</td>
                                <td>${book.bookName}</td>
                                <td>${book.bookCounts}</td>
                                <td>${book.detail}</td>
                                <td>
                                    <a href="${pageContext.request.contextPath}/toUpdateBook?id=${book.bookID}">修改</a>
                                    &nbsp; | &nbsp;
                                    <a href="${pageContext.request.contextPath}/deleteBook/${book.bookID}">删除</a>
                                </td>
                            </tr>
                        </c:forEach>
                    </tbody>
                </table>
            </div>
        </div>
    </div>
    </div>
    </body>
    </html>