mybatis与spring集成和分页插件应用

嘴强程序员

已于 2022-10-04 22:22:50 修改

阅读量1.3k

点赞数

文章标签： mybatis spring java

于 2022-08-29 17:54:11 首次发布

本文链接：https://blog.csdn.net/qq_62898618/article/details/126589573

版权

1.mybatis简介

2. mybatis基本构成

3. mybatis与hibernate的区别

4. 项目中添加mybatis支持与spring做集成

~我们用student实体来做一个查询的实例使用方式 spring注解注入

5.分页插件 pagehelper 的实现使用spring切面与自定义注解实现功能

2.1 注解编写

1.mybatis简介

Mybatis是Apache的一个Java开源项目，是一个支持动态Sql语句的持久层框架。Mybatis可以将Sql语句配置在XML文件中，避免将Sql语句硬编码在Java类中。与JDBC相比： 1）Mybatis通过参数映射方式，可以将参数灵活的配置在SQL语句中的配置文件中，避免在Java类中配置参数（JDBC） 2）Mybatis通过输出映射机制，将结果集的检索自动映射成相应的Java对象，避免对结果集手工检索（JDBC） 3）Mybatis可以通过Xml配置文件对数据库连接进行管理

2. mybatis基本构成

SqlSessionFactoryBuilder: 根据配置信息生成SqlSessionFactory SqlSessionFactory: 用于生成SqlSession SqlSession： SqlSession是MyBatis的关键对象，通过这个接口可以操作命令，管理事务等 SqlMapper：MyBatis的设计组件，有java接口和xml文件构成。需要给出对应的sql映射和映射规则

3. mybatis与hibernate的区别

两者均为ORM框架，但也有一些不同

mybatis	hibernate
轻量级	重量级
半自动化	全自动化
sql	hql(但也可以使用sql，但违背了hibernate的初衷)
扩展性、迁移性比较差	无缝移植

4. 项目中添加mybatis支持与spring做集成

1）使用maven新建一个web工程 2） idea在创建web工程时不会自动创建java，resources，test等目录，可以手动创建

3）通过pom.xml添加必要的依赖，直接将相关依赖考到项目中的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>deomMybatis</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

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

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <!--  jar包 版本 -->
        <mysql-version>8.0.29</mysql-version>
        <mybatis-version>3.5.9</mybatis-version>
        <spring-version>5.3.18</spring-version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
        <!-- spring 包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring-version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring-version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring-version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring-version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring-version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring-version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring-version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring-version}</version>
        </dependency>

        <!-- spring 集成 mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>
        <!-- 引入阿里开发的连接池 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.11.1</version>
        </dependency>


        <!-- jdbc 数据库连接 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql-version}</version>
        </dependency>
        <!-- mybatis  -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis-version}</version>
        </dependency>
        <!-- 文字转换  -->
        <dependency>
            <groupId>com.belerweb</groupId>
            <artifactId>pinyin4j</artifactId>
            <version>2.5.1</version>
        </dependency>
        <!-- 自动生成 get set 各种实体 方法 需要有lombox插件才能使用 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
            <scope>provided</scope>
        </dependency>

        <!--日志 -->
        <!--日志规范接口 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.36</version>
        </dependency>

        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.10</version>
        </dependency>
      <!-- servlet  -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!--  分页 -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.1.2</version>
        </dependency>
        <!--  JSTL依赖 原因：org.springframework.web.servlet.view.JstlView在视图解析时需要这二个jar包-->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>

    </dependencies>

    <build>
        <finalName>deomMybatis</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>

                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
                <!-- 设置单元测试错误可 编译打包代码  -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <configuration>
                        <testFailureIgnore>true</testFailureIgnore>
                    </configuration>
                </plugin>


            </plugins>
        </pluginManagement>
    </build>
</project>

4）将mybatis 配置到spring中的核心配置文件（applicationContext-base.xml），jdbc.properties 连接参数, logback.xml日志考到项目的resources目录下，并修改数据库的连接。

applicationContext-base.xml spring核心配置文件

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

    <!--1. 注解式开发 -->
    <!--1) 注解驱动,用于激活已经在spring容器中注册过的bean上面的注解-->
    <!--<context:annotation-config/>-->
    <!-- 2) 用注解方式注入bean，并指定查找范围：com.zking.oa及子子孙孙包，使用了该注解后，context:annotation-config注解可以省略 -->
    <context:component-scan base-package="com.zking.mybatis01"/>

    <!--2. 引入外置jdbc配置文件 -->
    <!-- 第一种方式
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:jdbc.properties"/>
    </bean>
    -->
    <!--ignore-resource-not-found  不配置的话 会绑定斯读取的参数  -->
    <!-- 第二种方式，比第一种方式更简洁，第一种方式更好理解一些 -->
    <context:property-placeholder location="classpath:jdbc.properties" ignore-resource-not-found="true"/>

    <!-- 3. dbcp2数据库连接池配置  阿里云-->
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource"
          destroy-method="close">
        <property name="driverClassName" value="${driver.name}"/>
        <property name="url" value="${db.url}"/>
        <property name="username" value="${db.user}"/>
        <property name="password" value="${db.password}"/>
        <!--初始连接数-->
        <property name="initialSize" value="10"/>
        <!--最大活动连接数-->
        <property name="maxTotal" value="100"/>
        <!--最大空闲连接数-->
        <property name="maxIdle" value="50"/>
        <!--最小空闲连接数-->
        <property name="minIdle" value="10"/>
        <!--设置为-1时，如果没有可用连接，连接池会一直无限期等待，直到获取到连接为止。-->
        <!--如果设置为N（毫秒），则连接池会等待N毫秒，等待不到，则抛出异常-->
        <property name="maxWaitMillis" value="-1"/>
          <!-- mysql 8小时问题 需要定时发送sql 执行 -->
        <property name="testWhileIdle" value="true"></property>
        <property name="validationQuery" value="select 1"></property>

    </bean>

    <!--4. spring和MyBatis整合 -->
    <!--1) 创建sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 指定数据源 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 指定mybatis核心配置文件 -->
        <!-- <property name="configLocation" value="classpath:mybatis.cfg.xml"/>-->
        <!-- 自动扫描XxxMapping.xml文件，**表示迭代查找 -->
        <property name="mapperLocations" value="classpath:/mapper/**/*.xml"/>

        <property name="plugins">
            <list>
                <bean class="com.github.pagehelper.PageInterceptor">
                    <property name="properties">
                        <!-- config params as the following -->
                        <value>
                            helperDialect=mysql
                        </value>
                    </property>
                </bean>
            </list>
        </property>

    </bean>

    <!--2) 自动扫描com/zking/oa/**/mapper下的所有XxxMapper接口(其实就是DAO接口)，并实现这些接口-->
    <!--   即可直接在程序中使用dao接口，不用再获取sqlsession对象-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--basePackage 属性是映射器接口文件的包路径。-->
        <!--你可以使用分号或逗号 作为分隔符设置多于一个的包路径-->
        <property name="basePackage" value="com/zking/**/mapper"/>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>

    <!--5. 声明式事务配置开始 -->
    <!--1) 开启自动代理 -->
    <aop:aspectj-autoproxy/>

    <!--2) 事务管理器 -->
   <bean id="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 注解式事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

jdbc.properties mysql 8.0 连接配置文件

driver.name=com.mysql.cj.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=Asia/Shanghai&characterEncoding=utf-8&allowPublicKeyRetrieval=true
db.user=root
db.password=123456

logback.xml 配置日志文件

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

    <!--定义日志文件的存储地址，勿在LogBack 的配置中使用相对路径-->
    <property name="LOG_HOME" value="d:\\temp\\mylogs" />
    <!-- 定义项目名称 -->
    <property name="LOG_NAME" value="mybatisdemo"/>

    <!-- 控制台输出 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- 日志滚动输出，按日期滚动 -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--日志文件输出的文件名-->
            <FileNamePattern>${LOG_HOME}/${LOG_NAME}.%d{yyyy-MM-dd}.log</FileNamePattern>
            <!--日志文件保留天数-->
            <MaxHistory>30</MaxHistory>
        </rollingPolicy>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
        <!--日志文件最大的大小-->
        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
            <MaxFileSize>10MB</MaxFileSize>
        </triggeringPolicy>
    </appender>

    <!-- myibatis 相关的日志配置，适合开发环境，便于调试 -->
    <!--<logger name="com.apache.ibatis" level="TRACE"/>
    <logger name="java.sql.Connection" level="DEBUG"/>
    <logger name="java.sql.Statement" level="DEBUG"/>
    <logger name="java.sql.PreparedStatement" level="DEBUG"/>-->

    <!-- 日志输出级别 -->
    <!-- 级别排序为： TRACE < DEBUG < INFO < WARN < ERROR -->
    <root level="INFO">
        <appender-ref ref="STDOUT" />
        <appender-ref ref="FILE"/>
    </root>

</configuration>

5）在src/main/resources目录下创建mapper用于方式mybatis的映射文件

6）创建包的目录结构，如下图所示：

7）ssh2与ssm的对应关系

ssh2	ssm
action	controller
service	service
dao	mapper
IXxxDao.java	XxxMapper
XxxDao.java	XxxMapper.xml
entity	model
Xxx.java	Xxx.java
Xxx.hbm.xml

8）编写model，即存放数据的对象，在ssh2时叫做entity。

这里就可以看到我们所用的lombok的强大的 @Data 会自动生成 get set 与tostring 等等。。。。

使用lombok需要有的插件

9）mapper编写（相当于dao）。

编写之前我们需下载一个插件方便编写mybatis 如下图

10）在目录结构中加入一个mapper包，在该包中创建一个TestMapper接口

创建好接口后 ----可直接使用插件生成 mybatis的xml配置文件

注意：第一次创建的时候会提示你选择地址我们直接选择 resources 中我们创建的mapper文件

~我们用student实体来做一个查询的实例使用方式 spring注解注入

1.mapper中定义的接口

package com.zking.mybatis01.mapper;

import com.zking.mybatis01.dto.StudentDto;
import com.zking.mybatis01.model.Student;

import org.springframework.stereotype.Repository;

import java.util.List;
@Repository("studentMapper")
public interface IStudentMapper {
    /**
     * 查询所有学生
     * @param stu 根据姓名 模糊查询
     * @return 返回 学生集合
     */
    public List<Student> listStudent(Student stu);

    /**
     * 增加学生
     * @param  stu 学生实体
     */
   public Integer addStudent(Student stu);

    /**
     * 修改学生信息
     * @param upd
     * @return
     */
   public Integer updStudent(Student upd);

    /**
     * 根据学生id 进行删除
     * @param stu
     * @return
     */
   Integer delStudent(Student stu);

    /**
     *  根据 用户多个id查询
     * @return
     */
   List<Student> listStudentByid(StudentDto dto);

}

注意：在xml中注释的方法要在对应的java接口中注释掉，（注释掉只是为了少写点代码，尽快测试）

注：#{} 与 ${} 的区别 #{ }是预编译处理，MyBatis在处理#{ }时，它会将sql中的#{ }替换为？，然后调用PreparedStatement的set方法来赋值，传入字符串后，会在值两边加上单引号，如上面的值 “4,44,514”就会变成“ ‘4,44,514’ ”

${ }是字符串替换， MyBatis在处理${ }时,它会将sql中的${ }替换为变量的值，传入的数据不会加两边加上单引号。

使用${ }会导致sql注入，不利于系统的安全性！

SQL注入：就是通过把SQL命令插入到Web表单提交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。常见的有匿名登录（在登录框输入恶意的字符串）、借助异常获取数据库信息等

2.如数据库与实体的属性名不一致需要配置映射关系如图：👇

2.1 .我们配置好的增删改查

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

    <!-- 查询所有 -->
    <select id="listStudent" resultType="com.zking.mybatis01.model.Student">
        select sid,sname,birthday,ssex
        FROM t_student
      <where>
          <if test="sname !=null and ''!=sname ">
               sname like  concat(#{sname},'%')
          </if>
      </where>
    </select>
    <!-- 根据用户提供的多个id 进行查询 -->
    <select id="listStudentByid" resultType="com.zking.mybatis01.model.Student">
        select sid,sname,birthday,ssex from t_student
<where>
    <choose>

       <when test="listSid != null and listSid.size != 0">
           and sid in
           <!-- collection 循环的属性名   item 循环中应用的名字  open 以什么开头  close 结尾   separator 循环一个后以，隔开    -->
         <foreach collection="listSid" item="sid" open="(" close=")" separator=",">
             #{sid}
         </foreach>
       </when>
    </choose>
</where>

    </select>

    <!-- 增加学生 -->
    <insert id="addStudent" parameterType="com.zking.mybatis01.model.Student">
    Insert into t_student (sname,birthday,ssex)
   values (#{sname},#{birthday},#{ssex})

    </insert>
  <!-- 修改学生信息 -->
    <update id="updStudent"  parameterType="com.zking.mybatis01.model.Student">
      update t_student
     <set>
       <if test="sname !=null and ''!=sname">
           sname = #{sname},
       </if>
         <if test="birthday !=null">
             birthday = #{birthday},
         </if>
         <if test="ssex !=null and ''!=ssex">
             ssex = #{ssex,jdbcType=NUMERIC}
         </if>
     </set>
      <where>
           sid = #{sid}
      </where>
    </update>
<!-- 根据id 进行删除 -->
    <delete id="delStudent" parameterType="com.zking.mybatis01.model.Student">
        delete  from t_student <where>
        sid = #{sid}
    </where>

    </delete>
</mapper>

3.接下来我们编写service 事务层

定义我们的service接口 ↓

package com.zking.mybatis01.service;

import com.zking.mybatis01.dto.StudentDto;
import com.zking.mybatis01.model.Student;
import com.zking.mybatis01.utils.PageBean;

import java.util.List;

public interface IStudentService {


    /**
     * 查询所有学生信息
     * @param stu 模糊查询
     * @return 学生集合
     */
    List<Student> listStudentpaging(Student stu , PageBean pge);
    /**
     * 增加学生
     * @param  stu 学生实体
     */
    Integer addStudent(Student stu);
    /**
     * 修改学生信息
     * @param upd
     * @return
     */
    public Integer updStudent(Student upd);
    /**
     * 根据学生id 进行删除
     * @param stu
     * @return
     */
    Integer delStudent(Student stu);
    /**
     *  根据 用户多个id查询
     * @return
     */
    List<Student> listStudentByid(StudentDto dto );
}

定义实现类

package com.zking.mybatis01.service;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.zking.mybatis01.dto.StudentDto;
import com.zking.mybatis01.interfaces.Paging;
import com.zking.mybatis01.mapper.IStudentMapper;
import com.zking.mybatis01.model.Student;
import com.zking.mybatis01.utils.PageBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
@Service
public class StudentServiceImpl implements IStudentService {
   //类型判断 注入
    @Autowired
    private IStudentMapper stu;

  
    @Override
    public List<Student> listStudentpaging(Student stu, PageBean pge) {


        return  this.stu.listStudent(stu);
    }

    @Override
    public Integer addStudent(Student stu) {
       return   this.stu.addStudent(stu);
    }

    @Override
    public Integer updStudent(Student upd) {
        return this.stu.updStudent(upd);
    }

    @Override
    public Integer delStudent(Student stu) {
        return this.stu.delStudent(stu);
    }

    @Override
    public List<Student> listStudentByid(StudentDto dto) {
        return this.stu.listStudentByid(dto);
    }
}

编写测试用例测试功能

部分测试

package com.zking.mybatis01.service;

import com.zking.mybatis01.dto.StudentDto;
import com.zking.mybatis01.model.Student;
import com.zking.mybatis01.utils.PageBean;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.Arrays;
import java.util.Date;
import java.util.List;
//帮我们去生成spring 上下文对象
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath*:applicationContext*.xml"})
public class StudentServiceImplTest {
    @Autowired
    private IStudentService studentService;


    @Test
    public void listStudent() {
        Student st=new Student();
        st.setBirthday(new Date());
        st.setSname("小黑");
        st.setSsex(1);
        /*List<Student> students = studentService.listStudent(st);
        students.forEach(t->System.out.println(t));*/

      Integer i=  studentService.addStudent(st);
        System.out.println(i);

    }
    @Test
    public void updStudent(){
        Student st=new Student();
        st.setSid(1);
        st.setBirthday(new Date());
        st.setSname("小名");
        st.setSsex(1);
        Integer integer = studentService.updStudent(st);
        System.out.println(integer);
    }
    @Test
   public void delStudent(){
       Student st=new Student();
       st.setSid(18);
       Integer integer = studentService.delStudent(st);
       System.out.println(integer);
   }
   @Test
 public void listStudentByid(){
       StudentDto studentDto = new StudentDto();
       studentDto.setListSid(Arrays.asList(1,2,3,5,6));
       List<Student> students = studentService.listStudentByid(studentDto);
       students.forEach(System.out::println);
   }

}

5.分页插件 pagehelper 的实现使用spring切面与自定义注解实现功能

引入pagehelper 包如果复制了上方的pom的可不需要加入

<!--  分页 -->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.1.2</version>
</dependency>

1.编写分页实体便于分页

package com.zking.mybatis01.utils;

import com.mysql.cj.util.StringUtils;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;



public class PageBean {

    /**
     * 页码
     */
    private int page = 1;

    /**
     * 每页显示的记录数
     */
    private int rows = 10;

    /**
     * 总记录数
     */
    private int total = 0;

    /**
     * 是否分页
     */
    private boolean pagination = true;

    /**
     * 记录查询的url，以便于点击分页时再次使用
     */
    private String url;

    /**
     * 存放请求参数，用于生成隐藏域中的元素
     */
    private Map<String,String[]> parameterMap;

    /**
     * 根据传入的Request初始化分页对象
     * @param request
     */
    public void setRequest(HttpServletRequest request) {

        if(!StringUtils.isNullOrEmpty(request.getParameter("page"))) {
            this.page = Integer.valueOf(request.getParameter("page"));
        }
        if(!StringUtils.isNullOrEmpty(request.getParameter("rows"))) {
            this.rows = Integer.valueOf(request.getParameter("rows"));
        }
        if(!StringUtils.isNullOrEmpty(request.getParameter("pagination"))) {
            this.pagination = Boolean.valueOf(request.getParameter("pagination"));
        }

        this.url = request.getRequestURI();
        this.parameterMap = request.getParameterMap();

        request.setAttribute("pageBean", this);
    }


    public int getPage() {
        return page;
    }


    public void setPage(int page) {
        this.page = page;
    }


    public int getRows() {
        return rows;
    }


    public void setRows(int rows) {
        this.rows = rows;
    }


    public int getTotal() {
        return total;
    }


    public void setTotal(int total) {
        this.total = total;
    }

    public boolean isPagination() {
        return pagination;
    }

    public void setPagination(boolean pagination) {
        this.pagination = pagination;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public Map<String, String[]> getParameterMap() {
        return parameterMap;
    }

    public void setParameterMap(Map<String, String[]> parameterMap) {
        this.parameterMap = parameterMap;
    }

    //计算起始页码
    public int getStartIndex() {
        return (this.page - 1) * this.rows;
    }

    //获取总页数
    public int getTotalPage() {
        if (this.getTotal() % this.rows == 0) {
            return this.getTotal() / this.rows;
        } else {
            return this.getTotal() / this.rows + 1;
        }
    }

    //上一页
    public int getPreviousPage() {
        return this.page - 1 > 0 ? this.page - 1 : 1;
    }

    //下一页
    public int getNextPage() {
        return this.page + 1 > getTotalPage() ? getTotalPage() : this.page + 1;
    }

}

2.在aop包中定义分页切面定义切面前需要架包 spring-aspects

package com.zking.mybatis01.aop;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.zking.mybatis01.utils.PageBean;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
@Aspect
public class PaginAop {
    //环绕通知  自定义注解 分辨是否调用
    @Around("@annotation(com.zking.mybatis01.interfaces.Paging)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
       //获取目标方法的所有参数
        Object[] args = joinPoint.getArgs();
        PageBean pag =null;
        for (Object arg : args) {
            if(arg instanceof PageBean){
                 pag=(PageBean) arg;
                if(pag!=null && pag.isPagination()){
                    PageHelper.startPage(pag.getPage(),pag.getRows());
                }
            }
        }
        Object proceed = joinPoint.proceed();
        if(pag!=null && pag.isPagination()){
            PageInfo info=new PageInfo((List) proceed);
            pag.setTotal((int)info.getTotal());
        }
        return  proceed;
    }


}

2.1 注解编写

接下来我们就可以去使用注解了

1.我们将自定义注解标记在我们需要分页的方法上在service中实现

2.测试用例中添加

   @Test
  public void listStudentPage(){
       PageBean page=new PageBean();
       page.setRows(3);
       List<Student> students = studentService.listStudentpaging(null, page);
       students.forEach(System.out::println);
   }

3.运行结果