MyBatis 框架

前言

以下笔记内容来自B站动力节点MyBatis教程实战精讲的课程内容，我自己跟着视频的内容对原有笔记进行了适当的增改，仅供参考

第一章 框架的概述

1.三层架构

mvc：web开发中，使用mvc架构模式。 m：数据， v：视图， c：控制器。

​ c控制器： 接收请求，调用service对象，显示请求的处理结果。 当前使用servlet作为控制器

​ v视图： 现在使用jsp， html，css，js。 显示请求的处理结果，把m中数据显示出来。

​ m数据： 来自数据库mysql， 来自文件，来自网络

mvc作用：

​ 1）实现解耦合。

​ 2）让mvc 各负其职。

​ 3）使得系统扩展性更好，更容易维护。

三层架构：

1.界面层（视图层、表现层）：接收用户的请求，调用service， 显示请求的处理结果的。 包含了jsp，html，servlet等对象。 对应的包controller，

2.业务逻辑层：处理业务逻辑， 使用算法处理数据的。 把数据返回给界面层。 对应的是service包，和包中的很多的XXXService类。 例如： StudentService ， OrderService, ShopService

3.持久层（数据库访问层）：访问数据库，或者读取文件，访问网络。获取数据。 对应的包是dao。 dao包中很多的StudentDao, OrderDao, ShopDao等等。

2. 三层架构请求的处理流程

用户发起请求---->界面层----->业务逻辑层---->持久层---->数据库（mysql）

3. 为什么要使用三层？

1，结构清晰、耦合度低, 各层分工明确
2，可维护性高，可扩展性高
3，有利于标准化
4，开发人员可以只关注整个结构中的其中某一层的功能实现
5，有利于各层逻辑的复用

4. 三层架构模式和框架

每一层对应着一个框架

1）界面层---SpringMVC框架

2）业务层---Spring框架

3）持久层---MyBatis框架

5 .框架

1. 什么是框架（framework）

框架：就是一个软件， 完成了部分的功能。 软件中的类和类之间的方法调用都已经规定好了。 通过这些可以完成某些功能。 框架看做是模版。

框架是可以升级的，改造的。 框架是安全的。

框架是对某一个方面有用的，不是全能的。

6. 框架解决的问题

1）框架能实现技术的整合。

2）提供开发的效率。 降低难度。

7. jdbc访问数据库的优缺点

优点：

1. 直观，好理解

缺点：

1. 创建很多对象 Connection ,Statement, ResultSet
2. 注册驱动
3. 执行sql语句
4. 把ResultSet转为 Student ， List集合。
5. 关闭资源
6. sql语句和业务逻辑代码混在一起

8 MyBatis框架

什么 mybatis： 是一个持久层框架， 原名是ibatis， 2013改名为 MyBatis. MyBatis可以操作数据库，对数据执行增删改查。 看做是高级的jdbc。 解决jdbc的缺点。

mybatis能做什么？

1） 注册驱动 。

2） 创建jdbc中使用的Connection， Statement，ResultSet

3. 执行sql语句， 得到ResultSet

4. 处理ResultSet， 把记录集中的数据转为java对象， 同时还能把java对象放入到List集合。

5）关闭资源

6）实现sql语句和java代码的解耦合。

mybatis的文档： https://mybatis.org/mybatis-3/zh/index.html

第二章 MyBatis入门

2.0.1 maven中的配置文件

这里需要注意一下mysql驱动的版本

<dependencies>    
	<dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.9</version>
    </dependency>
    <!-- mysql驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.16</version>
    </dependency>
</dependencies>


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

2.1 第一个例子

实现步骤：

0.创建student表（id，name，email，age）

1.新建maven项目

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.5.9</version>
</dependency>

2.修改pom.xml

1）加入依赖 mybatis依赖， mysql驱动， junit

<dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.9</version>
</dependency>
<!-- mysql驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.16</version>
</dependency>

2）在加入资源插件

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

3.创建实体类Student。定义属性， 属性名和列名保持一致

public class Student {
    private Integer id;
    private String name;
    private String email;
    private Integer age;

    @Override
    public String toString() {
        return "StudentDao{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                ", age=" + age +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

4.创建Dao接口， 定义操作数据库的方法。

public interface StudentDao {
    List<Student> selectStudents();
}

5.创建xml文件（mapper文件）， 写sql语句。

mybatis框架推荐是把sql语句和java代码分开

mapper文件：定义和dao接口在同一目录， 一个表一个mapper文件。

<?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">
<!--
    1.约束文件
     http://mybatis.org/dtd/mybatis-3-mapper.dtd
     作用:定义和限制当前文件中可以使用的标签和属性,以及标签出现的顺序


    2.mapper:根标签

     namespace:命名空间,必须有值,且是唯一值;推荐使用Dao接口的全限定名称
     作用:参与识别sql语句
    3.在mapper里可以写<insert> <update> <delete> <select>
    -->
<mapper namespace="dao.StudentDao">
    <!--
    查询所有学生

    id:要执行的sql语句的唯一标识,是一个自定义字符串,推荐使用dao接口中的方法名称
    resultType:告诉mybatis,执行sql语句后,把数据赋值给哪个类型的Java对象
     -->
    <select id="selectStudents" resultType="bean.Student">
        select id,name,email,age from student
    </select>

</mapper>

6.创建mybatis的主配置文件（xml文件）：有一个， 放在resources目录下

该主配置文件不用过多关心，后续不用

1）定义创建连接实例的数据源（DataSource）对象

2. 指定其他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 default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <!-- 配置数据源,创建connection对象 -->
            <dataSource type="POOLED">
                <!-- 驱动内容 -->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <!-- 连接数据库的url -->
                <property name="url" value="jdbc:mysql://localhost:3306/${数据库名字}?characterEncoding=utf8&amp;
                useUnicode=true&amp;serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 指定其他mapper文件的位置 找到其他mapper文件的目的是找到其他文件的sql语句 -->
    <mappers>
        <!--
        使用mapper的resource属性指定mapper文件的路径

        用/分隔
        从类路径开始:target/classes(类路径)
         -->
        <mapper resource="dao/StudentDao.xml"/>
    </mappers>
</configuration>

7.创建测试的内容。

使用main方法，测试mybatis访问数据库

也可以使用junit 访问数据库

//1.mybatis 主配置文件
String config = "mybatis-config.xml";
//2.读取配置文件
InputStream in = Resources.getResourceAsStream(config);
//3.创建 SqlSessionFactory 对象,目的是获取 SqlSession
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
//4.【重要】获取 SqlSession,SqlSession 能执行 sql 语句
SqlSession session = factory.openSession();
//5.【重要】执行 SqlSession 的 selectList()    sql语句：映射文件中的namespace+"."+标签的id值
List<Student> studentList =
    session.selectList("dao.StudentDao.selectStudents");
//6.循环输出查询结果
studentList.forEach( student -> System.out.println(student));
//7.关闭 SqlSession，释放资源
session.close();

8.配置日志功能

在mybatis主配置文件中加入

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

2.2 概念

1.自动提交：当你的 sql语句执行完毕后， 提交事务。 数据库更新操作之间保存到数据

2.手动（手工）提交事务：在你需要提交事务的位置， 执行方法，提交事务或者回顾事务。

2.3 MyBatis的一些对象

1） Resources ： mybatis框架中的对象， 一个作用读取 主配置信息。

InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");

2）SqlSessionFactoryBuilder：负责创建SqlSessionFactory对象

SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);

3）SqlSessionFactory: 重要对象

SqlSessionFactory是重量级对象：创建此对象需要使用更多的资源和时间。 在项目中有一个就可以了。

SqlSessionFactory接口：作用是SqlSession的工厂， 就是创建SqlSession对象。

DefaultSqlSessionFactory实现类

public class DefaultSqlSessionFactory implements SqlSessionFactory { } 

SqlSessionFactory接口中的方法

openSession(): 获取一个默认的SqlSession对象， 默认是需要手工提交事务的。

openSession(boolean): boolean参数表示是否自动提交事务。

​ true： 创建一个自动提交事务的SqlSession

​ false: 等同于没有参数的openSession

4. SqlSession对象

SqlSession对象是通过SqlSessionFactory获取的。 SqlSession本身是接口

DefaultSqlSession: 实现类

public class DefaultSqlSession implements SqlSession { }

SqlSession作用是提供了大量的执行sql语句的方法：

selectOne：执行sql语句，最多得到一行记录，多余1行是错误。

selectList：执行sql语句，返回多行数据

selectMap：执行sql语句的，得到一个Map结果
insert：执行insert语句
update：执行update语句
delete：执行delete语句
commit：提交事务

rollback：回顾事务

注意SqlSession对象不是线程安全的， 使用的步骤：

①：在方法的内部，执行sql语句之前，先获取SqlSession对象

②：调用SqlSession的方法，执行sql语句

③：关闭SqlSession对象，执行SqlSession.close()

2.4 使用工具类和模版

1）创建工具类

public class MyBatisUtils { 
    //定义  SqlSessionFactory
    private static SqlSessionFactory factory = null;
    //使用 静态块 创建一次  SqlSessionFactory 
    static {
        String config = "mybatis-config.xml";
        InputStream in = null;
        try {
            in = Resources.getResourceAsStream(config);
            factory = new SqlSessionFactoryBuilder().build(in);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取session对象
     * @return session对象
     */
    public static SqlSession getSqlSession(){
        SqlSession session = null;
        if (factory != null){
            session = factory.openSession(true);
        }
        return session;
    }
}

2 ）创建模版，mapper文件模版和mybatis主配置文件模版

创建模版的步骤：

创建模版文件：

创建文件选择使用的模版：

第三章 MyBatis的Dao代理（核心）

3.1 dao代理（动态代理）

3.1.1 mybatis提供代理：

mybatis创建Dao接口的实现类对象， 完成对sql语句的执行。 mybatis创建一个对象代替你的 dao实现类功能。

3.1.2 使用mybatis代理要求

1）mapper文件中的namespace 一定dao接口的全限定名称

2）mapper文件中 标签的id是dao接口方法名称

3.1.3 mybatis代理实现方式

使用SqlSession对象的方法 getMapper(dao.class)

例如： 现在有 StudentDao接口。

SqlSession session  = MyBatisUtils.getSqlSession();
StudentDao dao  = session.getMapper(StudentDao.class);
Student student = dao.selectById(1001);


//上面代码中
StudentDao dao  = session.getMapper(StudentDao.class);
等同于

StudentDao dao  = new StudentDaoImpl();

3.2 理解参数

理解参数是： 通过java程序把数据传入到mapper文件中的sql语句。 参数主要是指dao接口方法的形参

3.2.1 parameterType（可以不写）

parameterType:表示参数的类型， 指定dao方法的形参数据类型。 这个形参的数据类型是给mybatis使用。 mybatis在给sql语句的参数赋值时使用。 PreparedStatement.setXXX( 位置， 值)

第一个用法： java类型的全限定类型名称   parameterType="java.lang.Integer"
第二个用法： mybatis定义的java类型的别名  parameterType="int"

parameterType：mybatis通过反射机制可以获取 dao接口方法参数的类型， 可以不写

<select id="selectById"  parameterType="integer"
                 resultType="com.bjpowernode.domain.Student">
   select id,name,email,age from student where id=#{studentId}
</select>

3.2.2 dao接口方法是一个简单类型的参数

//dao接口的方法形参是一个简单类型的
//简单类型： java基本数据类型和String
Student selectByEmail(String email);

<!--
   dao接口是一个简单类型的参数
   mapper文件，获取这个参数值，使用#{任意字符}
-->
<select id="selectByEmail" resultType="com.bjpowernode.domain.Student">
    select id,name,email,age from student where email=#{studentEmail}
</select>

3.2.3 dao接口方法有多个简单类型的参数

@Param: 命名参数， 在方法的形参前面使用的， 定义参数名。 这个名称可以用在mapper文件中。

dao接口，方法的定义

/*
  多个简单类型的参数
  使用@Param命名参数， 注解是mybatis提供的

  位置：在形参定义的前面

  属性：value 自定义的参数名称
 */
List<Student> selectByNameOrAge(@Param("myname") String name,
                                @Param("myage") Integer age);

mapper文件

<!--
   多个简单类型的参数.
   当使用了@Param命名后，例如@Param("myname").
   在mapper中，使用#{命名的参数}， 例如 #{myname}
-->
<select id="selectByNameOrAge" resultType="com.bjpowernode.domain.Student">
    select id,name,email,age from student where name=#{myname} or age=#{myage}
</select>

3.2.4 dao接口方法使用一个对象作为参数

方法的形参是一个java对象。这个java对象表示多个参数。使用对象的属性值作为参数使用

java对象

public class Student {
    private Integer id;
    private String name;
    private String email;
    private Integer age;
    //set|get方法
}

public class QueryParam {
    private Object p1;
    private Object p2;
    //set|get方法
}

dao接口中的方法定义

/*
 * 一个java对象作为参数( 对象由属性， 每个属性有set，get方法)
 */
List<Student> selectByObject(Student student);

List<Student> selectByQueryParam(QueryParam param);

mapper文件

<!--
   一个java对象作为方法的参数，使用对象的属性作为参数值使用

   简单的语法： #{属性名} ， mybatis调用此属性的getXXX()方法获取属性值

-->
<select id="selectByObject" resultType="com.bjpowernode.domain.Student">
    select id,name,email,age from student where name=#{name} or age=#{age}
</select>

<select id="selectByQueryParam" resultType="com.bjpowernode.domain.Student">
     select id,name,email,age from student where name=#{p1} or age=#{p2}
</select>

<!--
负责的语法格式： #{属性名,javaType=java类型的全限定名称,jdbcType=mybatis中定义列的数据类型}
过于麻烦，了解即可

-->
<select id="selectByObject" resultType="com.bjpowernode.domain.Student">
        select id,name,email,age from student where
        name=#{name,javaType=java.lang.String,jdbcType=VARCHAR}
        or
        age=#{age,javaType=java.lang.Integer,jdbcType=INTEGER}
</select>

3.2.5 dao接口中多个简单类型的参数，使用位置（了解）

参数位置： dao接口中方法的形参列表，从左往右，参数位置是 0 ， 1， 2......

语法格式：#{arg0} ,#{arg1}

dao接口的方法

/*
   使用位置，获取参数

 */
List<Student> selectByPosition(String name,Integer age);

<!--
   mybatis版本是 3.5.1
   使用位置获取参数值， dao接口方法是多个简单类型的参数
   语法： #{arg0}, #{arg1}....
-->
<select id="selectByPosition" resultType="com.bjpowernode.domain.Student">
    select id,name,email,age from student where name=#{arg0} or age=#{arg1}
</select>

3.2.6 dao接口参数是一个Map（了解）

map作为dao接口的参数， 使用 key 获取参数值，mapper文件中，语法格式 #{key}

/*
   使用Map作为参数
 */
List<Student> selectStudentByMap(Map<String,Object> map);

mapper文件

<!--
   使用Map传递参数，
   在mapper文件中，获取map的值，是通过key获取的，语法：#{key}
-->
<select id="selectStudentByMap" resultType="com.bjpowernode.domain.Student">
     select id,name,email,age from student where name=#{myname} or age=#{myage}
</select>

测试，调用方法的位置

@Test
public void testSelectByMap(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    StudentDao dao  = sqlSession.getMapper(StudentDao.class);

    //使用map传递参数
    Map<String,Object> data = new HashMap<>();
    data.put("myname", "李思思");
    data.put("myage", 20);
    List<Student> students = dao.selectStudentByMap(data);

    students.forEach( stu-> System.out.println("stu="+stu));
    sqlSession.close();

}

3.3 #和$的区别

3.3.1 # 占位符

语法： #{字符}

mybatis处理#{} 使用jdbc对象是 PrepareStatment对象

<select id="selectById"  parameterType="integer"
             resultType="com.bjpowernode.domain.Student">
    select id,name,email,age from student where id=#{studentId}
</select>

mybatis出创建PrepareStatement对象，执行sql语句
String sql=" select id,name,email,age from student where id=?";
PrepareStatement pst = conn.prepareStatement(sql);
pst.setInt(1,1001);  //传递参数

ResultSet rs  = pst.executeQuery(); //执行sql语句

{}特点：

1）使用的PrepareStatement对象，执行sql语句，效率高。

2）使用的PrepareStatement对象，能避免sql语句， sql语句执行更安全。

3） #{} 常常作为 列值使用的， 位于等号的右侧， #{}位置的值和数据类型有关的。

3.3.2 $ 占位符

语法 : ${字符}

mybatis执行${}占位符的sql语句

<select id="selectById"  parameterType="integer"
             resultType="com.bjpowernode.domain.Student">
    select id,name,email,age from student where id=${studentId}
</select>	

${} 表示字符串连接， 把sql语句的其他内容和 ${}内容使用 字符串（+） 连接的方式连在一起

String sql="select id,name,email,age from student where id=" + "1001";

mybatis创建Statement对象， 执行sql语句。

Statement stmt  = conn.createStatement(sql);
ResultSet rs  = stmt.executeQuery();

${} 的特点

1）使用Statement对象，执行sql语句，效率低

2）${}占位符的值，使用的字符串连接方式， 有sql注入的风险。 有代码安全的问题

3. ${} 数据是原样使用的， 不会区分数据类型。

4）${} 常用作 表名或者列名， 在能保证数据安全的情况下使用 ${}

总结

{}使用的PrepareStatement对象，执行sql语句，效率高

{}能避免sql注入，更安全

{}使用占位符

${}使用字符串连接的方式

${}使用Statement对象执行sql，效率较低

${}有sql注入风险，缺乏安全性

3.4 封装MyBatis输出结果

封装输出结果： MyBatis执行sql语句，得到ResultSet, 转为java对象。

讲两个 resultType, resultMap

resultType和resultMap不能一起用

3.4.1 resultType

resultType属性： 在执行select时使用， 作为标签的属性出现的。 resultType:表示结果类型 ，  mysql执行sql语句，得到java对象的类型。  它的值有两种 ​      1） java类型的全限定名称  。 2）使用别名 全限定名称 1） resultType:表示java自定义对象 Student selectById(Integer id);  <select id="selectById"  parameterType="integer"              resultType="com.bjpowernode.domain.Student">     select id,name,email,age from student where id=#{studentId} </select>  resultType:现在使用java类型的全限定名称。 表示的意思 mybatis执行sql，把ResultSet中的数据转为Student类型的对象。  mybatis会做以下操作： 1. 调用com.bjpowernode.domain.Student的无参数构造方法，创建对象。     Student student = new Student(); //使用反射创建对象 2. 同名的列赋值给同名的属性。     student.setId( rs.getInt("id"));     student.setName(rs.getString("name")); 3. 得到java对象， 如果dao接口返回值是List集合， mybatis把student对象放入到List集合。   所以执行 Student mystudent = dao.selectById(1001); 得到 数据库中 id=1001这行数据，  这行数据的列值， 付给了mystudent对象的属性。 你能得到mystudent对象。 就相当于是 id=1001这行数据。     2）resultType表示简单类型 dao方法 long countStudent();  mapper文件 <!--   执行sql语句，得到是一个值（一行一列） --> <select id="countStudent" resultType="java.lang.Long">     select count(*) from student </select>  3） resultType:表示一个map结构 //查询结果返回是一个Map Map<Object,Object> selectMap(@Param("stuid") Integer id);  <!--    执行sql得到一个Map结构数据， mybatis执行sql，把ResultSet转为map    sql执行结果， 列名做map的key ， 列值作为value    sql执行得到是一行记录，转为map结构是正确的。     dao接口返回是一个map， sql语句最多能获取一行记录，多余一行是错误  --> <select id="selectMap" resultType="java.util.HashMap">     select id,name,email from student where id != #{stuid} </select>  别名 在mybatis主配置文件中加入typeAliases标签 的name属性是包名，表示这个包中的所有类，以类名作为别名 <typeAliases>     <!-- 设置别名后，bean.Student别名为Student -->     <package name="bean" </typeAliases>  3.4.2 resultMap resultMap: 结果映射。 自定义列名和java对象属性的对应关系。 常用在列名和属性名不同的情况。 用法： 1.先定义 resultMap标签， 指定列名和属性名称对应关系 2.在select标签使用resultMap属性，指定上面定义的resultMap的id值 <!--使用resultMap定义列和属性的关系--> <!--定义resultMap     id:给resultMap的映射关系起个名称，唯一值     type:java类型的全限定名称 --> <resultMap id="customMap" type="com.bjpowernode.vo.CustomObject">      <!--定义列名和属性名的对应-->     <!--主键类型使用id标签-->     <id column="id" property="cid" />     <!--非主键类型使用result标签-->     <result column="name" property="cname" />     <!--列名和属性名相同不用定义-->     <result column="email" property="email" />     <result column="age" property="age" /> </resultMap>  <!--使用resultMap属性，指定映射关系的id     resultMap和resultType 不能同时使用， 二选一。 --> <select id="selectById2" resultMap="customMap">   select id,name,email,age from student where id=#{stuid} </select>  3.5 自定义别名 mybatis提供的对java类型定义简短，好记名称。 自定义别名的步骤： 1）在mybatis主配置文件，使用 typeAliases标签声明别名 2）在mapper文件中， resultType="别名" 声明别名（mybatis主配置文件） <typeAliases>     <!--第一种语法格式         type:java类型的全限定名称（自定义类型）         alias:自定义别名     -->     <typeAlias type="com.bjpowernode.domain.Student" alias="stu" />  </typeAliases>  mapper文件中使用 resultType="别名" <select id="selectById"  parameterType="integer" resultType="stu">     select id,name,email,age from student where id=#{studentId} </select>  3.6 列名和java对象属性名称不一样解决方式 1） 使用resultMap： 自定义列名和属性名称对应关系 2）使用resultType:  直接在sql语句中使用列别名（as），让别名和java对象属性名称一样 3.7 like 第一种方式： 在java程序中，把like的内容组装好。 把这个内容传入到sql语句 //like第一种方式 List<Student> selectLikeOne(@Param("name") String name);  mapper <!--like第一种方式--> <select id="selectLikeOne" resultType="com.bjpowernode.domain.Student">     select * from student where name like #{name} </select>  执行like @Test public void testLikeOne(){     SqlSession sqlSession = MyBatisUtil.getSqlSession();     StudentDao dao  = sqlSession.getMapper(StudentDao.class);      String name="%李%";     List<Student> students = dao.selectLikeOne(name);      sqlSession.close();      students.forEach( stu-> System.out.println(stu)); }  第二种方式： 在sql语句，组织like的内容。 sql语句like的格式：  where name like "%"空格#{name}空格"%" //like第二种方式 List<Student> selectLikeTwo(@Param("name") String name);  <!--like第二种方式--> <select id="selectLikeTwo" resultType="com.bjpowernode.domain.Student">     select * from student where name like "%" #{name} "%" </select>  @Test public void testLikeTwo(){     SqlSession sqlSession = MyBatisUtil.getSqlSession();     StudentDao dao  = sqlSession.getMapper(StudentDao.class);      String name="李";     List<Student> students = dao.selectLikeTwo(name);      sqlSession.close();      students.forEach( stu-> System.out.println(stu)); }  第四章 动态sql（核心） 什么是动态sql： 同一个dao的方法， 根据不同的条件可以表示不同的sql语句， 主要是where部分有变化 使用mybatis提供的标签，实现动态sql的能力，  主要讲 if ，where ，foreach， sql。 使用动态sql的时候， dao方法的形参使用java对象。 什么时候使用动态sql：  4.1  if 标签 语法： <if test="boolean判断结果">    sql 代码 </if>   在mapper文件中 <select id="selectStudent" resultType="com.bjpwoernode.domain.Student">       select *from student       <if test="条件">           sql语句       </if>       <if test="条件">           sql语句       </if> </select>  例子： List<Student> selectIf(Student student);  <!--if     test: 使用对象的属性值作为条件     &lt;代表小于号(<)     &gt;代表大于符号(>)     &le;表示小于或等于符号(<=)     &ge;表示大于或等于符号(>=) --> <select id="selectIf" resultType="com.bjpowernode.domain.Student">     select * from student     <!-- 加入该条件，防止语法错误报异常 -->     where id=-1     <if test="name !=null and name!=''">        or  name = #{name}     </if>      <if test="age >0">         or age &lt; #{age}     </if> </select>  4.2 where 标签 使用if标签时，容易引起sql语句语法错误。  使用where标签解决if产生的语法问题。 使用时 where ,里面是一个或多个if 标签， 当有一个if标签 判断条件为true，  where标签会转为 WHERE 关键字附加到sql语句的后面。  如果 if 没有一个条件为true ， 忽略where和里面的if。 where标签删除 和他最近的or 或者 and。 语法： <where>     <if test="条件1">sql语句1</if>     <if test="条件2">sql语句2</if> </where>  例子： //where List<Student> selectWhere(Student student);  <!--where--> <select id="selectWhere" resultType="com.bjpowernode.domain.Student">     select * from student     <where>         <if test="name !=null and name!=''">             or  name = #{name}         </if>          <if test="age >0">             or age &lt; #{age}         </if>     </where>  </select>  4.3 foreach 循环 使用foreach可以循环数组，list集合， 一般使用在in语句中。 语法： < foreach collection="集合类型" open="开始的字符" close="结束的字符"           item="集合中的成员" separator="集合成员之间的分隔符">               #{item 的值} </ foreach>  标签属性： collection： 表示，循环的对象是 数组， 还是list集合。  如果dao接口方法的形参是 数组，               collection="array" ,如果dao接口形参是List， collection="list"  open:循环开始时的字符。  sql.append("("); close：循环结束时字符。  sql.append(")"); item：集合成员， 自定义的变量。   Integer item  = idlist.get(i);// item是集合成员 separator：集合成员之间的分隔符。  sql.append(","); //集合成员之间的分隔符 #{item 的值}：获取集合成员的值。  第一种方式： //foreach-1 List<Student> selectForeachOne(List<Integer> idlist);   <!--foreach第一种方式， 循环简单类型的List--> <select id="selectForeachOne" resultType="com.bjpowernode.domain.Student">       select * from student         <if test="list !=null and list.size>0">             where id in             <foreach collection="list" open="(" close=")" separator="," item="myid">                   #{myid}             </foreach>         </if> </select>  @Test public void testSelectForeachOne(){         //1.获取SqlSession         SqlSession session = MyBatisUtil.getSqlSession();         //2.获取dao的代理         StudentDao dao = session.getMapper(StudentDao.class);           List<Integer> idlist = new ArrayList<>();         idlist.add(1001);         idlist.add(1002);         idlist.add(1003);           List<Student> students  = dao.selectForeachOne(idlist);          students.forEach( stu-> System.out.println("stu=="+stu));         //3.关闭SqlSession对象         session.close();     }   第二种方式： //foreach-2 List<Student> selectForeachTwo(List<Student> studentList);  <!--foreach第二种方式， 循环的List<Student>--> <select id="selectForeachTwo" resultType="com.bjpowernode.domain.Student">         select * from student         <if test="list != null and list.size>0">             where id in             <foreach collection="list" open="(" close=")" separator="," item="stu">                   #{stu.id}             </foreach>         </if> </select>               @Test  public void testSelectForeachTwo(){         //1.获取SqlSession         SqlSession session = MyBatisUtil.getSqlSession();         //2.获取dao的代理         StudentDao dao = session.getMapper(StudentDao.class);           List<Student> list  = new ArrayList<>();         Student s1 = new Student();         s1.setId(1001);          Student s2 = new Student();         s2.setId(1002);          list.add(s1);         list.add(s2);           List<Student> students  = dao.selectForeachTwo(list);          students.forEach( stu-> System.out.println("stu=="+stu));         //3.关闭SqlSession对象         session.close();     }               4.4 sql标签 sql标签标示 一段sql代码， 可以是表名，几个字段， where条件都可以， 可以在其他地方复用sql标签的内容。 使用方式： 1) 在mapper文件中定义 sql代码片段 <sql id="唯一字符串">  部分sql语句  </sql> 2）在其他的位置，使用include标签引用某个代码片段  例如： <!--定义代码片段--> <sql id="selectStudent">     select * from student </sql>  <sql id="studentFieldList">     id,name,email </sql>  <select id="selectIf" resultType="com.bjpowernode.domain.Student">          <include refid="selectStudent" />          where id=-1         <if test="name !=null and name!=''">            or  name = #{name}         </if>          <if test="age >0">             or age &lt; #{age}         </if>     </select>      <!--where-->     <select id="selectWhere" resultType="com.bjpowernode.domain.Student">         select <include refid="studentFieldList"/> from student         <where>             <if test="name !=null and name!=''">                 or  name = #{name}             </if>              <if test="age >0">                 or age &lt; #{age}             </if>         </where>      </select>   第五章 MyBatis配置文件 mybatis配置文件两大类： 1 mybatis主配置文件； 2 mybatis的mapper文件  mybatis主配置文件，提供mybatis全局设置的。包含的内容 日志， 数据源，mapper文件位置 mapper文件： 写sql语句的。 一个表一个mapper文件  5.1 settings部分 settings是mybatis的全局设置，影响整个mybatis的运行。 这个设置一般使用默认值就可以了。 <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>  5.2 typeAliase 别名 设置别名 <typeAliases>         <!--第一种语法格式             type:java类型的全限定名称（自定义类型）             alias:自定义别名              优点： 别名可以自定义             缺点： 每个类型必须单独定义         -->         <typeAlias type="com.bjpowernode.domain.Student" alias="stu" />         <typeAlias type="com.bjpowernode.vo.QueryParam" alias="qp" />          <!--第二种方式             name:包名， mybatis会把这个包中所有类名作为别名（不用区分大小写）             优点：使用方便，一次给多个类定义别名             缺点: 别名不能自定义，必须是类名。         -->         <package name="com.bjpowernode.domain" />         <package name="com.bjpowernode.vo" />      </typeAliases>  5.3 配置环境 environments: 环境标签， 在他里面可以配置多个environment        属性： default ，必须是某个environment的id属性值。 表示mybatis默认连接的数据库 environment： 表示一个数据库的连接信息。        属性： id 自定义的环境的标识。 唯一值。 transactionManager：事务管理器        属性：  type 表示事务管理器的类型。        属性值：1）JDBC: 使用Connection对象， 由mybatis自己完成事务的处理。              2） MANAGED: 管理，表示把事务的处理交给容器实现（由其他软件完成事务的提交，回滚） dataSource： 数据源，创建的Connection对象，连接数据库。        属性：  type 数据源的类型        属性值：1） POOLED， mybatis会在内存中创建PooledDataSource类，管理多个Connection连接对象，使                           用的连接池              2） UNPOOLED ，不使用连接池， mybatis创建一个UnPooledDataSource这个类， 每次执行sql                           语句先创建Connection对象，再执行sql语句，最后关闭Connection              3) JNDI : java的命名和目录服务。  <environments default="online">         <environment id="development">             <transactionManager type="JDBC"/>             <!--配置数据源： 创建Connection对象。-->             <dataSource type="POOLED">                 <!--driver:驱动的内容-->                 <property name="driver" value="com.mysql.jdbc.Driver"/>                 <!--连接数据库的url-->                 <property name="url"                           value="jdbc:mysql://localhost:3306/springdb"/>                 <!--用户名-->                 <property name="username" value="root"/>                 <!--密码-->                 <property name="password" value="123"/>             </dataSource>         </environment>         <!-- 项目上线后使用的数据库 -->         <environment id="online">             <transactionManager type="JDBC"/>             <!--配置数据源： 创建Connection对象。-->             <dataSource type="POOLED">                 <!--driver:驱动的内容-->                 <property name="driver" value="com.mysql.jdbc.Driver"/>                 <!--连接数据库的url-->                 <property name="url"                           value="jdbc:mysql://localhost:3306/springdb"/>                 <!--用户名-->                 <property name="username" value="admin"/>                 <!--密码-->                 <property name="password" value="123456"/>             </dataSource>         </environment>     </environments>  5.4 使用数据库属性配置文件（掌握） 需要把数据库的配置信息放到一个单独文件中， 独立管理。 这个文件扩展名是 properties. 在这个文件中，使用自定义的key=value的格式表示数据 使用步骤： 1.在resources目录中，创建xxxx.properties 2.在文件中，使用 key=value的格式定义数据。 例如 jdbc.url=jdbc:mysq://localhost:3306/springdb 3.在mybatis主配置文件， 使用properties标签引用外部的属性配置文件 4.在使用值的位置， 使用${key}获取key对应的value（等号右侧的值） 例子： jdbc.properties jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/springdb?useUnicode=true&amp;characterEncoding=utf-8 jdbc.username=root jdbc.password=123  mybatis主配置文件 <!--使用外部属性配置文件     resource:指定类路径下的某个属性配置文件 --> <properties resource="jdbc.properties" />  <environments default="development">         <environment id="development">             <transactionManager type="JDBC"/>             <!--配置数据源： 创建Connection对象。-->             <dataSource type="POOLED">                 <!--driver:驱动的内容-->                 <property name="driver" value="${jdbc.driver}"/>                 <!--连接数据库的url-->                 <property name="url" value="${jdbc.url}"/>                 <!--用户名-->                 <property name="username" value="${jdbc.username}"/>                 <!--密码-->                 <property name="password" value="${jdbc.password}"/>             </dataSource>          </environment> </environments>  5.5 mapper 标签(*) 使用mapper指定其他mapper文件的位置， mapper标签使用的格式有两个常用的方式： <mappers>     <!--第一种方式， resources="mapper文件的路径"         优点：文件清晰。 加载的文件是明确的。               文件的位置比较灵活。         缺点：文件比较多， 代码量会比较大， 管理难度大     -->     <mapper resource="com/bjpowernode/dao/StudentDao.xml"/>     <mapper resource="com/bjpowernode/dao/OrderDao.xml"/>     <!--        第二种方式，使用<package>        name:包名， mapper文件所在的包名。        特点： 把这个包中的所有mapper文件，一次加载。         使用要求：         1. mapper文件和dao接口在同一目录         2. mapper文件和dao接口名称完全一样。     -->     <package name="com.bjpowernode.dao" />     <package name="com.bjpowernode.dao1" /> </mappers>  第六章 PageHelper PageHelper做数据分页。 在你的select语句后面加入 分页的 sql 内容， 如果你使用的mysql数据库， 它就是在select * from student 后面加入 limit 语句。 使用步骤： 1.加入依赖pagehelper依赖 <dependency> <groupId>com.github.pagehelper</groupId> <artifactId>pagehelper</artifactId> <version>5.1.10</version> </dependency>  2.在mybatis主配置文件， 加入plugin声明 在<environments> 之前加入 <plugins>    <plugin interceptor ="com.github.pagehelper.PageInterceptor" /> </plugins>      3.在select语句之前，调用PageHelper.startPage(页码， 每页大小) 对比： 没有使用PageHelper select * from student order by id 使用PageHelper SELECT count(0) FROM student select * from student order by id LIMIT ? 



出处：https://www.cnblogs.com/liziying/p/15807268.html