MyBatis

<!--maven核心文件-->
<?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>
    <!--maven配置文件，包含maven静态资源过滤代码-->
    <!--项目创建的gav，最后还要加一个packaging为打包格式，一般为jar-->
    <groupId>com.wang.mabatis</groupId>
    <artifactId>mybatis_demo1</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <!--导入jar包的标签-->
    <dependencies>
        <!--  Mybatis核心  -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.9 </version>
        </dependency>
        <!--  junit测试  -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!--  MySQL驱动  -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>

        <!--  log4j日志  -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.16</version>
        </dependency>
    </dependencies>
<!--Maven静态资源过滤问题-->
<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

</project>

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

        <!--
                MyBatis核心配置文件中，标签的顺序：
                properties?,settings?,typeAliases?,typeHandlers?,
                objectFactory?,objectWrapperFactory?,reflectorFactory?,
                plugins?,environments?,databaseIdProvider?,mappers?
            -->
<configuration>
<!--引入properties文件-->
    <properties resource="jdbc.properties"></properties>
    <settings>
		<!--将表中字段的下划线自动转换为驼峰-->
		<setting name="mapUnderscoreToCamelCase" value="true"/>
		<!--开启延迟加载-->
		<setting name="lazyLoadingEnabled" value="true"/>
	</settings>

    <!--设置类型别名-->
    <typeAliases>
        <!--
                   typeAlias：设置某个类型的别名
                   属性：
                       type：设置需要设置别名的类型
                       alias：设置某个类型的别名，若不设置该属性，那么该类型拥有默认的别名，即类名且不区分大小写
               -->
        <!--<typeAlias type="com.atguigu.mybatis.pojo.User"></typeAlias>-->
        <!-- <typeAlias type="com.wang.pojo.User" alias="User"></typeAlias>-->
        <!--以包为单位，将包下所有的类型设置默认的类型别名，即类名且不区分大小写-->
        <package name="com.wang.pojo"/>
    </typeAliases>
    <!--
           environments：配置多个连接数据库的环境
           属性：
               default：设置默认使用的环境的id
       -->
    <environments default="development">
        <environment id="development">
            <!--
              transactionManager：设置事务管理方式
              属性：
                  type="JDBC|MANAGED"
                  JDBC：表示当前环境中，执行SQL时，使用的是JDBC中原生的事务管理方式，事务的提交或回滚需要手动处理
                  MANAGED：被管理，例如Spring
          -->
            <transactionManager type="JDBC"/>
            <!--
               dataSource：配置数据源
               属性：
                   type：设置数据源的类型
                   type="POOLED|UNPOOLED|JNDI"
                   POOLED：表示使用数据库连接池缓存数据库连接
                   UNPOOLED：表示不使用数据库连接池
                   JNDI：表示使用上下文中的数据源
           -->
            <dataSource type="POOLED">
                <!--设置连接数据库的驱动-->
                <property name="driver" value="${jdbc.driver}"/>
                <!--设置连接数据库的连接地址-->
                <property name="url" value="${jdbc.url}"/>
                <!--设置连接数据库的用户名-->
                <property name="username" value="${jdbc.username}"/>
                <!--设置连接数据库的密码-->
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!--引入MyBatis映射文件-->
    <mappers>
        <!--这是传入一个mapper的接口-->
        <!--<mapper resource="mappers/UserMapper.xml"/>-->
        <!--
            以包为单位引入映射文件（多个包目录下的接口）
            要求：
            1、mapper接口所在的包要和映射文件所在的包一致
            2、mapper接口要和映射文件的名字一致
        -->
        <package name="com.wang.mapper"/>
    </mappers>
</configuration>

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

 <dataSource type="POOLED">
                <!--设置连接数据库的驱动-->
                <property name="driver" value="${jdbc.driver}"/>
                <!--设置连接数据库的连接地址-->
                <property name="url" value="${jdbc.url}"/>
                <!--设置连接数据库的用户名-->
                <property name="username" value="${jdbc.username}"/>
                <!--设置连接数据库的密码-->
                <property name="password" value="${jdbc.password}"/>
            </dataSource>

<!--对应pom引入的log4j的日志，复制即可-->
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS}
%m (%F:%L) \n" />
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug" />
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info" />
    </logger>
    <root>
        <level value="debug" />
        <appender-ref ref="STDOUT" />
    </root>
</log4j:configuration>

<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--对应java目录下的xxxMapper文件，创建时要与java目录下的mapper文件结构一致，方便在mybatis-config.xml配置文件中以包配置mapper接口-->
        <!--
            以包为单位引入映射文件（多个包目录下的接口）
            要求：
            1、mapper接口所在的包要和映射文件所在的包一致
            2、mapper接口要和映射文件的名字一致
        -->
<mapper namespace="com.wang.mapper.UserMapper">
  <!--增删改查等-->
    
      
</mapper>

package com.wang.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

/**
 * @program: mybatis_new_study
 * @description: 测试的方法工具
 * @author: WMS
 * @create: 
 **/
public class SqlSessionUtils {

   public  static SqlSession getSqlSession() {
       SqlSession sqlSession = null;
       try {
           InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
           SqlSessionFactory build = new SqlSessionFactoryBuilder().build(is);
            sqlSession = build.openSession(true);

       } catch (IOException e) {
           e.printStackTrace();
       }
       return sqlSession;
   }

}

<!--头部文件-->
<?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">
<!--mybatis-3-config.dtd对应名称，版本，文件性质名称，文件类型dtd-->

MyBatis核心配置文件中，标签的顺序：
<configuration>
properties?,settings?,typeAliases?,typeHandlers?,
objectFactory?,objectWrapperFactory?,reflectorFactory?,
plugins?,environments?,databaseIdProvider?,mappers?
</configuration>

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

<?xml version="1.0" encoding="utf-8"?>
<!--配置文件中可以使用哪些标签，这个地方是配置这是一个mybatis文件，使用mybatis文件标签-->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--开始配置信息-->
<configuration>
 <!-- 导入配置文件 -->   
        <properties resource="jdbc.properties"></properties>
<!-- environments的 default属性配置的是默认 运行环境，其后面的值就是environment中的id -->
 <!--
           environments：配置多个连接数据库的环境
           属性：
               default：设置默认使用的环境的id
       -->
    <environments default="development">
        <environment id="development">
 <!--
              transactionManager：设置事务管理方式
              属性：
                  type="JDBC|MANAGED"
                  JDBC：表示当前环境中，执行SQL时，使用的是JDBC中原生的事务管理方式，事务的提交或回滚需要手动处理
                  MANAGED：被管理，例如Spring
          -->
            <transactionManager type="JDBC"/>
<!--
               dataSource：配置数据源
               属性：
                   type：设置数据源的类型
                   type="POOLED|UNPOOLED|JNDI"
                   POOLED：表示使用数据库连接池缓存数据库连接
                   UNPOOLED：表示不使用数据库连接池
                   JNDI：表示使用上下文中的数据源
           -->
            <dataSource type="POOLED">
                <!--设置连接数据库的驱动-->
                <!-- com.mysql.jdbc.Driver或com.mysql.cj.jdbc.Driver -->
                <property name="driver" value="${jdbc.driver}"/>
				<!--设置连接数据库的连接地址-->
                <property name="url" value="${jdbc.url}"/>
               <!--设置连接数据库的用户名-->
                <property name="username" value="${jdbc.username}"/>
                <!--设置连接数据库的密码-->
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--        <mapper resource="映射文件这个地方配置sql语句，后面具体演示"></mapper>-->
        <mapper resource="mappers/StudentMapper.xml"></mapper>
    </mappers>
</configuration>

<settings>
	<setting name="cacheEnabled" value="true"/>
	<setting name="lazyLoadingEnabled" value="true"/>
	<setting name="multipleResultSetsEnabled" value="true"/>
	<setting name="useColumnLabel" value="true"/>
	<setting name="useGeneratedKeys" value="false"/>
	<setting name="autoMappingBehavior" value="PARTIAL"/>
	<setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
	<setting name="defaultExecutorType" value="SIMPLE"/>
	<setting name="defaultStatementTimeout" value="25"/>
	<setting name="defaultFetchSize" value="100"/>
	<setting name="safeRowBoundsEnabled" value="false"/>
	<setting name="mapUnderscoreToCamelCase" value="false"/>
	<setting name="localCacheScope" value="SESSION"/>
	<setting name="jdbcTypeForNull" value="OTHER"/>
	<setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

	cacheEnabled: 全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存。参数为：true | false，默认值为：true。运行原理：在同一个session中的同样类型的查询，会调用第一次查询的数据，而不会再次调用MySql语句去访问数据库。
	lazyLoadingEnabled：全局启用或禁用延迟加载。当禁用时，所有关联对象都会即时加载。参数为：true | false，默认值为：true。运行原理：懒加载，级联对象都不会加载，而在你需要的时候，返回数据库单独查找。
	aggressiveLazyLoading：当启用时，对任意延迟属性的调用会使带有延迟加载属性的对象完整加载；反之，每种属性将会按需加载。参数为：true | false，版本3.4.1 （不包含）之前 true，之后 false。
	multipleResultSetsEnabled：是否允许单一语句返回多结果集（需要兼容驱动）。参数为：true | false，默认值为：true。
	useColumnLabel：使用列标签代替列名。不同的驱动会有不同的表现，具体可参考相关驱动文档或通过测试这两种不同的模式来观察所用驱动的结果。参数为：true | false，默认值为：true。
	useGeneratedKeys： 允许JDBC 支持自动生成主键，需要驱动兼容。如果设置为 true，则这个设置强制使用自动生成主键，尽管一些驱动不能兼容但仍可正常工作（比如 Derby）。参数为：true | false，默认值为：true。
	autoMappingBehavior： 指定 MyBatis 应如何自动映射列到字段或属性。NONE 表示取消自动映射。PARTIAL 表示只会自动映射，没有定义嵌套结果集和映射结果集。FULL 会自动映射任意复杂的结果集（无论是否嵌套）。参数为：NONEPARTIAL、FULL，默认值为：PARTIAL。	
	autoMappingUnkno wnColumnBehavior： 指定自动映射当中未知列（或未知属性类型）时的行为。 默认是不处理，只有当日志级别达到 WARN 级别或者以下，才会显示相关日志，如果处理失败会抛出 SqlSessionException 异常。参数为：NONE、WARNING、FAILING，默认值为：NONE。			
	defaultExecutorType： 配置默认的执行器。SIMPLE 是普通的执行器；REUSE 会重用预处理语句（prepared statements）；BATCH 执行器将重用语句并执行批量更新。参数为：SIMPLE、REUSE、BATCH，默认值为：SIMPLE。
	defaultStatementTimeout： 设置超时时间，它决定驱动等待数据库响应的秒数。参数为：任何正整数、Not Set (null)。
	defaultFetchSize： 设置数据库驱动程序默认返回的条数限制，此参数可以重新设置。参数为：任何正整数、Not Set (null)。
	safeRowBoundsEnabled： 允许在嵌套语句中使用分页（RowBounds）。如果允许，设置 false。参数为：true | false，默认值为：false。
	safeResultHandlerEnabled： 允许在嵌套语句中使用分（ResultHandler）。如果允许，设置false。参数为：true | false，默认值为：true。				 		
	mapUnderscoreToCamelCase： 是否开启自动驼峰命名规则映射，即从经典数据库列名 A_COLUMN 到经典 Java 属性名 aColumn 的类似映射。参数为：true | false，默认值为：false。
	localCacheScopeMyBatis： 利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速联复嵌套査询。默认值为 SESSION，这种情况下会缓存一个会话中执行的所有查询。若设置值为 STATEMENT，本地会话仅用在语句执行上，对相同 SqlScssion 的不同调用将不会共享数据 。参数为：SESSION|STATEMENT，默认值为：SESSION。
	jdbcTypeForNull：当没有为参数提供特定的 JDBC 类型时，为空值指定 JDBC 类型。某些驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。参数为：NULL、VARCHAR、OTHER，默认值为：OTHER 。
	lazyLoadTriggerMethods：指定哪个对象的方法触发一次延迟加载。
	defaultScriptingLanguage：指定动态 SQL 生成的默认语言。
	callSettersOnNulls：指定当结果集中值为 null 时，是否调用映射对象的 setter（map 对象时为 put）方法，这对于 Map.kcySet() 依赖或 null 值初始化时是有用的。注意，基本类型（int、boolean 等）不能设置成 null。参数为：true | false，默认值为：false。	  	
	logPrefix：指定 MyBatis 增加到日志名称的前缀 。参数为：任何字符串，默认值为：Not set。
	loglmpl：指定 MyBatis 所用日志的具体实现，未指定时将自动査找。参数为：SLF4J|LOG4J、LOG4J2、JDK_LOGGING、	COMMONS_LOGGING、ST DOUT_LOGGING|NO_LOGGING，默认值为：Not set。
	proxyFactory：指定 MyBatis 创建具有延迟加栽能力的对象所用到的代理工具。参数为：CGLIB、JAVASSIST	默认值为：JAVASSIST （MyBatis 版本为 3.3 及以上的） 。
	vfsImpl：指定 VFS 的实现类 。提供 VFS 类的全限定名，如果存在多个，可以使用逗号分隔 。默认值为：Not set。
	useActualParamName：允许用方法参数中声明的实际名称引用参数。要使用此功能，项目必须被编译为 Java 8 参数的选择。（从版本 3.4.1 开始可以使用）参数为：true | false，默认值为：true。	  	

 <!--
                   typeAlias：设置某个类型的别名
                   属性：
                       type：设置需要设置别名的类型
                       alias：设置某个类型的别名，若不设置该属性，那么该类型拥有默认的别名，即类名且不区分大小写
               -->

<!-- 创建一个类，其包+类名  com.wang.pojp.User  -->

<!-- 这个配置是写在mybatis-config.xml中的 -->

<configuration>
    ....
    <typeAliases >
        <typeAlias type="com.wang.pojp.User" alias="User"> 
            <!--<typeAlias type="com.com.wang.pojp.User" -->
    </typeAliases>
 
    ....
</configuration>

<!-- 这个配置是写在UsertMapper.xml中的 这个返回类型就可以使用自定义别名了 -->
 <select id="getAllStudent" resultType="User">
        SELECT 	* FROM  testmybatis.student
    </select>
    <!-- 这个配置是写在UsertMapper.xml中的 如果不设置alias，相对于没写typeAlias标签 ，在xxxMapper.xml中resultType就要返回实体类完整的路径-->
    <select id="getAllStudent" resultType="com.wang.pojp.User">
        SELECT 	* FROM  testmybatis.student
    </select>

<!-- 创建一个类，其包+类名  com.wang.pojp.User  -->

<!-- 这个配置是写在mybatis-config.xml中的 -->

<configuration>
    ....
    <typeAliases >
     <!--以包为单位，将包下所有的类型设置默认的类型别名，即类名且不区分大小写-->
         <package name="com.wang.pojo"/>
        
    </typeAliases>
 
    ....
</configuration>

<!-- 这个配置是写在UsertMapper.xml中的 这个返回类型就可以使用默认的类名作为别名了，会默认其包下的类名即为别名，而且不区别大小写。  -->
<!-- List<User> getUser();-->
    <select id="getUser" resultType="User">
        select * from user;
    </select>

<!--引入MyBatis映射文件-->
    <mappers>
        <!--这是传入一个mapper的接口-->
        <!--但是如果是多个的话，那是需要输入很多行，所以其也支持包（应该说文件夹）导入，然后将其包下的配置文件，全部导入其中。-->
        <!--<mapper resource="mappers/UserMapper.xml"/>-->
        <!--
            以包为单位引入映射文件（多个包目录下的接口）
            要求：
            1、mapper接口所在的包要和映射文件所在的包一致
            2、mapper接口要和映射文件的名字一致
        -->
        <package name="com.wang.mapper"/>
    </mappers>

<!--头部文件-->
<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
        <!--mybatis-3-mapper.dtd对应名称，版本，文件性质名称，文件类型dtd-->

<!--namespace对应xxxMapper的接口文件-->
<mapper namespace="com.wang.mapper.UserMapper">
  
</mapper>

<select id="selectPerson" parameterType="int" resultType="hashmap">
  SELECT * FROM PERSON WHERE ID = #{id}
</select>

<select 要加resultType>
增删改不用加

<insert
  id="insertAuthor"
  parameterType="domain.blog.Author"
  flushCache="true"
  statementType="PREPARED"
  keyProperty=""
  keyColumn=""
  useGeneratedKeys=""
  timeout="20">

<update
  id="updateAuthor"
  parameterType="domain.blog.Author"
  flushCache="true"
  statementType="PREPARED"
  timeout="20">

<delete
  id="deleteAuthor"
  parameterType="domain.blog.Author"
  flushCache="true"
  statementType="PREPARED"
  timeout="20">

package com.wang.pojo;

/**
 * @program: mybatis_new_study
 * @description: 员工表t_emp
 * @author: WMS
 * @create: 2023-02-14 19:54
 **/
public class Emp {
    private Integer eid;
    private String empName;
    private int age;
    private String sex;
    private String email;
 /**
   * 必须提供一个无参数的构造函数
   */
    public Emp() {
    }
//有参方法
 // getter,setter方法
//toString方法
 
}

<?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.wang.mapper.EmpMapper">
<!-- 
        resultMap：设置自定义映射关系
        id：唯一标识，不能重复
        type：设置映射关系中的实体类类型
        子标签：
        id：设置主键的映射关系
        result：设置普通字段的映射关系
        属性：
        property：设置映射关系中的属性名，必须是type属性所设置的实体类类型中的属性名
        column：设置映射关系中的字段名，必须是sql语句查询出的字段名
     -->
    <resultMap id="empResultMap" type="Emp">
        <id property="eid" column="eid"></id>
        <result property="empName" column="emp_Name"></result>
        <result property="age" column="age"></result>
        <result property="sex" column="sex"></result>
        <result property="email" column="email"></result>
    </resultMap>
    <!--List<Emp> getAllEmp();-->
    <select id="getAllEmp" resultMap="empResultMap">
        select * from t_emp;
    </select>
</mapper>

<select id="getStudent" resultMap="getStudentRM">
  SELECT ID, Name, Age
    FROM TStudent
</select>
<resultMap id="getStudentRM" type="EStudnet">
  <constructor>
    <idArg column="ID" javaType="_long"/>
    <arg column="Name" javaType="String"/>
    <arg column="Age" javaType="_int"/>
  </constructor>
</resultMap>

//在实体类A中添加实体类B，并添加getter/setter+toString等方法
public class Emp {
    private Integer eid;
    private String empName;
    private int age;
    private String sex;
    private String email;
    private Dept dept;//添加的内容
//getter/setter+toString+有参和无参方法
}

//在接口类中添加方法  
/*根据id查询员工以及员工对应的部门名称*/
   Emp getEmpAndDept(@Param("eid") Integer eid);

//在xml映射文件中用在实体类中命名的为引用.属性名为property
<!--   /*根据id查询员工以及员工对应的部门名称*/
   Emp getEmpAndDept(@Param("eid") Integer eid);-->
    <resultMap id="empAndDeptResult" type="Emp">
        <id property="eid" column="eid"></id>
        <result property="empName" column="emp_Name"></result>
        <result property="age" column="age"></result>
        <result property="sex" column="sex"></result>
        <result property="email" column="email"></result>
        <!-- 使用级联属性查询 （引用.属性）-->
        <result property="dept.did" column="did"></result>
        <result property="dept.deptName" column="dept_name"></result>
    </resultMap>
<select id="getEmpAndDept" resultMap="">
    select * from t_emp
    left join t_dept on t_emp.did = t_dept.did
     where t_eid = #{eid}
</select>

public class MybatisTest {
    @Test
    public void getEmpAndDeptTest(){
        SqlSession sqlSession = SqlsessionUtils.getSqlSession();
        EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
        System.out.println(mapper.getEmpAndDept(1));
        
    }

   Emp getEmpAndDept(@Param("eid") Integer eid);-->
    <resultMap id="empAndDeptResult" type="Emp">
        <id property="eid" column="eid"></id>
        <result property="empName" column="emp_Name"></result>
        <result property="age" column="age"></result>
        <result property="sex" column="sex"></result>
        <result property="email" column="email"></result>
        <!-- 
            association:处理多对一的映射关系
            property:需要处理多对的映射关系的属性名
            javaType:该属性的类型，其中Dept为pojo对应的实体类的类型
         -->
        <association property="dept" javaType="Dept">
            <id property="did" column="did"></id>
            <result property="deptName" column="dept_name"></result>
        </association>
    </resultMap>
    <select id="getEmpAndDept" resultMap="empAndDeptResult">
    select * from t_emp
    left join t_dept on t_emp.did = t_dept.did
     where t_emp.eid = #{eid}
</select>

//在emp中创建接口方法
///*根据id查询员工以及员工对应的部门名称*/
Emp getEmpAndDeptByStepOne(@Param("eid") Integer eid);

   <resultMap id="empAndDeptByStepResultMap" type="Emp">
        <id property="eid" column="eid"/>
        <result property="empName" column="emp_name"/>
        <result property="age" column="age"/>
        <result property="sex" column="sex"/>
        <result property="email" column="email"/>
		<!--相当于引入dept中的select查到的sql方法，然后传入column中的did，-->
		<!--传入did后，正常执行下面的sql语句-->
        <association property="dept" select="com.wang.mapper.DeptMapper.getEmpAndDeptByStepTwo" column="did" fetchType="eager">
		<!--property:需要处理多对的映射关系的属性名
			select:设置分步查询的sql的唯一标识（namespace.SQLId或mapper接口的全类名.方法名）
					在接口方法中，点击方法名，鼠标右键，选择复制引用（Y）
    		column:设置分布查询的条件
  			fetchType:当开启了全局的延迟加载之后，可通过此属性手动控制延迟加载的效果
            fetchType="lazy|eager":lazy表示延迟加载（加载当前执行的sql，获得对应参数），eager表示立即加载(立即加载sql再获取参数)
		-->
        </association>
    </resultMap>
	<!--Emp getEmpAndDeptByStepOne(@Param("eid") Integer eid);-->
    <select id="getEmpAndDeptByStepOne" resultMap="empAndDeptByStepResultMap">
        select * from t_emp
    	left join t_dept on t_emp.did = t_dept.did
     	where t_emp.eid = #{eid}
    </select>

  /*通过did查询对应部门*/
Dept getEmpAndDeptByStepTwo(@Param("did") Integer did);

<!--在DeptMapper.xml写对应方法查did-->
<?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.wang.mapper.DeptMapper">
    <resultMap id="DeptMap" type="Dept">
        <id property="did" column="did"></id>
        <result property="deptName" column="dept_name"></result>
    </resultMap>
<!--  Dept getEmpAndDeptByStepTwo(@Param("did") Integer did);-->
    <select id="getEmpAndDeptByStepTwo" resultMap="DeptMap">
        select * from t_dept where did = #{did}
    </select>
</mapper>

<!-- 
            collection：处理一对多的映射关系
            ofType：表示该属性所对应的集合中存储数据的类型
         -->

public class Dept {
    private Integer did;
    private String deptName;
    private List<Emp> emps;
    public Dept() {
    }
    //getter和setting等方法

//根据did查员工信息
Dept getDeptAndEmp(@Param("did") Integer did);

 <!-- Dept getDeptAndEmp(@Param("did") Integer did);-->
    <select id="getDeptAndEmp" resultMap="getDeptAndEmpResultMap">
        select * from t_dept left join t_emp on t_dept.did = t_emp.did where t_dept.did = #{did}
    </select>
    <resultMap id="getDeptAndEmpResultMap" type="Dept">
        <id property="did" column="did"></id>
        <result property="deptName" column="dept_name"></result>

        <collection property="emps" ofType="Emp">
            <id property="eid" column="eid"></id>
            <result property="empName" column="emp_name"></result>
            <result property="age" column="age"></result>
            <result property="sex" column="sex"></result>
            <result property="email" column="email"></result>
        </collection>
    </resultMap>

//测试
 @Test
    public void getDeptAndEmpTest(){
        SqlSession sqlSession = SqlsessionUtils.getSqlSession();
        DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);

        System.out.println(mapper.getDeptAndEmp(2));
    }
//Dept{did=2, deptName='B', emps=[Emp{eid=2, empName='明', age=3, sex='m', email='123@qq.com', dept=null}]}

//在Dept实体类接口写方法
Dept getDeptByDid(@Param("did") Integer did);

<!--在DeptMapper写sql -->
<!--Dept getDeptByDid(@Param("did") Integer did);-->
    <select id="getDeptByDid" resultMap="getDeptByDidResultMap">
<!--查did-->
        select * from t_dept where did = #{did}
    </select>
    <resultMap id="getDeptByDidResultMap" type="Dept">
        <id property="did" column="did"></id>
        <result property="deptName" column="dept_name"></result>
<!--根据在Emp接口方法查did-->
        <collection property="emps"
                    select="com.wang.mapper.EmpMapper.getAllByDid"
                    column="did">
        </collection>
    </resultMap>

//在EmpMapper接口处查did
List<Emp> getAllByDid(@Param("did") Integer did);

//sql语句
<!--   List<Emp> getAllByDid(@Param("did") Integer did);-->
<select id="getAllByDid" resultType="Emp">
    select * from t_emp where did = #{did}
</select>

//测试
@Test
public void getDeptByDidTest(){
    SqlSession sqlSession = SqlsessionUtils.getSqlSession();
    DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);

    System.out.println(mapper.getDeptByDid(1));

}

DEBUG 02-16 11:08:04,808 ==>  Preparing: select * from t_dept where did = ? (BaseJdbcLogger.java:137) 
DEBUG 02-16 11:08:04,836 ==> Parameters: 1(Integer) (BaseJdbcLogger.java:137) 
DEBUG 02-16 11:08:04,855 ====>  Preparing: select * from t_emp where did = ? (BaseJdbcLogger.java:137) 
DEBUG 02-16 11:08:04,856 ====> Parameters: 1(Integer) (BaseJdbcLogger.java:137) 
DEBUG 02-16 11:08:04,859 <====      Total: 2 (BaseJdbcLogger.java:137) 
DEBUG 02-16 11:08:04,861 <==      Total: 1 (BaseJdbcLogger.java:137) 
Dept{did=1, deptName='A', emps=[Emp{eid=1, empName='null', age=2, sex='m', email='123@qq.com', dept=null}, Emp{eid=3, empName='null', age=4, sex='w', email='123@qq.com', dept=null}]}

//根据用户名查询用户信息
User getUserByUsername(String username);

<!--实现根据用户名查询用户信息的功能。将该SQL语句的方法与mapper接口中getUserByUsername(String username)方法关联-->
<select id="getUserByUsername" resultType="User">
    <!--使用#{}时，大括号里的名称可以写成任意名称如#{aaa}等。因为使用#{}进行赋值时，只和赋值顺序有关，和名称无关-->
    <!--select * from t_user where username = #{username}-->
    <!--使用${}时，大括号里的名称也可以写成任意名称，但是还需要加上''以符合sql语法-->
    select * from t_user where username = '${username}'
</select>

//测试根据用户名获取用户信息的功能
@Test
public void testGetUserByUsername(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
    User user = mapper.getUserByUsername("admin");
    System.out.println(user);
}

//验证登录
User checkLogin(String username, String password);

<!--实现验证登录的功能。将该SQL语句的方法与mapper接口中checkLogin(String username, String password)方法关联-->
<select id="checkLogin" resultType="User">
    <!--
        当参数为多个字面量类型时，系统会自动把多个参数放入一个map集合中([arg1, arg0, param1, param2])，
        然后以arg为key，以参数为value，或者以param为key，以参数为value。因此有多个参数时，使用arg或者param来赋值。
        -->
    <!--select * from t_user where username = #{arg0} and password = #{arg1}-->
    <!--select * from t_user where username = #{param1} and password = #{param2}-->
    select * from t_user where username = '${arg0}' and password = '${arg1}'
</select>

//测试验证登录的功能
@Test
public void testCheckLogin(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
    User user = mapper.checkLogin("admin", "123456");
    System.out.println(user);

//验证登录(参数为map)
User checkLoginByMap(Map<String, Object> map);

<!--实现验证登录(参数为map)的功能。将该SQL语句的方法与mapper接口中checkLoginByMap(Map<String, Object> map)方法关联-->
<select id="checkLoginByMap" resultType="User">
    <!--此时#{}和${}中的名称以自己定义的map的key为准-->
    <!--select * from t_user where username = #{username} and password = #{password}-->
    select * from t_user where username = '${username}' and password = '${password}'
</select>

//测试验证登录(参数为map)的功能
@Test
public void testCheckLoginByMap(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("username", "admin");
    map.put("password", "123456");
    User user = mapper.checkLoginByMap(map);
    System.out.println(user);

/**
* 查询所有用户信息为map集合
* @return
* 将表中的数据以map集合的方式查询，一条数据对应一个map；若有多条数据，就会产生多个map集合，此
时可以将这些map放在一个list集合中获取
*/
List<Map<String, Object>> getAllUserToMap();

<!--Map<String, Object> getAllUserToMap();-->
<select id="getAllUserToMap" resultType="map">
select * from t_user
</select>

/**
* 查询所有用户信息为map集合
* @return
* 将表中的数据以map集合的方式查询，一条数据对应一个map；若有多条数据，就会产生多个map集合，并
且最终要以一个map的方式返回数据，此时需要通过@MapKey注解设置map集合的键，值是每条数据所对应的
map集合
*/
@MapKey("id")
Map<String, Object> getAllUserToMap();

<!--Map<String, Object> getAllUserToMap();-->
<select id="getAllUserToMap" resultType="map">
select * from t_user
</select>
结果：
<!--
{
1={password=123456, sex=男, id=1, age=23, username=admin},
2={password=123456, sex=男, id=2, age=23, username=张三},
3={password=123456, sex=男, id=3, age=23, username=张三}
}
-->

//添加用户信息
int insertUser(User user);

<!--实现添加用户信息的功能。将该SQL语句的方法与mapper接口中insertUser(User user)方法关联-->
<insert id="insertUser">
    <!--使用#{}和${}直接通过实体类中的属性名获取属性值-->
    insert into t_user values(null, #{username}, #{password}, #{age}, #{sex}, #{email})
</insert>

//测试添加用户信息的功能
@Test
public void testInsertUser(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
    int result = mapper.insertUser(new User(null, "李四", "123", 23, "男", "123@qq.com"));
    System.out.println(result);

//验证登录(使用@Param注解)
/**
 * 使用@param注解后，MyBatis会将参数放入map集合，然后以@Param
 * 注解中的值为key，以之后的参数为value
 */
User checkLoginByParam(@Param("username") String username, @Param("password") String password);

<!--
    实现验证登录(使用@Param注解)的功能。将该SQL语句的方法与mapper接口中
    checkLoginByParam(@Param("username") String username, @Param("password") String password)方法关联
-->
<select id="checkLoginByParam" resultType="User">
    select * from t_user where username = #{username} and password = #{password}
</select>

//测试验证登录(使用@Param注解)的功能
@Test
public void testCheckLoginByParam(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
    User user = mapper.checkLoginByParam("admin", "123456");
    System.out.println(user);

select * from user where username like '%${}%'
select * from user where username like concat ('%',#{username},'%')
 select  * from user where username like "%"#{username}"%"

<!--在xxxMapper接口方法中-->
int deleteMore(@Param("ids") String ids);
<!--在xxxMapper.xml中的sql语句-->
<!--int deleteMore(@Param("ids") String ids);-->
<delete id="deleteMore">
delete from t_user where id in (${ids})
</delete>

/**
* 动态设置表名，查询所有的用户信息
* @param tableName
* @return
*/
List<User> getAllUser(@Param("tableName") String tableName);

<!--List<User> getAllUser(@Param("tableName") String tableName);-->
<select id="getAllUser" resultType="User">
select * from ${tableName}
</select>

/**
* 添加用户信息
* @param user
* @return
* useGeneratedKeys：设置使用自增的主键
* keyProperty：因为增删改有统一的返回值是受影响的行数，因此只能将获取的自增的主键放在传输的参
数user对象的某个属性中
*/
int insertUser(User user);

<!--int insertUser(User user);-->
<insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
insert into t_user values(null,#{username},#{password},#{age},#{sex})
</insert>

    /*获取emp表中所有信息*/
    List<Emp> getEmp(Emp emp);

<!-- List<Emp> getEmp(Emp emp);-->
<select id="getEmp" resultType="Emp" >
    select * from t_emp where 1=1
    <!--1=1来使恒成立，同时后面接and来拼接sql语句-->
    <if test="empName !=null and empName !=''">
        emp_name = #{empName}
    </if>
    <if test="age !=null and age !=''">
        and age = #{age}
    </if>
    <if test="sex !=null and sex !=''">
        and sex = #{sex}
    </if>
    <if test="email !=null and email !=''">
        and email= #{email}
    </if>
</select>

<!-- List<Emp> getEmp(Emp emp);-->
<select id="getEmp" resultType="Emp" >
    select * from t_emp
    <where>
    <if test="empName !=null and empName !=''">
       and emp_name = #{empName}
    </if>
    <if test="age !=null and age !=''">
        and age = #{age}
    </if>
    <if test="sex !=null and sex !=''">
        and sex = #{sex}
    </if>
    <if test="email !=null and email !=''">
        and email= #{email}
    </if>
    </where>

<trim prefix="SET" suffixOverrides=",">
  ...
</trim>

<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG WHERE state = ‘ACTIVE’
  <choose>
    <when test="title != null">
      AND title like #{title}
    </when>
    <when test="author != null and author.name != null">
      AND author_name like #{author.name}
    </when>
    <otherwise>
      AND featured = 1
    </otherwise>
  </choose>
</select>

    /**
     * 通过数组实现批量删除
     */
    int deleteMoreByArray(@Param("eids") Integer[] eids);

<!-- int deleteMoreByArray(@Param("eids") Integer[] eids); -->
<delete id="deleteMoreByArray">
<!--等价于	delete from t_emp where eid = ? or eid=?....-->
delete from t_emp where
<foreach collection="eids" item="eid" separator="or"> eid = #{eid} </foreach>
<!-- delete from t_emp where eid in （?，?，?，，，）
            delete from t_emp where eid in
            <foreach collection="eids" item="eid" separator="," open="(" close=")">
                #{eid}
            </foreach>
         -->
</delete>

<!-- int insertMoreByList(@Param("emps") List<Emp> emps); -->
<insert id="insertMoreByList">
insert into t_emp values
<foreach collection="emps" item="emp" separator=","> (null,#{emp.empName},#{emp.age},#{emp.sex},#{emp.email},null) </foreach>
</insert>

<!-- /*批量添加*/
int insertMoreByList(@Param("emps") List<Emp> emps);-->
<insert id="insertMoreByList">
    insert into t_emp values
    <foreach collection="emps" item="emp" separator=",">
        (null,#{emp.empName},#{emp.age},#{emp.sex},#{emp.email},null)
    </foreach>
</insert>

@Test
public void insertMoreByListTest() {
    SqlSession sqlSession = SqlsessionUtils.getSqlSession();
    DynamicSqlMapper mapper = sqlSession.getMapper(DynamicSqlMapper.class);
    Emp emp1 = new Emp(null, "a1", 23, "男", "123@qq.com");
    Emp emp2 = new Emp(null,"a2",23,"男","123@qq.com");
    Emp emp3 = new Emp(null,"a3",23,"男","123@qq.com");
    List<Emp> emps = Arrays.asList(emp1, emp2, emp3);
    System.out.println(mapper.insertMoreByList(emps));
}

EBUG 02-16 21:12:47,634 ==>  Preparing: insert into t_emp values (null,?,?,?,?,null) , (null,?,?,?,?,null) , (null,?,?,?,?,null) (BaseJdbcLogger.java:137) 
DEBUG 02-16 21:12:47,673 ==> Parameters: a1(String), 23(Integer), 男(String), 123@qq.com(String), a2(String), 23(Integer), 男(String), 123@qq.com(String), a3(String), 23(Integer), 男(String), 123@qq.com(String) (BaseJdbcLogger.java:137) 
DEBUG 02-16 21:12:47,705 <==    Updates: 3 (BaseJdbcLogger.java:137) 

<sql id="empColumns">eid,emp_name,age,sex,email</sql>
<!-- List<Emp> getEmpByCondition(Emp emp); -->
<select id="getEmpByCondition" resultType="Emp">
	select
	<include refid="empColumns"/>
	from t_emp
<trim prefix="where" suffixOverrides="and|or">
<if test="empName != null and empName != ''"> emp_name = #{empName} and </if>
<if test="age != null and age != ''"> age = #{age} or </if>
<if test="sex != null and sex != ''"> sex = #{sex} and </if>
<if test="email != null and email != ''"> email = #{email} </if>
</trim>
</select>

  @Test
    public void testTwoCache(){
        try {
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
            CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
            System.out.println(mapper1.getEmpByEid(1));
            <!--要符合四个条件
            	设置全局配置属性cacheEnabled="true"，默认为true，不需要设置
            	在映射文件中设置标签<cache/>
            	**二级缓存必须在SqlSession关闭或提交之后有效** 
            	查询的数据所转换的实体类类型必须实现序列化的接口
            -->
            sqlSession1.close();
            SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
            CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class);
            System.out.println(mapper2.getEmpByEid(1));
            sqlSession2.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    <cache eviction="" flushInterval="" size="" readOnly="" blocking="" type="" />

<!-- Mybatis EHCache整合包 -->
<dependency>
<groupId>org.mybatis.caches</groupId>
<artifactId>mybatis-ehcache</artifactId>
<version>1.2.1</version>
</dependency>
<!-- slf4j日志门面的一个具体实现 -->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.3</version>
</dependency>

<?xml version="1.0" encoding="utf-8" ?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
<!-- 磁盘保存路径 -->
<diskStore path="D:\atguigu\ehcache"/>
<defaultCache
maxElementsInMemory="1000"
maxElementsOnDisk="10000000"
eternal="false"
overflowToDisk="true"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LRU">
</defaultCache>
</ehcache>

<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="true">
<!-- 指定日志输出的位置 -->
<appender name="STDOUT"
class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<!-- 日志输出的格式 -->
<!-- 按照顺序分别是：时间、日志级别、线程名称、打印日志的类、日志主体内容、换行 -
->
<pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger]
[%msg]%n</pattern>
</encoder>
</appender>
<!-- 设置全局日志级别。日志级别按顺序分别是：DEBUG、INFO、WARN、ERROR -->
<!-- 指定任何一个日志级别都只打印当前级别和后面级别的日志。 -->
<root level="DEBUG">
<!-- 指定打印日志的appender，这里通过“STDOUT”引用了前面配置的appender -->
<appender-ref ref="STDOUT" />
</root>
<!-- 根据特殊需求指定局部日志级别 -->
<logger name="com.atguigu.crowd.mapper" level="DEBUG"/>
</configuration>

<!-- 依赖MyBatis核心包 -->
<dependencies>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.7</version>
</dependency>
</dependencies>
<!-- 控制Maven在构建过程中相关配置 -->
<build>
<!-- 构建过程中用到的插件 -->
<plugins>
<!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
<plugin>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-maven-plugin</artifactId>
<version>1.3.0</version>
<!-- 插件的依赖 -->
<dependencies>
<!-- 逆向工程的核心依赖 -->
<dependency>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-core</artifactId>
<version>1.3.2</version>
</dependency>
<!-- 数据库连接池 -->
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.2</version>
</dependency>
<!-- MySQL驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.8</version>
</dependency>
</dependencies>
</plugin>
</plugins>
</build>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
<!--
targetRuntime: 执行生成的逆向工程的版本
MyBatis3Simple: 生成基本的CRUD（清新简洁版）
MyBatis3: 生成带条件的CRUD（奢华尊享版）
-->
<context id="DB2Tables" targetRuntime="MyBatis3Simple">
<!-- 数据库的连接信息 -->
<jdbcConnection driverClass="com.mysql.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/mybatis"
userId="root"
password="123456">
</jdbcConnection>
<!-- javaBean的生成策略-->
<javaModelGenerator targetPackage="com.atguigu.mybatis.bean"
targetProject=".\src\main\java">
<property name="enableSubPackages" value="true" />
<property name="trimStrings" value="true" />
</javaModelGenerator>
<!-- SQL映射文件的生成策略 -->
<sqlMapGenerator targetPackage="com.atguigu.mybatis.mapper"
targetProject=".\src\main\resources">
<property name="enableSubPackages" value="true" />
</sqlMapGenerator>
<!-- Mapper接口的生成策略 -->
<javaClientGenerator type="XMLMAPPER"
targetPackage="com.atguigu.mybatis.mapper" targetProject=".\src\main\java">
<property name="enableSubPackages" value="true" />
</javaClientGenerator>
<!-- 逆向分析的表 -->
<!-- tableName设置为*号，可以对应所有表，此时不写domainObjectName -->
<!-- domainObjectName属性指定生成出来的实体类的类名 -->
<table tableName="t_emp" domainObjectName="Emp"/>
<table tableName="t_dept" domainObjectName="Dept"/>
</context>
</generatorConfiguration

 * limit index,pageSize
 * index:当前页的起始索引
 * pageSize：每页显示的条数
 * pageNum：当前页的页码
 * index=(pageNum-1)*pageSize
 *
 * 使用MyBatis的分页插件实现分页功能：
 * 1、需要在查询功能之前开启分页
 * PageHelper.startPage(int pageNum, int pageSize);
 * 2、在查询功能之后获取分页相关信息
 * PageInfo<Emp> page = new PageInfo<>(list, 5);
 * list表示分页数据
 * 5表示当前导航分页的数量
 */

<!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.2.0</version>
</dependency>

<plugins>
<!--设置分页插件-->
<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>

ABDDBCBCBDB
ACDccbdcddcc
DBBBD
cbbcd