Mybatis简介

MyBatis历史

• MyBatis最初是Apache的一个开源项目iBatis, 2010年6月这个项目由Apache Software Foundation迁移到了Google Code。随着开发团队转投Google Code旗下，iBatis3.x正式更名为MyBatis。代码于2013年11月迁移到Github
• iBatis一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBatis提供的持久层框架包括SQL Maps和Data Access Objects（DAO）

MyBatis特性

1. MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架
2. MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集
3. MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录，当操作数据库内容时就像操作实体类对象一样简单。
4. MyBatis 是一个 半自动的ORM（Object Relation Mapping）框架

MyBatis下载

• MyBatis下载地址

和其它持久化层技术对比

• JDBC
  • SQL 夹杂在Java代码中耦合度高，导致硬编码内伤
  • 维护不易且实际开发需求中 SQL 有变化，频繁修改的情况多见
  • 代码冗长，开发效率低
• Hibernate 和 JPA
  • 操作简便，开发效率高
  • 程序中的长难复杂 SQL 需要绕过框架
  • 内部自动生产的 SQL，不容易做特殊优化
  • 基于全映射的全自动框架，大量字段的 POJO 进行部分映射时比较困难。
  • 反射操作太多，导致数据库性能下降
• MyBatis
  • 轻量级，性能出色
  • SQL 和 Java 编码分开，功能边界清晰。Java代码专注业务、SQL语句专注数据
  • 开发效率稍逊于HIbernate，但是完全能够接受

搭建MyBatis

开发环境

• IDE：idea 2019.2
• 构建工具：maven 3.5.4
• MySQL版本：MySQL 5.7
• MyBatis版本：MyBatis 3.5.7

创建maven工程

• 打包方式：jar
• 引入依赖

  org.mybatismybatis3.5.7junitjunit4.12testmysqlmysql-connector-java5.1.3
  
  

创建MyBatis的核心配置文件

习惯上命名为mybatis-config.xml，这个文件名仅仅只是建议，并非强制要求。将来整合Spring之后，这个配置文件可以省略，所以大家操作时可以直接复制、粘贴。
核心配置文件主要用于配置连接数据库的环境以及MyBatis的全局配置信息
核心配置文件存放的位置是src/main/resources目录下

创建mapper接口

MyBatis中的mapper接口相当于以前的dao。但是区别在于，mapper仅仅是接口，我们不需要提供实现类

package com.atguigu.mybatis.mapper;  public interface UserMapper {  /**  * 添加用户信息  */  int insertUser();  
}

创建MyBatis的映射文件

• 相关概念：ORM（Object Relationship Mapping）对象关系映射。
  • 对象：Java的实体类对象
  • 关系：关系型数据库
  • 映射：二者之间的对应关系

• 映射文件的命名规则
  • 表所对应的实体类的类名+Mapper.xml
  • 例如：表t_user，映射的实体类为User，所对应的映射文件为UserMapper.xml
  • 因此一个映射文件对应一个实体类，对应一张表的操作
  • MyBatis映射文件用于编写SQL，访问以及操作表中的数据
  • MyBatis映射文件存放的位置是src/main/resources/mappers目录下
• MyBatis中可以面向接口操作数据，要保证两个一致
  • mapper接口的全类名和映射文件的命名空间（namespace）保持一致
  • mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致

  
  
      insert into t_user values(null,'张三','123',23,'女')    

关系

一个表对应一个实体类，一个实体类对应一个mapper接口，一个mapper接口对应一个映射文件

通过junit测试功能

• SqlSession：代表Java程序和数据库之间的会话。（HttpSession是Java程序和浏览器之间的会话）
• SqlSessionFactory：是“生产”SqlSession的“工厂”
• 工厂模式：如果创建某一个对象，使用的过程基本固定，那么我们就可以把创建这个对象的相关代码封装到一个“工厂类”中，以后都使用这个工厂类来“生产”我们需要的对象

public class UserMapperTest {@Testpublic void testInsertUser() throws IOException {//读取MyBatis的核心配置文件InputStream is = Resources.getResourceAsStream("mybatis-config.xml");//获取SqlSessionFactoryBuilder对象SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();//通过核心配置文件所对应的字节输入流创建工厂类SqlSessionFactory，生产SqlSession对象SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);//获取sqlSession，此时通过SqlSession对象所操作的sql都必须手动提交或回滚事务//SqlSession sqlSession = sqlSessionFactory.openSession();//创建SqlSession对象，此时通过SqlSession对象所操作的sql都会自动提交  SqlSession sqlSession = sqlSessionFactory.openSession(true);//通过代理模式创建UserMapper接口的代理实现类对象UserMapper userMapper = sqlSession.getMapper(UserMapper.class);//调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配元素文件，通过调用的方法名匹配映射文件中的SQL标签，并执行标签中的SQL语句int result = userMapper.insertUser();//提交事务//sqlSession.commit();System.out.println("result:" + result);}
}

• 此时需要手动提交事务，如果要自动提交事务，则在获取sqlSession对象时，使用SqlSession sqlSession = sqlSessionFactory.openSession(true);，传入一个Boolean类型的参数，值为true，这样就可以自动提交

加入log4j日志功能

1. 加入依赖

   
   
   log4j
   log4j
   1.2.17
   
   

2. 加入log4j的配置文件
   • log4j的配置文件名为log4j.xml，存放的位置是src/main/resources目录下
   • 日志的级别：FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试) 从左到右打印的内容越来越详细

核心配置文件详解

核心配置文件中的标签必须按照固定的顺序(有的标签可以不写，但顺序一定不能乱)：
properties、settings、typeAliases、typeHandlers、objectFactory、objectWrapperFactory、reflectorFactory、plugins、environments、databaseIdProvider、mappers

引入映射文件

注意：在resources中创建多级目录时应该时以/分割

默认的类型别名

MyBatis的增删改查

1. 添加

   
   insert into t_user values(null,'admin','123456',23,'男','12345@qq.com')
   
   

2. 删除

   
   delete from t_user where id = 6
   
   

3. 修改

   
   update t_user set username = '张三' where id = 5
   
   

4. 查询一个实体类对象

     
     select * from t_user where id = 2  
   
   

5. 查询集合

   
   select * from t_user
   
   

查询的标签select必须设置属性resultType或resultMap

注意：

1. 查询的标签select必须设置属性resultType或resultMap，用于设置实体类和数据库表的映射关系
   • resultType：返回值类型，自动映射，用于属性名和表中字段名一致的情况
   • resultMap：自定义映射，用于一对多或多对一或字段名和属性名不一致的情况
2. 当查询的数据为多条时，不能使用实体类作为返回值，只能使用集合，否则会抛出异常TooManyResultsException；但是若查询的数据只有一条，可以使用实体类或集合作为返回值

MyBatis获取参数值的两种方式（重点）

• MyBatis获取参数值的两种方式：${}和#{} ；
• ${}的本质就是字符串拼接，#{}的本质就是占位符赋值 ，实际开发中能用#{}就用#{}，对于一些特殊的sql语句，则必须使用${}
• ${}使用字符串拼接的方式拼接sql，若为字符串类型或日期类型的字段进行赋值时，需要手动加单引号；但是#{}使用占位符赋值的方式拼接sql，此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号。

单个字面量类型的参数

• 若mapper接口中的方法参数为单个的字面量类型，此时可以使用${}和#{}以任意的名称（最好见名识意）获取参数的值，注意${}需要手动加单引号

select * from t_user where username = #{username}

  select * from t_user where username = '${username}'  

多个字面量类型的参数

• 若mapper接口中的方法参数为多个时，此时MyBatis会自动将这些参数放在一个map集合中
  1. 以arg0,arg1…为键，以参数为值；
  2. 以param1,param2…为键，以参数为值；
• 因此只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号。
• 使用arg或者param都行，要注意的是，arg是从arg0开始的，param是从param1开始的
• 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_userwhere id in (#{arg0}, #{param2})

map集合类型的参数

• 若mapper接口中的方法需要的参数为多个时，此时可以手动创建map集合，将这些数据放在map中只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号

select * from t_user where username = #{username} and password = #{password}

@Test
public void checkLoginByMap() {SqlSession sqlSession = SqlSessionUtils.getSqlSession();ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);Map map = new HashMap<>();map.put("usermane","admin");map.put("password","123456");User user = mapper.checkLoginByMap(map);System.out.println(user);
}

实体类类型的参数(使用最多)

• 若mapper接口中的方法参数为实体类对象时此时可以使用${}和#{}，通过访问实体类对象中的属性名获取属性值，注意${}需要手动加单引号

insert into t_user values(null,#{username},#{password},#{age},#{sex},#{email})

@Test
public void insertUser() {SqlSession sqlSession = SqlSessionUtils.getSqlSession();ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);User user = new User(null,"Tom","123456",12,"男","123@321.com");mapper.insertUser(user);
}

使用@Param标识参数(建议使用)

• 可以通过@Param注解标识mapper接口中的方法参数，此时，会将这些参数放在map集合中，可以使用以下两种方式来获取对应的值：
  1. 以@Param注解的value属性值为键，以参数为值；
  2. 以param1,param2…为键，以参数为值；
• 只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号

select * from t_user where username = #{username} and password = #{password}// select * from t_user where username = #{param1} and password = #{param2}// select * from t_user where username = #{param1} and password = #{password}

@Test
public void checkLoginByParam() {SqlSession sqlSession = SqlSessionUtils.getSqlSession();ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);mapper.CheckLoginByParam("admin","123456");
}

总结

• 建议分成两种情况进行处理
  1. 实体类类型的参数
  2. 使用@Param标识参数

MyBatis的各种查询功能

1. 如果查询出的数据只有一条，可以通过
   1. 实体类对象接收
   2. List集合接收
   3. Map集合接收，结果{password=123456, sex=男, id=1, age=23, username=admin}
2. 如果查询出的数据有多条，一定不能用实体类对象接收，会抛异常TooManyResultsException，可以通过
   1. 实体类类型的LIst集合接收
   2. Map类型的LIst集合接收
   3. 在mapper接口的方法上添加@MapKey注解
3. 如果查询得到的结果没有对应的实体类，那么就使用Map集合接收。

查询一个实体类对象

/*** 根据用户id查询用户信息* @param id* @return*/
User getUserById(@Param("id") int id);

select * from t_user where id = #{id}

查询一个List集合

/*** 查询所有用户信息* @return*/
List getUserList();

select * from t_user

查询单个数据

/**  * 查询用户的总记录数  * @return  * 在MyBatis中，对于Java中常用的类型都设置了类型别名  * 例如：java.lang.Integer-->int|integer  * 例如：int-->_int|_integer  * 例如：Map-->map,List-->list  */  
int getCount();

select count(id) from t_user

查询一条数据为map集合

/**  * 根据用户id查询用户信息为map集合  * @param id  * @return  */  
Map getUserToMap(@Param("id") int id);

select * from t_user where id = #{id}

查询多条数据为map集合

方法一

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

  
  select * from t_user  

方法二

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

select * from t_user

特殊SQL的执行

模糊查询

/*** 根据用户名进行模糊查询* @param username * @return java.util.List* @date 2022/2/26 21:56*/
List getUserByLike(@Param("username") String username);

    select * from t_user where username like "%"#{mohu}"%"

• 其中select * from t_user where username like "%"#{mohu}"%"是最常用的

批量删除(只能使用${})

• 只能使用${}，如果使用#{}，会自动添加单引号，所以解析后的sql语句为delete from t_user where id in ('1,2,3')，这样是将1,2,3看做是一个整体，只有id为1,2,3的数据会被删除。正确的语句应该是delete from t_user where id in (1,2,3)，或者delete from t_user where id in ('1','2','3')

/*** 根据id批量删除* @param ids * @return int* @date 2022/2/26 22:06*/
int deleteMore(@Param("ids") String ids);

delete from t_user where id in (${ids})

//测试类
@Test
public void deleteMore() {SqlSession sqlSession = SqlSessionUtils.getSqlSession();SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);int result = mapper.deleteMore("1,2,3,8");System.out.println(result);
}

动态设置表名(只能使用${})

• 只能使用${}，因为表名不能加单引号

/*** 查询指定表中的数据* @param tableName * @return java.util.List* @date 2022/2/27 14:41*/
List getUserByTable(@Param("tableName") String tableName);

select * from ${tableName}

添加功能获取自增的主键

• 使用场景
  • t_clazz(clazz_id,clazz_name)
  • t_student(student_id,student_name,clazz_id)
  1. 添加班级信息
  2. 获取新添加的班级的id
  3. 为班级分配学生，即将某学的班级id修改为新添加的班级的id
• 在mapper.xml中设置两个属性
  • useGeneratedKeys：设置使用自增的主键
  • keyProperty：因为增删改有统一的返回值是受影响的行数，因此只能将获取的自增的主键放在传输的参数user对象的某个属性中

/*** 添加用户信息* @param user * @date 2022/2/27 15:04*/
void insertUser(User user);

insert into t_user values (null,#{username},#{password},#{age},#{sex},#{email})

//测试类
@Test
public void insertUser() {SqlSession sqlSession = SqlSessionUtils.getSqlSession();SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);User user = new User(null, "ton", "123", 23, "男", "123@321.com");mapper.insertUser(user);System.out.println(user);//输出：user{id=10, username='ton', password='123', age=23, sex='男', email='123@321.com'}，自增主键存放到了user的id属性中
}

自定义映射resultMap(查询时使用)

resultMap用来处理字段名和属性名不一致、一对多和多对一的映射关系。

resultMap处理字段和属性的映射关系

• resultMap：设置自定义映射，字段名和属性名不一致时使用。
  • 属性：
    • id：表示自定义映射的唯一标识，不能重复
    • type：查询的数据要映射的实体类的类型
  • 子标签：
    • id：设置主键的映射关系
    • result：设置普通字段的映射关系
    • 子标签属性：
      • property：设置映射关系中实体类中的属性名
      • column：设置映射关系中表中的字段名
• 若字段名和实体类中的属性名不一致，则可以通过resultMap设置自定义映射，即使字段名和属性名一致的属性也要映射，也就是全部属性都要列出来

select * from t_emp

• 若字段名和实体类中的属性名不一致，但是字段名符合数据库的规则（使用_），实体类中的属性名符合Java的规则（使用驼峰）。此时也可通过以下两种方式处理字段名和实体类中的属性的映射关系

  1. 可以通过为字段起别名的方式，保证和实体类中的属性名保持一致

     
     select eid,emp_name empName,age,sex,email from t_emp
     
     

  2. 可以在MyBatis的核心配置文件中的setting标签中，设置一个全局配置信息mapUnderscoreToCamelCase，可以在查询表中数据时，自动将_类型的字段名转换为驼峰，例如：字段名user_name，设置了mapUnderscoreToCamelCase，此时字段名就会转换为userName。这种方式的前提必须时字段名符合数据库的规则（使用_），实体类中的属性名符合Java的规则（使用驼峰）。
     核心配置文件详解

多对一映射处理

查询员工信息以及员工所对应的部门信息

public class Emp {  private Integer eid;  private String empName;  private Integer age;  private String sex;  private String email;  private Dept dept;//...构造器、get、set方法等
}

方式1： 级联方式处理映射关系

select * from t_emp left join t_dept on t_emp.eid = t_dept.did where t_emp.eid = #{eid}

方式2：使用association处理映射关系

• association：处理多对一的映射关系
• property：需要处理多对的映射关系的属性名
• javaType：该属性的类型

select * from t_emp left join t_dept on t_emp.eid = t_dept.did where t_emp.eid = #{eid}

方式3：分步查询(可以延迟加载)

1. 查询员工信息

• select：设置分布查询的sql的唯一标识（namespace.SQLId或mapper接口的全类名.方法名）
• column：设置分步查询的条件

//EmpMapper里的方法
/*** 通过分步查询，员工及所对应的部门信息* 分步查询第一步：查询员工信息* @param  * @return com.atguigu.mybatis.pojo.Emp* @date 2022/2/27 20:17*/
Emp getEmpAndDeptByStepOne(@Param("eid") Integer eid);

select * from t_emp where eid = #{eid}

2. 查询部门信息

//DeptMapper里的方法
/*** 通过分步查询，员工及所对应的部门信息* 分步查询第二步：通过did查询员工对应的部门信息* @param* @return com.atguigu.mybatis.pojo.Emp* @date 2022/2/27 20:23*/
Dept getEmpAndDeptByStepTwo(@Param("did") Integer did);

select * from t_dept where did = #{did}

一对多映射处理

// 在部门表中添加List集合用来存放员工信息
public class Dept {private Integer did;private String deptName;private List emps;//...构造器、get、set方法等
}

方式1： collection

• collection：用来处理一对多的映射关系
• ofType：表示该属性对应的集合中存储的数据的类型

 // 设置主键


select * from t_dept left join t_emp on t_dept.did = t_emp.did where t_dept.did = #{did}

方式2：分步查询

1. 查询部门信息

/*** 通过分步查询，查询部门及对应的所有员工信息* 分步查询第一步：查询部门信息* @param did * @return com.atguigu.mybatis.pojo.Dept* @date 2022/2/27 22:04*/
Dept getDeptAndEmpByStepOne(@Param("did") Integer did);

- select：设置分布查询的sql的唯一标识（namespace.SQLId或mapper接口的全类名.方法名）
- column：设置分步查询的条件



select * from t_dept where did = #{did}

2. 根据部门id查询部门中的所有员工

/*** 通过分步查询，查询部门及对应的所有员工信息* 分步查询第二步：根据部门id查询部门中的所有员工* @param did* @return java.util.List* @date 2022/2/27 22:10*/
List getDeptAndEmpByStepTwo(@Param("did") Integer did);

select * from t_emp where did = #{did}

延迟加载

• 分步查询的优点：可以实现延迟加载，但是必须在核心配置文件中设置全局配置信息：
  • lazyLoadingEnabled：延迟加载的全局开关。当开启时，所有关联对象都会延迟加载
  • aggressiveLazyLoading：当开启时，任何方法的调用都会加载该对象的所有属性。 否则，每个属性会按需加载
• 此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sql。
• 因为开启全局延迟加载后，所有的分步查询都会延迟，如果想要单独设置，可通过association和collection中的fetchType属性设置当前的分步查询是否使用延迟加载，fetchType=“lazy(延迟加载)|eager(立即加载)”

@Test
public void getEmpAndDeptByStepOne() {SqlSession sqlSession = SqlSessionUtils.getSqlSession();EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);Emp emp = mapper.getEmpAndDeptByStepOne(1);System.out.println(emp.getEmpName());
}

• 关闭延迟加载，两条SQL语句都运行了
  
• 开启延迟加载，只运行获取emp的SQL语句
  

@Test
public void getEmpAndDeptByStepOne() {SqlSession sqlSession = SqlSessionUtils.getSqlSession();EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);Emp emp = mapper.getEmpAndDeptByStepOne(1);System.out.println(emp.getEmpName());System.out.println("----------------");System.out.println(emp.getDept());
}

• 开启后，需要用到查询dept的时候才会调用相应的SQL语句
  
• fetchType：当开启了全局的延迟加载之后，可以通过该属性手动控制延迟加载的效果，fetchType=“lazy(延迟加载)|eager(立即加载)”

动态SQL

• Mybatis框架的动态SQL技术是一种根据特定条件动态拼装SQL语句的功能，它存在的意义是为了解决拼接SQL语句字符串时的痛点问题

if

• if标签可通过test属性（即传递过来的数据）的表达式进行判断，若表达式的结果为true，则标签中的内容会执行；反之标签中的内容不会执行
• 在where后面添加一个恒成立条件1=1
  • 这个恒成立条件并不会影响查询的结果
  • 这个1=1可以用来拼接and语句，例如：当empName为null时
    • 如果不加上恒成立条件，则SQL语句为select * from t_emp where and age = ? and sex = ? and email = ?，此时where会与and连用，SQL语句会报错
    • 如果加上一个恒成立条件，则SQL语句为select * from t_emp where 1= 1 and age = ? and sex = ? and email = ?，此时不报错

select * from t_emp where 1=1and emp_name = #{empName}and age = #{age}and sex = #{sex}and email = #{email}

where

• where和if一般结合使用：
  • 若where标签中的if条件都不满足，则where标签没有任何功能，即不会添加where关键字
  • 若where标签中的if条件满足，则where标签会自动添加where关键字，并将条件最前方多余的and/or去掉

select * from t_empemp_name = #{empName}and age = #{age}and sex = #{sex}and email = #{email}

• 注意：where标签不能去掉条件后多余的and/or

  
  
  emp_name = #{empName} and
  
  age = #{age}
  
  

trim

• trim用于去掉或添加标签中的内容
• 常用属性
  • prefix：在trim标签中的内容的前面添加某些内容
  • suffix：在trim标签中的内容的后面添加某些内容
  • prefixOverrides：把trim标签中的内容的前面去掉某些内容
  • suffixOverrides：把trim标签中的内容的后面去掉某些内容
• 若trim中的标签都不满足条件，则trim标签没有任何效果，也就是只剩下select * from t_emp

select * from t_empemp_name = #{empName} andage = #{age} andsex = #{sex} oremail = #{email}

//测试类
@Test
public void getEmpByCondition() {SqlSession sqlSession = SqlSessionUtils.getSqlSession();DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);List emps= mapper.getEmpByCondition(new Emp(null, "张三", null, null, null, null));System.out.println(emps);
}

choose、when、otherwise

• choose、when、otherwise相当于if...else if..else
• when至少要有一个，otherwise至多只有一个

select * from t_empemp_name = #{empName}age = #{age}sex = #{sex}email = #{email}did = 1

@Test
public void getEmpByChoose() {SqlSession sqlSession = SqlSessionUtils.getSqlSession();DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);List emps = mapper.getEmpByChoose(new Emp(null, "张三", 23, "男", "123@qq.com", null));System.out.println(emps);
}

• 相当于if a else if b else if c else d，只会执行其中一个

foreach

用来处理参数是集合的情况

• 属性：

  • collection：设置要循环的数组或集合
  • item：表示集合或数组中的每一个数据
  • separator：设置循环体之间的分隔符，分隔符前后默认有一个空格，如,
  • open：设置foreach标签中的内容的开始符
  • close：设置foreach标签中的内容的结束符

• 批量删除

  方式1：
  为了能在映射文件中通过eids访问参数eids，在mapper接口方法中应该使用@Param标识参数
  
  delete from t_emp where eid in#{eid}
  
  

  方式2：delete from t_user whereid = #{id}
  

  	@Testpublic void deleteMoreByArray() {SqlSession sqlSession = SqlSessionUtils.getSqlSession();DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);int result = mapper.deleteMoreByArray(new Integer[]{6, 7, 8, 9});System.out.println(result);}
  

• 批量添加

  
  insert into t_emp values(null,#{emp.empName},#{emp.age},#{emp.sex},#{emp.email},null)
  
  

  @Test
  public void insertMoreByList() {SqlSession sqlSession = SqlSessionUtils.getSqlSession();DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);Emp emp1 = new Emp(null,"a",1,"男","123@321.com",null);Emp emp2 = new Emp(null,"b",1,"男","123@321.com",null);Emp emp3 = new Emp(null,"c",1,"男","123@321.com",null);List emps = Arrays.asList(emp1, emp2, emp3);int result = mapper.insertMoreByList(emps);System.out.println(result);
  }
  

SQL片段

• sql片段，可以记录一段公共sql片段，在使用的地方通过include标签进行引入
• 声明sql片段：标签

eid,emp_name,age,sex,email

• 引用sql片段：标签

select  from t_emp

MyBatis的缓存(只对查询功能有效)

MyBatis的一级缓存

• 一级缓存是SqlSession级别的，通过同一个SqlSession查询的数据会被缓存，下次查询相同的数据，就会从缓存中直接获取，不会从数据库重新访问。
• 一级缓存默认自动开启。
• 使一级缓存失效的四种情况：
  1. 不同的SqlSession对应不同的一级缓存
  2. 同一个SqlSession但是查询条件不同
  3. 同一个SqlSession两次查询期间执行了任何一次增删改操作
  4. 同一个SqlSession两次查询期间手动清空了缓存 sqlSession.clearCache();

MyBatis的二级缓存

• 二级缓存是SqlSessionFactory级别，通过同一个SqlSessionFactory创建的SqlSession查询的结果会被缓存；此后若再次执行相同的查询语句，结果就会从缓存中获取 。
• 二级缓存的范围大于一级缓存，而且二级缓存需要手动开启。
• 二级缓存开启的条件
  1. 在核心配置文件mybatis-config中，设置全局配置属性cacheEnabled=“true”，默认为true，不需要设置
  2. 在映射文件中设置标签
  3. 二级缓存必须在SqlSession关闭或提交之后有效
  4. 查询的数据所转换的实体类类型必须实现序列化的接口
• 使二级缓存失效的情况：两次查询之间执行了任意的增删改，会使一级和二级缓存同时失效
  
  

二级缓存的相关配置

• 在mapper配置文件中添加的cache标签可以设置一些属性
• eviction属性：缓存回收策略
  • LRU（Least Recently Used） – 最近最少使用的：移除最长时间不被使用的对象。
  • FIFO（First in First out） – 先进先出：按对象进入缓存的顺序来移除它们。
  • SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。
  • WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。
  • 默认的是 LRU
• flushInterval属性：刷新间隔，单位毫秒
  • 默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句（增删改）时刷新
• size属性：引用数目，正整数
  • 代表缓存最多可以存储多少个对象，太大容易导致内存溢出
• readOnly属性：只读，true/false
  • true：只读缓存；会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。
  • false：读写缓存；会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是false

MyBatis缓存查询的顺序

• 先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用
• 如果二级缓存没有命中，再查询一级缓存
• 如果一级缓存也没有命中，则查询数据库
• SqlSession关闭之后，一级缓存中的数据会写入二级缓存

整合第三方缓存EHCache（了解）

注意：第三方缓存只能代替MyBatis中的二级缓存，不能代替MyBatis中的一级缓存。

添加依赖

org.mybatis.cachesmybatis-ehcache1.2.1


ch.qos.logbacklogback-classic1.2.3

各个jar包的功能

创建EHCache的配置文件ehcache.xml

• 名字必须叫ehcache.xml，放在resources目录下。

设置二级缓存的类型

• 在xxxMapper.xml文件中设置二级缓存类型

加入logback日志

• 存在SLF4J时，作为简易日志的log4j将失效，此时我们需要借助SLF4J的具体实现logback来打印日志。创建logback的配置文件logback.xml，名字固定，不可改变

[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger] [%msg]%n

EHCache配置文件说明

MyBatis的逆向工程

• 正向工程：先创建Java实体类，由框架负责根据实体类生成数据库表。Hibernate是支持正向工程的
• 逆向工程：先创建数据库表，由框架负责根据数据库表，反向生成如下资源：
  • Java实体类
  • Mapper接口
  • Mapper映射文件

创建逆向工程的步骤

添加依赖和插件

org.mybatismybatis3.5.9junitjunit4.13.2testmysqlmysql-connector-java8.0.27log4jlog4j1.2.17


org.mybatis.generatormybatis-generator-maven-plugin1.3.0org.mybatis.generatormybatis-generator-core1.3.2com.mchangec3p00.9.2mysqlmysql-connector-java8.0.27

创建MyBatis的核心配置文件

创建逆向工程的配置文件

• 文件名必须是：generatorConfig.xml

执行MBG插件的generate目标
 
 
 
如果出现报错：Exception getting JDBC Driver，可能是pom.xml中，数据库驱动配置错误
 
 
dependency中的驱动
 
 
 
mybatis-generator-maven-plugin插件中的驱动
 
 
 
两者的驱动版本应该相同
 
 
 
执行结果(需要引入log4j.xml)
 
 
在MyBatis-config.xml中配置映射文件
QBC(根据条件来查询)
查询
后缀为Example的方法表示根据条件进行查询，可以传入null，表示没有条件。
selectByExample：按条件查询，需要传入一个example对象或者null；如果传入一个null，则表示没有条件，也就是查询所有数据
example.createCriteria().xxx：创建条件对象，通过andXXX方法为SQL添加查询添加，每个条件之间是and关系，对于多个查询条件可以使用链式结构example.createCriteria().andCommissionPctIsNotNull().andDepartmentIdIsNull();
example.or().xxx：将之前添加的条件通过or拼接其他条件
 
 
@Test public void testMBG() throws IOException {InputStream is = Resources.getResourceAsStream("mybatis-config.xml");SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);SqlSession sqlSession = sqlSessionFactory.openSession(true);EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);EmpExample example = new EmpExample();//名字为张三，且年龄大于等于20example.createCriteria().andEmpNameEqualTo("张三").andAgeGreaterThanOrEqualTo(20);//或者did不为空example.or().andDidIsNotNull();List emps = mapper.selectByExample(example);emps.forEach(System.out::println);
}
增改
 
updateByPrimaryKey：通过主键进行数据修改，如果某一个值为null，也会将对应的字段改为null
 
mapper.updateByPrimaryKey(new Emp(1,"admin",22,null,"456@qq.com",3));
 
 
updateByPrimaryKeySelective()：通过主键进行选择性数据修改，如果某个值为null，则不修改这个字段
 
mapper.updateByPrimaryKeySelective(new Emp(2,"admin2",22,null,"456@qq.com",3));
 
分页插件
分页插件使用步骤
添加依赖

com.github.pagehelperpagehelper5.2.0

配置分页插件
在MyBatis的核心配置文件（mybatis-config.xml）中配置插件


分页插件的使用
开启分页功能
在查询功能之前使用PageHelper.startPage(int pageNum, int pageSize)开启分页功能 
pageNum：当前页的页码，
pageSize：每页显示的条数
 
@Test
public void testPageHelper() throws IOException {InputStream is = Resources.getResourceAsStream("mybatis-config.xml");SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);SqlSession sqlSession = sqlSessionFactory.openSession(true);EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);//访问第一页，每页四条数据PageHelper.startPage(1,4);List emps = mapper.selectByExample(null);emps.forEach(System.out::println);
}
分页相关数据
方法一：直接输出
@Test
public void testPageHelper() throws IOException {InputStream is = Resources.getResourceAsStream("mybatis-config.xml");SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);SqlSession sqlSession = sqlSessionFactory.openSession(true);EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);//访问第一页，每页四条数据Page