MyBatis01-MyBatis基本使用

一、什么是MyBatis

• MyBatis 是一款优秀的持久层框架
• MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集的过程
• MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 实体类 【Plain Old Java Objects,普通的 Java对象】映射成数据库中的记录。
• MyBatis 本是apache的一个开源项目ibatis, 2010年这个项目由apache 迁移到了google code，并且改名为MyBatis 。
• 2013年11月迁移到Github .
• Mybatis官方文档 : http://www.mybatis.org/mybatis-3/zh/index.html
• GitHub : https://github.com/mybatis/mybatis-3

1.1、什么是持久化

持久化是将程序数据在持久状态和瞬时状态间转换的机制。

• 即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的对象存储在数据库中，或者存储在磁盘文件中、XML数据文件中等等。
• JDBC就是一种持久化机制。文件IO也是一种持久化机制。
• 在生活中 : 将鲜肉冷藏，吃的时候再解冻的方法也是。将水果做成罐头的方法也是。

为什么需要持久化服务呢？那是由于内存本身的缺陷引起的

• 内存断电后数据会丢失，但有一些对象是无论如何都不能丢失的，比如银行账号等，遗憾的是，人们还无法保证内存永不掉电。
• 内存过于昂贵，与硬盘、光盘等外存相比，内存的价格要高2~3个数量级，而且维持成本也高，至少需要一直供电吧。所以即使对象不需要永久保存，也会因为内存的容量限制不能一直呆在内存中，需要持久化来缓存到外存。

1.2、持久层

什么是持久层？

• 完成持久化工作的代码块 . ----> dao层 【DAO (Data Access Object) 数据访问对象】
• 大多数情况下特别是企业级应用，数据持久化往往也就意味着将内存中的数据保存到磁盘上加以固化，而持久化的实现过程则大多通过各种关系数据库来完成。
• 不过这里有一个字需要特别强调，也就是所谓的“层”。对于应用系统而言，数据持久功能大多是必不可少的组成部分。也就是说，我们的系统中，已经天然的具备了“持久层”概念？也许是，但也许实际情况并非如此。之所以要独立出一个“持久层”的概念,而不是“持久模块”，“持久单元”，也就意味着，我们的系统架构中，应该有一个相对独立的逻辑层面，专注于数据持久化逻辑的实现.
• 与系统其他部分相对而言，这个层面应该具有一个较为清晰和严格的逻辑边界。【说白了就是用来操作数据库存在的！】

1.3、为什么需要Mybatis

• Mybatis就是帮助程序猿将数据存入数据库中 , 和从数据库中取数据 .
• 传统的jdbc操作 , 有很多重复代码块 .比如 : 数据取出时的封装 , 数据库的建立连接等等… , 通过框架可以减少重复代码,提高开发效率 .
• MyBatis 是一个半自动化的ORM框架 (Object Relationship Mapping) -->对象关系映射
• 所有的事情，不用Mybatis依旧可以做到，只是用了它，所有实现会更加简单！技术没有高低之分，只有使用这个技术的人有高低之别
• MyBatis的优点
• • 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件就可以了，易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
  • 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。
  • 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
  • 提供xml标签，支持编写动态sql。

1.4、什么是对象关系映射（ORM）？

定义：

ORM的全称是Object Relational Mapping，即对象关系映射。它的实质就是将关系数据（库）中的业务数据用对象的形式表示出来，并通过面向对象（Object-Oriented）的方式将这些对象组织起来，实现系统业务逻辑的过程。

简单点说，如果我们用的是面向对象的编程语言，数据库使用的数据库是关系型数据库，那么将面向对象的语言和面向关系型的数据库之间建立一种映射关系，这就是对象关系映射。

它赋予我们一个强大的功能，就是可以用面向对象的思维来操作数据库，不用再和SQL语句打交道了。

映射

映射（Mapping），通过这种映射可以使业务对象与数据库分离。从面向对象来说，数据库不应该和业务逻辑绑定到一起，ORM则起到这样的分离作用，使数据库层透明，开发人员真正的面向对象。图 1简单说明了ORM在多层系统架构中的这个作用。

1.4、Mybatis架构

1、mybatis配置：
mybatis-config.xml,此文件作为mybatis的全局配置文件,配置了mybatis的运行环境等信息。mapper.xml文件即 sql 映射文件，文件中配置了操作数据库的 sql语句。此文件需要在mybatis-config.xml中加载。

2、通过mybatis环境等配置信息构造 SqlSessionFactory即会话工厂

3、由会话工厂创建sqlSession即会话，操作数据库需要通过sqlSession行。

4、mybatis 底层自定义了Executor执行器接口操作数据库，Executor接口有两个实现，一个是基本执行器、一个是缓存执行器。

5、Mapped Statement也是mybatis一个底层封装对象，它包装了mybatis配置信息及 sql映射信息等。mapper.xml文件中一个sql对应一个Mapped Statement对象，sql的id即是Mapped statement的 id。

6、Mapped Statement对sql执行输入参数进行定义,包括HashMap、基本类型、pojo，Executor通过Mapped Statement 在执行sql前将输入的java对象映射至 sql中，输入参数映射就是jdbc编程中对preparedStatement 设置参数。

7、Mapped Statement对sql执行输出结果进行定义,包括HashMap、基本类型、pojo，Executor通过Mapped Statement在执行sql后将输出结果映射至java对象中,输出结果映射过程相当于jdbc编程中对结果的解析处理过程。

二、第一个Mybatis程序

思路流程：搭建环境–>导入Mybatis—>编写代码—>测试

1、搭建实验数据库

2、导入MyBatis相关 jar 包

• maven网络资源库

<  <!--    导入依赖-->
    <dependencies>
        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!-- 导入mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!-- 导入 junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

3、编写MyBatis核心配置文件

• 查看帮助文档

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"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!--    每一个Mapper.XML都需要在mybatis核心配置文件中注册-->
    <mappers>
        <mapper resource="com/zsn/dao/userMapper.xml"/>
    </mappers>
</configuration>

4、编写MyBatis工具类

• 查看帮助文档

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 sqlSessionFactory;
    static {
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
      }
    }
//获取SqlSession连接
  public static SqlSession getSession(){
   return sqlSessionFactory.openSession();
    }
}

5、创建实体类

public class User {
    private int id;  //id
    private String name;   //姓名
    private String pwd;   //密码
    //构造,有参,无参
    //set/get
    //toString()
}

6、编写Mapper接口类

import com.zsn.pojo.User;
import java.util.List;
public interface UserMapper {
    List<User> selectUser();
}

7、编写Mapper.xml配置文件

• namespace 十分重要，不能写错！

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">
    
 <!-- namespace=绑定一个对应的/Dao/Mapper接口-->
<mapper namespace="com.kuang.dao.UserMapper">
  <select id="selectUser" resultType="com.zsn.pojo.User">
    select * from user
  </select>
</mapper>

8、编写测试类

• Junit 包测试

public class MyTest {
    @Test
    public void selectUser() {
        //SqlSession 的实例不是线程安全的
        SqlSession session = MybatisUtils.getSession();
        //方法一:过时
        //List users = session.selectList("com.kuang.mapper.UserMapper.selectUser");
        //方法二:
        UserMapper mapper = session.getMapper(UserMapper.class);
        List<User> users = mapper.selectUser();
        while (iterator.hasNext()) {
            User user = iterator.next();
            System.out.println(user);
        }
        //关闭
        session.close();
    }
}

9、运行测试，成功的查询出来的我们的数据，ok！

问题说明

可能出现问题说明：** Maven静态资源过滤问题（找不到xml）

maven由于他的约定大于配置，我们之后可以能遇到我们写的配置文件，无法被导出或者生效的问题，解决方案:

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties
                **/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties
                **/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

三、CRUD(增删改查)

标签中常见的属性

Id：对应是namespace中的方法名（接口中的方法名）

resultType：返回值–>sql语句执行的返回值

parameterType：参数类型（方法中传入的参数）

注意：增删改需要提交事务

1、select

1、编写接口：

//根据id查询用户
    User getUserId(int id);

2、编写对应的mapper中的SQL语句

<!--    增加用户-->
    <insert id="addUser" parameterType="com.zsn.pojo.User">
        insert into mybatis.user (id, name , pwd) values (#{id},#{name },#{pwd});
    </insert>

3、测试

 public static void getUserId(){
        //获取SqlSession对象
        SqlSession session = MybatisUtils.getSession();
        UserMapper mapper = session.getMapper(UserMapper.class);
        User user = mapper.getUserId(1001);
        System.out.println(user);
        session.close();
    }

2、insert

1、编写接口：

 //增加用户
    int addUser(User user);

2、编写对应的mapper中的SQL语句

<!--    增加用户-->
    <insert id="addUser" parameterType="com.zsn.pojo.User">
        insert into mybatis.user (id, name , pwd) values (#{id},#{name },#{pwd});
    </insert>

3、测试

 public static void addUser(){
        //获取SqlSession对象
        SqlSession session = MybatisUtils.getSession();
        UserMapper mapper = session.getMapper(UserMapper.class);
        User user = new User(1003, "王嬢嬢", "123546");
        int result = mapper.addUser(user);
        if(result>0){
            System.out.println("用户添加成功");
        }else{
            System.out.println("用户添加失败");
        }
        //注意要提交事务
        session.commit();
        session.close();
    }

3 、update

1、编写接口：

 //修改用户
    int updateUser(User user);

2、编写对应的mapper中的SQL语句

<!--    修改用户-->
    <update id="updateUser" parameterType="com.zsn.pojo.User">
       update user set name = #{name},pwd=#{pwd} where id = #{id};
    </update>

3、测试

 public static void updateUser(){
        //获取SqlSession对象
        SqlSession session = MybatisUtils.getSession();
        UserMapper mapper = session.getMapper(UserMapper.class);
        User user = new User(1003, "王嬢嬢", "123546");
        int result = mapper.updateUser(user);
        if(result>0){
            System.out.println("用户修改成功");
        }else{
            System.out.println("用户修改失败");
        }
        session.commit();
        session.close();
    }

4、delete

1、编写接口：

 //删除用户
    int deleteUser(int id);

2、编写对应的mapper中的SQL语句

<!--    删除用户-->
    <delete id="deleteUser" parameterType="int">
        delete from mybatis.user where id=#{id}
    </delete>

3、测试

 public static void deleteUser(){
        //获取SqlSession对象
        SqlSession session = MybatisUtils.getSession();
        UserMapper mapper = session.getMapper(UserMapper.class);
        int result = mapper.deleteUser(1003);
        if(result>0){
            System.out.println("用户删除成功");
        }else{
            System.out.println("用户删除失败");
        }
        session.commit();
        session.close();
    }

注意：增删改需要提交事务

5、Map和模糊查询扩展

Map的使用：

假设，我们的实体类，或者数据库中的表。字段或者参数过多是，我们应当考虑使用Map!

1、编写接口：

 //删除用户
  int addUser2(Map<String,Object> map);

2、编写对应的mapper中的SQL语句

这里的values后边传的参数名就可以不用和user中的属性名一一对应

  <!--    增加用户-->
  <insert id="addUser2" parameterType="map">
      insert into mybatis.user (id, name , pwd) values (#{userid},#{username},#{userpwd});
  </insert>

3、测试

public static void addUser2(){
        //获取SqlSession对象
        SqlSession session = MybatisUtils.getSession();
        UserMapper mapper = session.getMapper(UserMapper.class);
        Map<String,Object> map = new HashMap<>();
        map.put("userid",1005);
        map.put("username","诸葛青");
        map.put("userpwd","987654");
        int result = mapper.addUser2(map);
        if(result>0){
            System.out.println("用户添加成功");
        }else{
            System.out.println("用户添加失败");
        }
        //注意要提交事务
        session.commit();
        session.close();
    }

Map传递参数，直接在SQL中取出key即可！

对象传递参数，直接在SQL中取对象的属性即可！

只有一个基本类型的参数的情况下，可以直接在SQL中取到

多个参数用Map或者注解

模糊查询

//模糊查询
List<User> getUserLike(String name);

1、Java代码执行的时候传递通配符

​ 编写对应的mapper中的SQL语句

  
  <select id="getUserLike" parameterType="String" resultType="com.zsn.pojo.User">
	  select * from user where name like #{value}
select>

测试代码：

public static void getUserLike(){
    //获取SqlSession对象
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    List<User> userList = mapper.getUserLike("%王%");
    Iterator<User> iterator = userList.iterator();
    while (iterator.hasNext()) {
        User user = iterator.next();
        System.out.println(user);
    }
    session.close();
}

2、在SQL拼接中使用通配符！

编写对应的mapper中的SQL语句

  
  <select id="getUserLike" parameterType="String" resultType="com.zsn.pojo.User">
	    select * from user where name like "%"#{value}"%"
select>

有SQL注入的风险！！！

测试代码：

public static void getUserLike(){
    //获取SqlSession对象
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    List<User> userList = mapper.getUserLike("%王%");
    Iterator<User> iterator = userList.iterator();
    while (iterator.hasNext()) {
        User user = iterator.next();
        System.out.println(user);
    }
    session.close();
}

2、在SQL拼接中使用通配符！

四、XML配置文件解析

1、核心配置文件

核心配置文件

• mybatis-config.xml 系统核心配置文件
• MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。
• 注意：配置文件标签是有顺序的
• 能配置的内容如下：

configuration（配置）
properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
        environment（环境变量）
           transactionManager（事务管理器）
            dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）
<!-- 注意元素节点的顺序！顺序不对会报错 -->

我们可以阅读 mybatis-config.xml 上面的dtd的头文件！

2、环境配置（environments）

<environments default="development">
  <environment id="development">
    <transactionManager type="JDBC">
      <property name="..." value="..."/>
    </transactionManager>
    <dataSource type="POOLED">
      <property name="driver" value="${driver}"/>
      <property name="url" value="${url}"/>
      <property name="username" value="${username}"/>
      <property name="password" value="${password}"/>
    </dataSource>
  </environment>
</environments>

MyBatis 可以配置成适应多种环境，

不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。

​ 每个数据库对应一个 SqlSessionFactory 实例

注意一些关键点:

• 默认使用的环境 ID（比如：default=“development”）。
• 每个 environment 元素定义的环境 ID（比如：id=“development”）。
• 事务管理器的配置（比如：type=“JDBC”）。
• 数据源的配置（比如：type=“POOLED”）。

默认环境和环境 ID 顾名思义。 环境可以随意命名，但务必保证默认的环境 ID 要匹配其中一个环境 ID。

事务管理器（transactionManager）

在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]":

• JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。
• MANAGED – 这个配置几乎没做什么。

如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器

数据源（dataSource）

有三种内建的数据源类型（也就是 type="[UNPOOLED|POOLED|JNDI]"）：

常用POOLED 即连接池

3、属性（properties）

编写配置文件：

db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8
username=root
password=123456

在核心配置文件中映射：

<!- 引入外部位置文件-->
<properties resource="db.properties"/>
<environments default="development">
    <environment id="development">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <property name="driver" value="${driver}"/>
            <property name="url" value="${url}"/>
            <property name="username" value="${username}"/>
            <property name="password" value="${password}"/>
        dataSource>
    environment>
environments>

• 可以直接引入外部配置文件
• 可以在其中增加属性
• 如果两个文件有同一个字段，优先使用外部文件的

<properties resource="db.properties">
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
properties>

4、别名（typeAliases）

• 类型别名可为 Java 类型设置一个缩写名字
• 意义：在于降低冗余的全限定类名书写

语法：

SQL语句xml文件（没有起别名）

 <select id="getUserId" resultType="com.zsn.pojo.User" >
 	 select * from user 
select>

起别名后：

<select id="getUserList" resultType="User">
  	select * from user
select>

• 也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，比如：

<typeAliases>
  <package name="com.zsn.pojo"/>
typeAliases>

每一个在包 com.zsn.pojo 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 com.zsn.pojo.User 的别名为 user；若有注解（@Alias(“别名”)），则别名为其注解值。

用法：

​ 实体类较少可以使用第一种

​ 实例类多的可以用第二种

5、设置（setting）

查看文档：

设置名	描述	有效值	默认值
cacheEnabled	全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。	true | false	true
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。	true | false	false
aggressiveLazyLoading	开启时，任一方法的调用都会加载该对象的所有延迟加载属性。 否则，每个延迟加载属性会按需加载（参考 lazyLoadTriggerMethods)。	true | false	false （在 3.4.1 及之前的版本中默认为 true）
multipleResultSetsEnabled	是否允许单个语句返回多结果集（需要数据库驱动支持）。	true | false	true
useColumnLabel	使用列标签代替列名。实际表现依赖于数据库驱动，具体可参考数据库驱动的相关文档，或通过对比测试来观察。	true | false	true
useGeneratedKeys	允许 JDBC 支持自动生成主键，需要数据库驱动支持。如果设置为 true，将强制使用自动生成主键。尽管一些数据库驱动不支持此特性，但仍可正常工作（如 Derby）。	true | false	False
autoMappingBehavior	指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示关闭自动映射；PARTIAL 只会自动映射没有定义嵌套结果映射的字段。 FULL 会自动映射任何复杂的结果集（无论是否嵌套）。	NONE, PARTIAL, FULL	PARTIAL
autoMappingUnknownColumnBehavior	指定发现自动映射目标未知列（或未知属性类型）的行为。NONE: 不做任何反应WARNING: 输出警告日志（'org.apache.ibatis.session.AutoMappingUnknownColumnBehavior' 的日志等级必须设置为 WARN）FAILING: 映射失败 (抛出 SqlSessionException)	NONE, WARNING, FAILING	NONE
defaultExecutorType	配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（PreparedStatement）； BATCH 执行器不仅重用语句还会执行批量更新。	SIMPLE REUSE BATCH	SIMPLE
defaultStatementTimeout	设置超时时间，它决定数据库驱动等待数据库响应的秒数。	任意正整数	未设置 (null)
defaultFetchSize	为驱动的结果集获取数量（fetchSize）设置一个建议值。此参数只可以在查询设置中被覆盖。	任意正整数	未设置 (null)
defaultResultSetType	指定语句默认的滚动策略。（新增于 3.5.2）	FORWARD_ONLY | SCROLL_SENSITIVE | SCROLL_INSENSITIVE | DEFAULT（等同于未设置）	未设置 (null)
safeRowBoundsEnabled	是否允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为 false。	true | false	False
safeResultHandlerEnabled	是否允许在嵌套语句中使用结果处理器（ResultHandler）。如果允许使用则设置为 false。	true | false	True
mapUnderscoreToCamelCase	是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。	true | false	False
localCacheScope	MyBatis 利用本地缓存机制（Local Cache）防止循环引用和加速重复的嵌套查询。 默认值为 SESSION，会缓存一个会话中执行的所有查询。 若设置值为 STATEMENT，本地缓存将仅用于执行语句，对相同 SqlSession 的不同查询将不会进行缓存。	SESSION | STATEMENT	SESSION
jdbcTypeForNull	当没有为参数指定特定的 JDBC 类型时，空值的默认 JDBC 类型。 某些数据库驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。	JdbcType 常量，常用值：NULL、VARCHAR 或 OTHER。	OTHER
lazyLoadTriggerMethods	指定对象的哪些方法触发一次延迟加载。	用逗号分隔的方法列表。	equals,clone,hashCode,toString
defaultScriptingLanguage	指定动态 SQL 生成使用的默认脚本语言。	一个类型别名或全限定类名。	org.apache.ibatis.scripting.xmltags.XMLLanguageDriver
defaultEnumTypeHandler	指定 Enum 使用的默认 TypeHandler 。（新增于 3.4.5）	一个类型别名或全限定类名。	org.apache.ibatis.type.EnumTypeHandler
callSettersOnNulls	指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这在依赖于 Map.keySet() 或 null 值进行初始化时比较有用。注意基本类型（int、boolean 等）是不能设置成 null 的。	true | false	false
returnInstanceForEmptyRow	当返回行的所有列都是空时，MyBatis默认返回 null。 当开启这个设置时，MyBatis会返回一个空实例。 请注意，它也适用于嵌套的结果集（如集合或关联）。（新增于 3.4.2）	true | false	false
logPrefix	指定 MyBatis 增加到日志名称的前缀。	任何字符串	未设置
logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING	未设置
proxyFactory	指定 Mybatis 创建可延迟加载对象所用到的代理工具。	CGLIB | JAVASSIST	JAVASSIST （MyBatis 3.3 以上）
vfsImpl	指定 VFS 的实现	自定义 VFS 的实现的类全限定名，以逗号分隔。	未设置
useActualParamName	允许使用方法签名中的名称作为语句参数名称。 为了使用该特性，你的项目必须采用 Java 8 编译，并且加上 -parameters 选项。（新增于 3.4.1）	true | false	true
configurationFactory	指定一个提供 Configuration 实例的类。 这个被返回的 Configuration 实例用来加载被反序列化对象的延迟加载属性值。 这个类必须包含一个签名为static Configuration getConfiguration() 的方法。（新增于 3.2.3）	一个类型别名或完全限定类名。	未设置
shrinkWhitespacesInSql	从SQL中删除多余的空格字符。请注意，这也会影响SQL中的文字字符串。 (新增于 3.5.5)	true | false	false
defaultSqlProviderType	Specifies an sql provider class that holds provider method (Since 3.5.6). This class apply to the type(or value) attribute on sql provider annotation(e.g. @SelectProvider), when these attribute was omitted.	A type alias or fully qualified class name	Not set

一个配置完整的 settings 元素的示例如下：

6、其他配置

• 类型处理器（typeHandlers）

• 对象工厂（objectFactory）

• 插件（plugins）

映射器（mappers）

定义 SQL 映射语句了。 但首先，我们需要告诉 MyBatis 到哪里去找到这些语句

引入资源方式

<!-- 使用相对于类路径的资源引用 -->
<mappers>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>
<!-- 使用完全限定资源定位符（URL） -->
<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
</mappers>
<!--
使用映射器接口实现类的完全限定类名
需要配置文件名称和接口名称一致，并且位于同一目录下
-->
<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
</mappers>
<!--

将包内的映射器接口实现全部注册为映射
但是需要配置文件名称和接口名称一致，并且位于同一目录
-->
<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

Mapper文件

方式一：推荐使用

<mappers>
    <mapper resource="com/zsn/dao/UserMapper.xml"/>
mappers>

方式二：使用class文件绑定注册

<mappers>
    <mapper resource="com.zsn.dao.UserMapper"/>
mappers>

注意：

• 接口和Mapper配置文件必须同名
• 接口和Mapper配置文件必须在同一个包下

方式三：使用扫描包进行绑定

<mappers>
    <package name="com.zsn.dao"/>
mappers>

注意：

• 接口和Mapper配置文件必须同名
• 接口和Mapper配置文件必须在同一个包下

8、生命周期和作用域

作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题。

SqlSessionFactoryBuilder

• 一旦创建了SqSessionFactory,就不在需要它了
• 局部变量

SqSessionFactory

• 说白了就是可以想象为：数据库连接池
• SqSessionFactory一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例
• 因此SqSessionFactory的最佳作用域是应用作用域
• 最简单的就是使用单例模式或者静态单例模式

SqlSession

• 连接到连接池的一个请求
• SqSession的实例是线程不安全的，因此是不能被共享的，所以它的最佳作用域是请求或方法作用域
• 用完之后需要赶紧关闭，否则资源被占用！

五、ResultMap结果集映射

解决属性名和字段名（数据库中字段）不一致的问题

属性名和字段名不一致查询出来的结果会为null

1、查看之前的数据库的字段名

2、Java中的实体类设计

public class User {
    private int id;  //id
    private String name;   //姓名
    private String password;   //密码和数据库不一样！
    //构造
   //set/get
    //toString()
}

3、接口

//根据id查询用户
User selectUserById(int id);

4、mapper映射文件

<select id="selectUserById" resultType="user">
    select * from user where id = #{id}
</select>

5、测试

@Test
public void testSelectUserById() {
    SqlSession session = MybatisUtils.getSession();  //获取SqlSession连接
    UserMapper mapper = session.getMapper(UserMapper.class);
    User user = mapper.selectUserById(1);
    System.out.println(user);
    session.close();
}

结果:

• User{id=1, name=‘诸葛青’, password=‘null’}
• 查询出来发现 password 为空 . 说明出现了问题！

分析：

• select * from user where id = #{id} 可以看做

  select id,name,pwd from user where id = #{id}

• mybatis会根据这些查询的列名(会将列名转化为小写,数据库不区分大小写) , 去对应的实体类中查找相应列名的set方法设值 , 由于找不到setPwd() , 所以password返回null ; 【自动映射】

解决：

1、起别名

<select id="selectUserById" resultType="User">
    select id , name , pwd as password from user where id = #{id}
select>

2、使用结果集映射->ResultMap 【推荐】

<resultMap id="UserMap" type="User">
    
    <id column="id" property="id"/>
    
    <result column="name" property="name"/>
    <result column="pwd" property="password"/>
resultMap>
 
<select id="selectUserById" resultMap="UserMap">
    select id , name , pwd from user where id = #{id}
select>

ResultMap结果集映射

<resultMap id="UserMap" type="User">
    
    <id column="id" property="id"/>
    
    <result column="name" property="name"/>
    <result column="pwd" property="password"/>
resultMap>

ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

六、日志

6.1、日志工厂

如果一个数据库操作，出现了异常，我们需要排错，日志就是最好的助手。

以前排错：sout、debug

现在日志工厂：

logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING	未设置

• SLF4J
• LOG4J （掌握）
• LOG4J2
• JDK_LOGGING
• COMMONS_LOGGING
• STDOUT_LOGGING （掌握）
• NO_LOGGING

在Mybatis中具体使用哪一个日志实现，在设置中设定

STDOUT_LOGGING标准日志输出

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

6.2、LOG4J

什么是log4j?

• Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件等
• 我们也可以控制每一条日志的输出格式；
• 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
• 可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

1.先导入log4j的包

<dependency>
    <groupId>log4jgroupId>
    <artifactId>log4jartifactId>
    <version>1.2.17version>
dependency>

2、写log4j.properties配置文件

### 设置###
log4j.rootLogger = debug,stdout,D,E

### 输出信息到控制抬 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n

### 输出DEBUG 级别以上的日志到=E://JavaTools/log/log.log ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = E://JavaTools/log/log.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = DEBUG
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

### 输出ERROR 级别以上的日志到=E://JavaTools/log/error.log  ###
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File =E://JavaTools/log/error.log
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

3、配置mybatis-config.xml文件

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

4、日志级别

每个Logger都被了一个日志级别（log level），用来控制日志信息的输出。日志级别从高到低分为：
A：off 最高等级，用于关闭所有日志记录。
B：fatal 指出每个严重的错误事件将会导致应用程序的退出。
C：error 指出虽然发生错误事件，但仍然不影响系统的继续运行。
D：warm 表明会出现潜在的错误情形。
E：info 一般和在粗粒度级别上，强调应用程序的运行全程。
F：debug 一般用于细粒度级别上，对调试应用程序非常有帮助。
G：all 最低等级，用于打开所有日志记录。

5、简单使用：

5.1、导包：

import org.apache.log4j.Logger;

5.2、设置全局变量

public static Logger log= Logger.getLogger(UserDaoTest.class);

5.3、输出

log.info("info：进入getUserList()方法");
log.error("info：进入getUserList()方法");
log.debug("info：进入getUserList()方法");

七、分页

使用limit分页

语法：

语法：select * from user limit startIndex,pageSize;
select * from user limit 0,3;

使用mybatis实现分页

接口：

//分页
List<User> getUserByLimit(Map<String,Integer> map);

SQL：

  
  <select id="getUserByLimit" parameterType="map" resultType="user" >
  select * from user limit #{startIndex},#{pageSize}
	select>

测试类：

public static void getUserByLimit(){
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    Map<String,Integer> map = new HashMap<>();
    map.put("startIndex",0);
    map.put("pageSize", 2);
    List<User> userList = mapper.getUserByLimit(map);
    for(User uesr:userList){
        System.out.println(uesr);
    }
    session.close();
}

分页插件PageHelper

八、使用注解

大家之前都学过面向对象编程，也学习过接口，但在真正的开发中，很多时候我们会选择面向接口编程。

根本原因 : 解耦 , 可拓展 , 提高复用 , 分层开发中 , 上层不用管具体的实现 , 大家都遵守共同的标准 , 使得开发变得容易 , 规范性更好。

关于接口的理解

• 接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。
• 接口的本身反映了系统设计人员对系统的抽象理解。
• 接口应有两类：
• • 第一类是对一个个体的抽象，它可对应为一个抽象体(abstract class)；
  • 第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）；
• 一个体有可能有多个抽象面。抽象体与抽象面是有区别的。

三个面向区别

• 面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法 .
• 面向过程是指，我们考虑问题时，以一个具体的流程（事务过程）为单位，考虑它的实现 .
• 接口设计与非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题.更多的体现就是对系统整体的架构

8.1 利用注解开发

• mybatis最初配置信息是基于 XML ,映射语句(SQL)也是定义在 XML 中的。而到MyBatis 3提供了新的基于注解的配置。不幸的是，Java 注解的的表达力和灵活性十分有限。最强大的 MyBatis 映射并不能用注解来构建

  简单语句可以使用注解，复杂语句使用xml配置文件，都推荐使用配置文件，易看，好维护

• sql 类型主要分成 :

• • @select ()
  • @update ()
  • @Insert ()
  • @delete ()

**注意：**利用注解开发就不需要mapper.xml映射文件了

1、在接口中添加注解

//查询全部用户
@Select("select * from user")
List<User> getUserList();

2、在mybatis-config.xml的核心配置文件中注入

<mappers>
    <mapper class="com.kuang.mapper.UserMapper"/>
mappers>

3、测试

public static void getUserList(){
    log.info("info：进入getUserList()方法");
    //获取SqlSession对象
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    List<User> userList = mapper.getUserList();
    Iterator<User> iterator = userList.iterator();
    while (iterator.hasNext()) {
        User user = iterator.next();
        System.out.println(user);
    }
    session.close();
}

4、本质上利用了jvm的动态代理机制。

8.2注解增删改查：

查询

1、编写接口方法

//根据id查询用户
@Select("select * from user where id = #{id}")
User selectUserById(@Param("id") int id);

2、测试

@Test
public void testSelectUserById() {
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
 
    User user = mapper.selectUserById(1);
    System.out.println(user);
 
    session.close();
}

增加

1、编写接口方法

//添加一个用户
@Insert("insert into user (id,name,pwd) values (#{id},#{name},#{pwd})")
int addUser(User user);

2、测试

@Test
public void testAddUser() {
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
 
    User user = new User(6, "张灵玉", "123456");
    mapper.addUser(user);
 
    session.close();
}

删除

1、编写接口方法

//根据id删除用
@Delete("delete from user where id = #{id}")
int deleteUser(@Param("id")int id);

2、测试

@Test
public void testDeleteUser() {
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
 
    mapper.deleteUser(6);
    
    session.close();
}

修改

1、编写接口方法

//修改一个用户
@Update("update user set name=#{name},pwd=#{pwd} where id = #{id}")
int updateUser(User user);

2、测试

@Test
public void testUpdateUser() {
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
 
    User user = new User(6, "张起灵", "zxcvbn");
    mapper.updateUser(user);
 
    session.close();
}

【注意点：增删改一定记得对事务的处理】

关于@Param

@Param注解用于给方法参数起一个名字。以下是总结的使用原则：

• 在方法只接受一个参数的情况下，可以不使用@Param。
• 在方法接受多个参数的情况下，建议一定要使用@Param注解给参数命名。
• 如果参数是 JavaBean ， 则不能使用@Param。
• 不使用@Param注解时，参数只能有一个，并且是Javabean。

#{}与${}的区别

#{}和${}都能取得简单的数据类型，pojo对象，map对象的值。

#，$如果取pojo对象的属性，那么需要和pojo的属性一致;如果取map的值，那么需要和map的key一致

• #{} 的作用主要是替换预编译语句(PrepareStatement)中的占位符? 【推荐使用】

  有效防止SQL注入

  INSERT INTO user (name) VALUES (#{name});
  INSERT INTO user (name) VALUES (?);
  

• ${} 的作用是直接进行字符串拼接

  INSERT INTO user (name) VALUES ('${name}');
  INSERT INTO user (name) VALUES ('kuangshen');
  

• 使用的时候一般都使用#{可以防止sql注入;但是也有必须要使用$的情况〈不能做为sql参数的情况下，只能使用$，例如:根据XX进行排序，升序还是降序)

九、Lombok

Lombok介绍

Lombok是一个Java库，能自动插入编辑器并构建工具，简化Java开发。通过添加注解的方式，不需要为类编写getter或eques等方法，同时可以自动化日志变量。

Lombok使用方法：

1、lombok下载

直接下载，重启idea

2、导入maven依赖

<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <version>1.18.12version>
dependency>

常用注解

• @Data 注解在类上，生成setter/getter、equals、canEqual、hashCode、toString方法，如为final属性，则不会为该属性生成setter方法。
• @Setter：注解在属性上；为属性提供 setting 方法
• @Getter ：注解在属性上；为属性提供 getting 方法
• @Log4j ：注解在类上；为类提供一个 属性名为log 的 log4j 日志对象
• @NoArgsConstructor：注解在类上；为类提供一个无参的构造方法
• @AllArgsConstructor：注解在类上；为类提供一个全参的构造方法
• @Cleanup : 可以关闭流
• @Builder： 被注解的类加个构造者模式
• @Synchronized ： 加个同步锁
• @SneakyThrows : 等同于try/catch 捕获异常
• @NonNull : 如果给参数加个这个注解 参数为null会抛出空指针异常
• @Value : 注解和@Data类似，区别在于它会把所有成员变量默认定义为private final修饰，并且不会生成set方法。

Lombok的优缺点

优点：

• 能通过注解的形式自动生成构造器、getter/setter、equals、hashcode、toString等方法，提高了一定的开发效率
• 让代码变得简洁，不用过多的去关注相应的方法
• 属性做修改时，也简化了维护为这些属性所生成的getter/setter方法等

缺点：

• 不支持多种参数构造器的重载
• 虽然省去了手动创建getter/setter方法的麻烦，但大大降低了源代码的可读性和完整性，降低了阅读源代码的舒适度