MyBatis

关注

原创最新推荐文章于 2026-07-04 14:07:44 发布 553 阅读 AI 写同款· GEO 优化 ›

MyBatis源码的学习（15）---sqlSession.selectList方法 sqlSession一共俩个实现类，我们这里分析默认的DefaultSqlSession类 public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { try { //ms对象代表我们的xml中的一条sql。例如：<select... 阅读详情

框架 ( Farmework ) 是整个或部分系统,遵循可重用设计,表现为一组抽象构件,以及构件实例间交互的方法,另一种认为,框架是可被应用开发者定制的应用的骨架和模板

框架是一个半成品软件,定义好了一些基础功能 , 需要加入你的功能就是完整的

框架特点 :

框架一般不是全能的,不能做所有事情
框架是针对某一个领域有效, 特长在某一个方面,

三层架构:

界面层: (User Interface layer) controller (Servlet)

接收用户提交的数据,显示请求的处理结果,使用web页面和用户交互
html , Jsp , Servlet

业务逻辑层(Business Logic Layer) Service 包

接收表示传递过来的数据,检查数据,计算业务逻辑,调用数据访问层获取数据
Service

数据访问层(Data access layer) Dao 包

与数据库打交道,主要实现对数据的增删改查,将存储在数据库中的数据提交给业务层,同时将业务层处理的数据保存到数据库
Dao (持久层)

三层对应的处理框架:

界面层 —servlet类 ---- springmvc(框架)
业务逻辑层 — service 类 ---- spring (框架)
数据访问层 — Dao类 ---- mybatis (框架)

框架是一个模板

框架中定义了一些功能,这些功能是可用的
可以加入项目中自己的功能,这些功能可以利用框架中写好的功能

MyBatis框架:

mybatis(sql映射框架)

是MyBatis SQL Mapper Framework for java

sql mapper : sql 映射

可以把数据库表中的一行数据映射为一个java对象
一行数据可以看做是一个java对象
操作这个对象就相当于操作表中的数据

Data Access Objects (Daos) ; 数据访问

对数据库中执行增删改查

mybatis提供那些功能

提供了创建 Connection , Statement , ResultSet 的能力 , 不用开发人员创建这些对象了
提供了执行SQL语句的能力 , 不用你再执行sql
提供了循环sql , 把sql的结果转为list集合的能力
提供了关闭资源的能力,不用你再去关闭资源了

开发人员只需要提供sql语句即可

最后是 : 开发人员提供sql语句 — mybatis处理sql — 开发人员得到List集合或java对象 (表中的数据)

总结 :

MyBatis是一个sql映射框架 , 提供的数据库操作能力 , 可以看成是一个增强的JDBC

使用Mybatis 让我们的开发人员集中精神写sql即可 , 不必关心Connection , Statement , ResultSet 创建的创建 , 销毁 ,使用

使用步骤:

新建一个表 Student
加入maven的MyBatis坐标 , mysql驱动的坐标
创建实体类 Student – 保存表中的一行数据
创建持久层的Dao接口 , 定义操作数据库的方法
创建一个MyBatis使用的配置文件
- 叫做sql映射问文件 : 写SQL语句的 ,一般一个表一个SQL映射文件
- 这个文件是 .xml 文件
- 文件写在接口所在的目录中 , 文件的名称和接口保持一致
创建MyBatis的主配置文件
- 一个项目中就一个主配置文件
- 主配置文件提供了数据库的链接信息和SQL映射文件的位置信息
创建使用MyBatis的类
- 通过MyBatis访问数据库

SQL映射文件的编写

<!--
    sql映射文件 : 写sql语句的 , mybatis会执行这些sql

    1.指定约束文件
        <!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    mybatis-3-mapper.dtd 是约束文件的名称 , 扩展名是dtd的
    2.约束文件的作用 : 限制,检查在当前文件中出现的标签,属性必须符合mybatis的要求

    4.在当前文件中可以使用特定的标签 , 表示数据的特定操作
    <select> : 表示执行查询 , 只能执行select语句
    <update> : 表示更新数据库的操作,在标签中只能写update语句
    <insert> : 表示插入 , 放的是insert语句

    <delete> : 表示删除 , 执行的是delete语句
-->
<?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">
<!--
  3.mapper是当前文件的根标签,必须的
    namespace : 叫做命名空间,唯一值的,可以是自定义的字符串
                要求你使用dao接口的全限定名称(绝对路径 , 包名加类名)
-->
<mapper namespace="org.sichen.dao.StudentDao">
    <!--
        select : 表示查询操作
        id : 表示你要执行sql的语句的唯一标识
            mybatis会使用这个id的值来找到要执行的SQL的语句
            可以自定义 , 但是要求你是用接口中的方法名

        resultType : 表示结果类型的 ,
            是SQL语句执行后得到的ResultSet , 遍历这个ResultSet得到java对象的类型
            规定查询出来的数据的类型
        值就是类型的全限定名称
    -->
    <select id="findAll" resultType="org.sichen.domain.Student">
        select id,name,email,age from student order by id;
    </select>
    <insert id="insertStudent">
       <!--这里使用 #{} 一种占位符 里边写插入数据类型对应bean中的属性名-->  
        insert into student values(#{id},#{name},#{email},#{age});
    </insert>
</mapper>

主配置文件的编写:

<?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>
    <!-- environments : 加s说明可以有多个数据库的配置信息
                环境配置 : 就是数据库的配置信息
           default : 必须和某个environment的id值一样
                告诉mybatis使用那个数据库的连接信息,也就是访问那个数据库-->
    <environments default="development">
        <!-- environment : 一个数据库信息的配置 , 环境
                id : 是一个唯一值 , 是一个自定义的 , 是用来表示环境的名称的-->
        <environment id="development">
            <!-- transactionManager : mybatis的事务类型
                type : 值有两个
                  JDBC (表示使用jdbc中的connection对象的commit,rollback做事务处理)  -->
            <transactionManager type="JDBC"/>
            <!--dataSource 代表数据源,连接数据库的
                   type : 表示数据库的类型
                        POOLED : 表示使用连接池-->
            <dataSource type="POOLED">
                <!--配置数据库的具体信息的
                        这些值是固定的,不能自定义,-->
                <!--driver : 数据库的驱动类名-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <!--连接数据库的url字符串-->
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC"/>
                <!--访问数据库的用户名称-->
                <property name="username" value="root"/>
                <!--访问数据库的用户密码-->
                <property name="password" value="acpl159357"/>
            </dataSource>
        </environment>
    </environments>
    <!--mapper: 指定sql映射文件的位置
        从类路径开始的路径信息
            也就是从编译后的classes目录下的路径开始的(如下图所示),
			默认情况下,编译后不会保留配置文件 , 需要在pom.xml文件中加一个编译的插件
        -->
    <mappers>
        <mapper resource="org/sichen/dao/StudentDao.xml"/>
    </mappers>
</configuration>

1646471815241

编译时保留配置文件的插件:

<build>
    <resources>
      <resource>
        <directory>src/main/java</directory><!--所在的目录-->
        <includes><!--包括目录下的.properties , .xml文件都会被扫描到-->
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>
  </build>

使用:

//访问mybatis读取student数据
        //1.定义mybatis的主配置文件的名称 ,
        //从类路径的根开始(target/classes , 不用写这个路径,是默认从这个路径开始找的)
        String config = "mybatis.xml";
        //2.读取这个config表示的文件
        InputStream in = Resources.getResourceAsStream(config);
        //(要使用org.apache.ibatis.io这个包下的文件)

        //3.创建了SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        //4.创建SqlSessionFactory对象
        SqlSessionFactory factory = builder.build(in);
        //5.[重要的]获取SqlSession对象 , 从SqlSessionFactory中获取SqlSession
        SqlSession sqlSession = factory.openSession();
        //6.[重要的]指定要执行的sql语句的标识 , sql映射文件中的namespace + "." + 标签的id值
        String sqlId = "org.sichen.dao.StudentDao" + "." + "findAll";
        //7.执行SQL语句,通过sqlId来找到语句
        List<Student> studentList = sqlSession. selectList(sqlId);
        //8.输出结果(这个是jdk8才有的新功能)
        studentList.forEach(stu -> System.out.println(stu));
        //9.关闭SqlSession对象
        sqlSession.close();

注意:

MyBatis默认不是自动提交事务的

所以在执行增删改之后,要手工提交事务

sqlSession.commit();

开启日志功能:(很方便开发调试)

在主配置文件中添加日志配置 , 可以在控制台输出执行的sql语句和参数

<configuration>
<!--settings控制MyBatis全局行为的-->
    <settings>
        <!--设置mybatis输出日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
</configuration>

主要的类的介绍:

String config = "mybatis.xml";
InputStream in = Resources.getResourceAsStream(config);
/*
Resources : mybatis中的一个类 , 负责读取主配置文件
*/

SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory factory = builder.build(in);
/*
SqlSessionFactoryBuilder : 提供一个方法 build
	通过读取配置文件,去创建一个SqlSessionFactory

SqlSessionFactory : 重量级对象 , 程序创建一个对象耗时比较长,使用资源比较多
	在整个项目中创建一个就够了
    它本身是一个接口
    	接口的实现类 : DefaultSqlSessionFactory
        DefaultSqlSessionFactory作用 : 获取SqlSession对象
*/

SqlSession sqlSession = factory.openSession();
/*
openSession()方法说明 : 
	openSession(): 无参的 , 获取的是非自动提交事务的SqlSession对象
	openSession(boolean): 值为true: 获取的是自动提交事务的SqlSession对象
	
SqlSession 接口说明 : 
	定义了操作数据库的方法 
	例如 : selectOne() , selectList() , insert() , update() , delete() , commit() ,
			rollback()
SqlSession 的实现类 : DefaultSqlSession

使用要求 : 
	SqlSession对象不是线程安全的,需要在方法内部使用 , 
	在执行sql语句之前 , 使用openSession()获取SqlSession对象 , 
	在执行sql语句之后 , 需要关闭它 , 执行SqlSession.close();
	
*/
String sqlId = "org.sichen.dao.StudentDao" + "." + "findAll";
List<Student> studentList = sqlSession. selectList(sqlId);
studentList.forEach(stu -> System.out.println(stu));
sqlSession.close();

使用工具类封装重复操作 :

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;

public class MyBatisUtils {
    private static SqlSessionFactory factory = null;
    static {
        String config = "mybatis.xml";
        try {
            InputStream in = Resources.getResourceAsStream(config);
	//一步到位直接获取SqlSessionFactory , 省略了创建SqlSessionFactoryBuilder过程
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
//外界获取SqlSession的方法
    public static SqlSession getSqlSession() {
        SqlSession sqlSession = null;
        if (factory != null) {
            sqlSession = factory.openSession();
        }
        return sqlSession;
    }
}

使用动态代理来执行SQL语句:(非常重要)

也就是不用再创建实现类了 , mybatis根据你的dao调用的方法 , 这一条语句 , 获取你的全限定名称 , 还有调用的方法 , 以及确定调用的是哪一个SqlSession的方法

StudentDao studentdao = new StudentDaoImpl();
/**
* StudentDao studentdao = new StudentDaoImpl();调用
* 1.dao对象 , 类型是StudentDao , 全限定名称是 : com.sichen.dao.StudentDao
* 全限定名称和 namespace 是 一样的
* 
* 2.方法名称 : findAll , 这个方法就是mapper文件中的 id值 findAll
* 
* 3.通过dao中方法的返回值也可以确定MyBatis要调用的SqlSession方法
*   如果返回值是list , 调用的是SqlSession.selectList()方法
* 	如果返回值是 int , 或是非list的 , 看mapper文件中的标签是<insert> <update> 就会调用
*   SqlSession的insert , update等方法
* 
*  MyBatis的动态代理 
*  mybatis框架根据dao的方法调用 , 获取执行sql语句的信息
*  mybatis根据你的Dao接口 , 创建出一个Dao接口的实现类 , 并创建这个类的对象 , 
*    来完成SqlSession 调用方法 , 访问数据库

*/
List<Student> StudentList = studentdao.findAll();

以前写的时候 ,还需要创建实现类 , 将接口实例化 , 然后调用实现类中的方法 , 完成操作 ,

现在只需要写一个dao接口

/**
* 使用mybatis的动态代理的机制 , 使用SqlSession.getMapper(dao接口.class)
* getMapper 能够获取dao接口对于实现类的对象
* 这个是Mybatis使用动态代理的方式 , 自己实现的 , 我们只需要传递这个接口的class类型 , 就可以创建出一个实现类对象 , 调用其中的方法
*/
SqlSession sqlSession = MyBatisUtils.getSqlSession();
StudentDao dao = sqlSession.getMapper(StudentDao.class);
//调用dao的方法 , 执行数据库的操作
List<Student> all = dao.findAll();
for (Student student : all) {
    System.out.println(student);
}

MyBatis的传参是怎么完成的:

传入参数 : 从java代码中把数据传入到mapper文件的xml中

/*
parameterType : 写在mapper文件中的一个属性 , 表示dao接口中方法的参数的数据类型
		值 : 是java的数据类型的全限定名称 , java.lang.Integer
			或者是mybatis定义的别名  int
resultType : 规定返回值的数据类型 
    	值 : 是java的数据类型的全限定名称
             或者是mybatis定义的别名
注意 : parameterType :不是强制的 , mybatis通过反射机制能够发现接口参数的数据类型
	所以可以没有 , 一般我们也不写

一个简单类型的参数 :

/*
简单类型 : 
	mybatis把java的基本数据类型 , 和String 都叫做简单数据类型 
在mapper中 , 文件获取简单数据类型的一个参数的值 , 使用 #{任意字符} 
	使用 #{}之后 , mybatis执行sql是使用jdbc中的PreparedStatement对象
	由mybatis执行下面的代码 
	1. mybatis创建 Connection , PreparedStatement 对象 
*/
String sql = "select * from student where id = ? ";
PreparedStatement pst = conn.preparedStatement(sql);
pst.setInt(1,1003);
   //2.执行sql封装为  resultType="org.sichen.domain.Student" 这个对象
ResultSet rs = ps.executeQuery();
Student student = null;
while(rs.next()){
    //从数据库中取表的行数据 , 存到一个java对象的属性中 
  	student = new Student();
    student.setId(rs.getInt("id"));
    student.setName(rs.getString("name"));
    student.setEmail(rs.getString("email"));
    student.setAge(rs.getInt("age"));
}
return student; //给了dao方法调用的返回值


//接口定义 : 
public Student findOne(int id);

<!--mapper中的定义-->
	<select id="findOne" resultType="org.sichen.domain.Student">
        select * from student where id = #{id};  <!--这个可以是任意的字符-->
    </select>
<!--(parameterType可以忽略不写)-->

多个参数 :

多个参数 : 使用 @Param :

@Param : 命名参数

//接口 : 
public List<Student> findTwo(@Param("myname") String name , @Param("myage") Integer age);

//使用@Param命名参数
@Param("参数名") String name , @Param("参数名") Integer age

<!--mapper文件中 :-->
    <select id="findTwo" resultType="org.sichen.domain.Student">
        select *
        from student
        where name = #{myname}
           or id = #{myid};
    </select>

多个参数 : 使用对象 :

使用java对象传递参数 , java的属性值就是SQL需要的参数值 , 每一个属性就是一个参数 ,

创建一个bean对象用来存储属性 QueryParam.java

这个类型是没有限制的 , 什么类型都可以

public class QueryParam {
    private String myname;
    private Integer myage;
    //提供get和set方法 
}

//接口 :
List<Student> findThree (QueryParam param);

<!--mapper文件中
        使用对象的语法 :
         完整语法 : #{属性名 , javaType=类型名称 , jdbcType=数据库类型 }
            例如 : #{myname , javaType=java.lang.String , jdbcType=VARCHAR}
         开发中一般使用的语法 :
            #{属性名} 其他两个值 , mybatis反射能够获取 , 不用提供
    -->
    <select id="findThree" resultType="org.sichen.domain.Student">
        select *
        from student
        where name = #{myname}
           or id = #{myage};
    </select>

多个参数 : 按位置 :(不常用)

语法 : 
#{arg0} , #{arg1} ,这种格式 
按照传递参数从左往右数的位置, 在后边加上下标

多个参数 : 使用Map: (不常用)

语法 : 
#{key的名称}

#和$的区别:

/*
# : 叫做占位符 , 告诉MyBatis使用实际的参数值替代 , 并使用 PrepareStatement对象执行sql	语句 , #{...}代替sql语句中的 ? 
	这样做更安全(避免sql注入) , 便捷 ,通常也是首选做法
	select * from student where id = ?;
	
$ : 字符串替换 ,告诉MyBatis使用$包含的字符串替换所在位置 , 使用Statement把SQL语句 和${}的内容连接起来 , 
主要用在替换表名 , 列名 , 不同列排序等操作 
	select * from student where id = 1001;

使用$替换列名.或表名

select * from ${传递的表名} where id = ?;

MyBatis的输出结果:

简介:

mybatis执行sql语句 , 得到java对象

ResultType : 结果类型 , 指SQL语句执行完毕之后 , 数据转为java对象 , 这个java类型是任意的 ,

处理方式 :

mybatis执行sql语句 , 然后mybatis调用类的无参数构造方法 , 创建对象
mybatis把ResultSet指定的列值赋给同名的属性

常见处理 : 比如说 , 表中有很多列 , 但是我们只需要获取 , 其中的一些数据 , 那么可以将这些需要的属性封装一个类 , 让返回值类型为这个封装的类 , 这样查询出来的数据 , 就只有封装的类中的属性 ,

返回一个简单类型 :

返回的值可以是别名(mybatis规定的别名 , 有固定的格式 , 是简化代码书写的)

也可以是java类型的全限定名称

//接口中 : 
int selectCount();

<!--mapper中 : -->
<select id="selectCount" resultType="int(别名)或者是java.lang.Integer(全限定名称)">
	select count(*) from student;
</select>

返回一个Map: (使用比较少)

sql的查询结果作为Map的key和value , 推荐使用Map<Object , Object>

注意 : Map作为接口返回值 , sql语句的查询结果最多只能有一条记录 , 大于一条记录是错误

ResultMap : 结果映射 (指定列名和java对象的属性对应关系)

(1) 你自定义你的列值赋值给哪个属性

(2) 当你的列名和属性名不一样时 ,一定要使用resultMap

<!--
    使用resultMap
        先定义resultMap
        在select标签中 , 使用resultMap来引用1定义的
    -->
<resultMap id="studentMap" type="org.sichen.domain.Student">
    <!--
            id : 自定义名称 , 表示你定义的这个resultMap (就是resultType的值)
            type : java类型的全限定名称
        -->
    <!--列名和java属性的关系-->
    <!--主键列 , 使用id标签
            column : 列名
            property :  java类型的属性名(也就是要赋值的属性)
        -->
    <id column="id" property="id"></id>
    <!--非主键列 , 使用result-->
    <result column="name" property="name"></result>
    <result column="email" property="email"></result>
    <result column="age" property="age"></result>
</resultMap>
<!--这里是ResultMap , 注意 !!!!!
ResultMap  和   ResultType二者不能同时用 , 只能二选一
-->
<select id="selectAllStudents" resultMap="studentMap">
        select id,name,email,age from student;
</select>

列名和属性名不同的两种方法 :

(1) 使用ResultMap , 也就是上边的解决方法

(2) ResultType默认的原则是 , 同名的列值赋值给同名的的属性 , 所以可以给列起别名 , (对应java对象的属性名)

自定义类型的别名: typeAlias

在mybatis主配置文件中定义 , 使用定义别名

然后就可以在resultType中使用自定义的别名

第一种 : 给数据类型定义别名(也就是创建的实体类)

 <!--给数据类型  定义别名-->
<typeAliases>
    <!--
        可以指定一个类型 , 一个自定义别名
        type : 自定义类型的全限定名称
        alias : 自定义的别名
        -->
    <typeAlias type="org.sichen.domain.QueryParam" alias="qp"/>
    <typeAlias type="org.sichen.domain.Student" alias="stu"/>
</typeAliases>

第二种方式 : 直接给这个类型所在的包设置

这个包下的所有类 , 类名就是别名 (类名不区分大小写)

<typeAliases>
	<package name="org.sichen.domain.Student"/>
</typeAliases>

模糊查询 Like:

第一种 : Java代码中准备好like的值

也就是直接传值到mapper中 ,使用#{} 来表示

第二种 : 直接在mapper中拼接值

select id,name,email,age from student where name like "%" #{name} "%";
注意 : 这里的空格必须有 , 根据需要拼接 "%" 即可

动态SQL :

动态SQL : SQL 语句的内容是变化的 , 我们可以根据条件获取到不同的sql语句 ,主要是where部分发生变化

动态SQL的实现 : 使用的是mybatis提供的各种标签 ,

动态SQL要使用java对象作为参数 ,

if : 判断条件的

<!--语法 :--> 
<if test="判断java对象的属性值">
    部分SQL语句
</if>

<select id="selectStudentIf" resultType="org.sichen.domain.Student">
        select id, name, email, age
        from student
        where 1 = 1
        <if test="name!=null and name!=''">
            and name = #{name}
        </if>
        <if test="age>0">
            and age = #{age}
        </if>
    </select>

where:用来包含多个if的 ,

当多个if有一个成立的话 , where标签会自动增加一个where关键字 , 并去掉if中多余的and , or 等

(比如说 , 有些条件前边是or 直接加这个条件会造成SQL语法错误 , 但是where能够自动将这个or去掉 , 把语法错误避开)

如果都不满足 , 就什么都不会加 , 也不会加where语句

<select id="selectStudentWhere" resultType="org.sichen.domain.Student">
        select id, name, email, age
        from student
        <where>
            <if test="name!=null and name!=''">
                and name = #{name}
            </if>
            <if test="age>0">
                and age = #{age}
            </if>
        </where>
    </select>

注意: 从上往下 , 第一个if中的条件可以不加连接语句 , 但是后边的语句都要加连接语句 , 最好是全部加上

foreach: 循环java中的数组或 list集合的

主要用在SQL的in语句中

学生id是 1001 , 1002 , 1003 的三个学生

select * from student where id in (1001 , 1002 , 1003);

<select id="selectStudentForeach" resultType="org.sichen.domain.Student">
        select id,name,email,age
        from student
        where id in
        <foreach collection="list" item="myid" open="(" close=")" separator=",">
                #{myid}
        </foreach>
    </select>
    <!--
        collection : 表示接口中的方法参数的类型 , 如果是数组使用array , 如果是list集合使用list
        item : 自定义的 , 表示数组和集合成员的变量
        open : 循环开始时的字符   "("
        close : 循环结束时的字符   ")"
        separator : 集合成员之间的符号  ","
    -->

如果传递的是一个List 里边存储的是一个Student对象 ,

<foreach collection="list" item="stu" open="(" close=")" separator=",">
                #{stu.id}
</foreach>

动态SQL之代码片段 :

 <!--定义 sql片段 , 使用的是sql 标签 id值与下边引用这个代码片段的refid的值一致-->
    <sql id="studentSql">
        select id,name,email,age from student
    </sql>
    <select id="selectStudentsql" resultType="org.sichen.domain.Student">
        /*引用SQL片段的时候使用include标签 refid的值就是上边sql标签中的id值*/
        <include refid="studentSql" />
        <if test="list!=null and list.size>0">
            where id in
            <foreach collection="list" item="id" open="(" close=")" separator=",">
                #{id}
            </foreach>
        </if>
    </select>

主配置文件的属性 :

设置mybatis输出日志 :(重复之前)

setting是mybatis的全局设置

它可以指定很多的name ,以及对应的值

<settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

定义别名 :(重复之前)

<!--定义别名-->
    <typeAliases>
        <!--
        可以指定一个类型 , 一个自定义别名
        type : 自定义类型的全限定名称
        alias : 自定义的别名
        -->
        <typeAlias type="org.sichen.domain.QueryParam" alias="qp"/>
        <typeAlias type="org.sichen.domain.Student" alias="stu"/>
        <!--指定package标签 , 该文件夹下的所有类的名称就是别名-->
        <package name="org.sichen.domain.Student"/>
    </typeAliases>

环境变量的设置 :(了解)

<environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <!--
				transactionManager : 提交事务 , 回滚事务的方式
				type : 事务处理的类型
     (1)JDBC 表示mybatis底层是调用JDBC中的Connection对象 , commit ,rollback
(2)MANAGED	: 把mybatis的事务处理委托给其他的容器(可以是一个服务器软件 , 或者框架(Spring))			
			-->
            <dataSource type="POOLED">
 <!--
	dataSource : 表示数据源 , Java体系中 , 规定实现了javax.sql.DataSource接口的都是数					据源
		数据源 : 表示Connection对象的
	type : 指定数据源的类型 
		(1)POOLED : 使用连接池 , mybatis会创建PooledDataSource类
		(2)UNPOOLED : 不使用连接池 , 在每次执行sql语句时 , 先创建连接 , 执行sql ,在关					闭连接
 			mybatis会创建一个UnPooledDataSource , 管理Connection对象的使用
		(3)JNDI : java的命名和目录服务 , (相当于windows的注册表)
-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="acpl159357"/>
            </dataSource>
        </environment>
    </environments>

数据库属性配置文件:(重要)

把数据库连接信息放到一个单独的文件中 , 和mybatis主配置文件分开 , 目的是便于修改 , 保存 , 处理多个数据库的信息

(1) 在Sources 目录中定义一个属性配置文件 , xxx.properties

在属性配置文件中 , 定义数据 , 格式是 key = value

key : 一般使用 . 做多级目录的

例如 : jdbc.mysql.Driver = com.mysql.cj.jdbc,Driver

jdbc.url = jdbc:mysql:// …

这么做的目的是 : 使结构更加清晰 , 能够一眼看出哪几个是一起的

(2) 在mybatis的主配置文件 , 使用指定文件的位置

在需要值的地方 , ${key}

<configuration>
    <!--指定properties文件的位置 , 从类路径根开始找文件-->
    <properties resource="jdbc.properties"/>
</configuration>

<!--driver : 数据库的驱动类名-->
<property name="driver" value="${jdbc.Driver}"/>
<!--连接数据库的url字符串-->
<property name="url" value="${jdbc.url}"/>
<!--访问数据库的用户名称-->
<property name="username" value="${jdbc.user}"/>
<!--访问数据库的用户密码-->
<property name="password" value="${jdbc.password}"/>

指定多个mapper文件:

第一种方式 : 就是上边有的 , 每指定一个文件 , 写一个mapper

第二种方式 : (使用包名)

name是你的mapper文件所在的包的包名全限定名称 ,

在这个包下的所有mapper文件 , 都能够被一次性加载进mybatis

**注意 : **

mapper 文件名称必需要和接口名称一样 , 区分大小写
mapper文件和 dao接口必须在同一目录之中

<mappers>
	<package name="">
</mappers>

typeHandlers 标签 : 自定义类型处理器

首先要编写数据类型的转换器类 ,

public class TypeHandler extends BaseTypeHandler<Date> {
    //将java类型 转换为 数据库需要的类型
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, Date parameter, JdbcType jdbcType) throws SQLException {
        long time = parameter.getTime();
        ps.setLong(i,time);
    }
    //将数据库中类型转换为java类型
    //ResultSet : 查询出的结果集
    //String : 要转换的字段名称
    @Override
    public Date getNullableResult(ResultSet rs, String columnName) throws SQLException {
        return null;
    }
    //将数据库中类型转换为java类型
    @Override
    public Date getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        return null;
    }
    //将数据库中类型转换为java类型
    @Override
    public Date getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        return null;
    }

然后在MyBatis核心配置文件中注册类型处理器

<typeHandlers>
    <typeHandler class="自定义数据转换类型的全限定名称">
    </typeHandler>
</typeHandlers>

PageHelper : MyBatis通用分页插件(实用)

使用 :

首先 , 添加PageHelper的jar包

<!--使用PageHelper的jar包-->
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>5.3.0</version>
    </dependency>

(2) 加入plugin配置 :

注意是在主配置文件中添加的 , 而不是添加在pom.xml文件中

<plugins>
    <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>

java中编写 :

SqlSession sqlSession = MyBatisUtils.getSqlSession();
StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
/*加入分页查询的数据
其中PageNum : 第几页数据(为0的话就查不出来数据了)
PageSize : 一页中有多少行数据
* */
/*PageHelper.startPage(PageNum,PageSize);*/
PageHelper.startPage(2,3);
List<Student> studentList = studentDao.selectAllTwo();
for (Student student : studentList) {
	System.out.println(student);
}