MyBatis 3

一、MyBatis简介

优秀的持久层框架，支持支持自定义 SQL、存储过程以及高级映射，专注于SQL的编写。

? 为什么不使用工具类进行数据库操作：

? 功能简单，sql语句编写在Java代码里面，是一种硬编码高耦合的方式，不推荐。

Hibernate：

? 另一种持久层框架，全自动全映射ORM（Object Relation Mapping）框架，旨在消除SQL。

? 主要特点：一个JavaBean对象与数据库中一条记录建立映射，中间过程对于程序员来讲是黑箱操作，无须关注SQL语句的编写。

? 缺点：框架自动生成SQL语句，程序员无法进行SQL优化；JavaBean中每一个字段都在数据库中有相应映射，加重了数据库的负担。

? 需求：SQL语句交给我们开发人员编写，希望SQL不失去灵活性。于是，诞生了MyBatis：

MyBatis官方文档

二、MyBatis接口式编程 Hello World

1. 搭建环境

? lombok介绍：

? Lombok 是一种 Java? 实用工具，可用来帮助开发人员消除 Java 的冗长，尤其是对于简单的 Java 对象（POJO）。它通过注解实现这一目的。

? 通过@Data注解，让被修饰的类自动生成getter和setter方法、构造器、equals方法、或者hash方法等。

? 如果觉得@Data这个注解有点简单粗暴的话,Lombok提供一些更精细的注解,比如@Getter,@Setter,(这两个是field注解),@ToString,@AllArgsConstructor(这两个是类注解)。

? log4j介绍：

? Apache的开源项目log4j是一个功能强大的日志组件,提供方便的日志记录。可以查看在debug时候的sql语句。

? 一般在resources目录下创建log4j.properties文件，进行配置。

1.1 Maven

导入依赖：

  
    
    
      junit
      junit
      4.11
      test
    
    
    
      org.projectlombok
      lombok
      RELEASE
      compile
    
    
    
      org.mybatis
      mybatis
      3.4.6
      compile
    
    
      org.junit.jupiter
      junit-jupiter
      RELEASE
      compile
    
    
    
      log4j
      log4j
      1.2.17
    
    
     
    
      mysql
      mysql-connector-java
      8.0.26
    
  

1.2 Bean

@Data
public class Employee {
    private int id;
    private String name;
    private String age;
}

1.3 配置文件

放在resources目录下：

<?xml version="1.0" encoding="UTF-8" ?>



    
    
    
    
    
    
        
            
            
                
                
                
                
                
            
        
    

    
    
        
    

数据库配置文件properties，同样也存放在resources目录下

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatisdb
username=root
password=zouwenhao

日志的配置文件properties，resources目录下：

log4j.rootLogger=DEBUG,A1

log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n

mapper配置文件，在这里面编写sql：

    
        select * from info where id = #{id}
    

1.4 通过SqlSession建立与数据库的会话

老版本的编程方法：

    /* MyBatis操作数据库的整体思路：
     * 1、根据xml配置文件（全局配置文件）创建一个SqlSessionFactory对象，有数据源一些运行环境信息 （config）
     * 2、sql映射配置文件；配置了每一个sql，以及sql的封装规则等。 （mapper）
     * 3、将sql映射文件注册在全局配置文件中 （config配置文件中的mapper标签进行注册）
     * 4、写代码：
     * 		1）、根据全局配置文件得到SqlSessionFactory；
     * 		2）、使用sqlSession工厂，获取到sqlSession对象使用他来执行增删改查（一个与数据库操作的代理对象）
     * 			一个sqlSession就是代表和数据库的一次会话，用完关闭，使用close方法
     * 		3）、使用sql的唯一标志来告诉MyBatis执行哪个sql。sql都是保存在sql映射文件中的。
     */
    // 返回SqlSessionFactory对象
    public SqlSessionFactory getSqlSessionFactory() throws IOException {
        // MyBatis全局配置文件路径
        String resource = "mybatis_config.xml";
        // 获取MyBatis全局配置文件的输入流
        InputStream inputStream = Resources.getResourceAsStream(resource);
        // 获取SqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        return  sqlSessionFactory;
    }

    // 查询测试，老的方法
    @Test
    public void testHello() throws IOException {
        // 1.获取SqlSessionFactory实例
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();

        // 2.获取SqlSession实例，能直接执行已经映射的sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();
        try {
            // 为了避免mapper映射出现重名的情况，一般使用 命名空间+查询id
            /*
            *   第一个参数：sql的唯一标识，statement Unique identifier matching the statement to use.
            *   第二个参数：执行sql要用的参数，parameter A parameter object to pass to the statement.
            * */
            Employee employee = sqlSession.selectOne("com.atguigu.mybatis.mapper.selectEmp", 1001);
            System.out.println(employee);
        } finally {
            // sqlSession表示与数据库的一次对话，用完之后必须手动关闭
            sqlSession.close();
        }
    }

1.5 接口式编程（推荐）

? 使用接口与配置文件进行动态绑定，接口中的方法与select标签进行绑定

1. 第一步：创建接口，getEmpById方法返回Employee对象

   public interface EmployeeMapper {
   
       public Employee getEmpById(Integer id);
   
   }
   

2. 第二步：修改原EmployeeMapper.xml文件

   
    
       
           select * from info where id = #{id}
       
   
   

3. 第三步：编写测试类

   思路是：拿到接口的实现类对象，然后调用接口的方法，进行数据库的查询操作

       @Test
       public void testHelloByInterface() throws IOException {
           // 1.获取SqlSessionFactory实例
           SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
           // 2.获取SqlSession实例，与数据库建立会话
           SqlSession sqlSession = sqlSessionFactory.openSession();
           try {
               // 3. 获取接口的实现类对象
               // 会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
               EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);//获取代理对象
               Employee emp = mapper.getEmpById(1001);
               System.out.println(emp);
           } finally {
               sqlSession.close();
           }
       }
   

   ? 使用接口式编程的好处：

   ? 拥有更强的类型检查，以及返回值的限制，能够将DAO层与实现进行分离出来。

1.6 总结

1. SqlSession和connection一样都不是线程安全的，因此不能共享，每次使用都应该去获取新的对象。

2. SqlSession代表和数据库的一次会话，用完就必须关闭。

3. mapper接口没有实现类，但是MyBatis会为这个接口生成一个代理对象：（将接口与xml进行绑定）

   ? EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);

4. 两个重要的配置文件：

   ? mybatis的全局配置文件：包含数据库连接池的信息、事务管理器信息等

   ? sql映射文件：保存了每一个sql语句的映射信息，包括这个sql语句的标识、返回的信息类型（select标签）

三、MyBatis-全局配置文件

? 全局配置文件中的dtd约束，对应了语法规则，在编写时，会有相关提示信息

1. properties_引入外部配置文件

	
	 
    
    ......
    
    

如果属性在不只一个地方进行了配置，那么 MyBatis 将按照下面的顺序来加载：

? – 在 properties 元素体内指定的属性首先被读取。

? – 然后根据 properties 元素中的 resource 属性读取类路径下属性文件或根据 url 属性指定的路径读取属性文件，并覆盖已读取的同名属性。

? – 最后读取作为方法参数传递的属性，并覆盖已读取的同名属性。

2. settings_运行时行为设置

? 以是否开启驼峰命名规则映射为例：

3. typeAliases_别名处理器（不推荐使用）

? 将全类名与别名建立映射关系，这样在一些使用全类名的条件下，可以使用别名。

4. typeHandlers_类型处理器（了解）

? MyBatis 在设置预处理语句（PreparedStatement）中的参数或从结果集中取出一个值时， 都会用类型处理器将获取到的值以合适的方式转换成 Java 类型。部分如下所示：

5. plugins_插件（本章了解）

? MyBatis 允许你在映射SQL语句执行过程中的某一过程进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：

• Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)

• ParameterHandler (getParameterObject, setParameters)

• ResultSetHandler (handleResultSets, handleOutputParameters)

• StatementHandler (prepare, parameterize, batch, update, query)

  通常使用插件来修改MyBatis的一些核心行为，插件通过动态代理机制。

6. environments_运行环境

? MyBatis可以配置多种环境，比如开发、测试和生 产环境需要有不同的配置。

? 每种环境使用一个environment标签进行配置并指 定唯一标识符。

? 可以通过environments标签中的default属性指定一个环境的标识符来快速的切换环境。

? 配置当前运行环境，比如数据库、事务管理器的信息，可以创建多个运行环境，如下所示：有MySQL和Oracle两种数据库环境。

? type： JDBC | MANAGED | 自定义

– JDBC：使用了 JDBC 的提交和回滚设置，**依赖于从数据源得到的连接来管理事务范围**。 		

? JdbcTransactionFactory

? – MANAGED：不提交或回滚一个连接，让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下 文）。

? ManagedTransactionFactory

? – 自定义：实现TransactionFactory接口，type=全类名/ 别名

? type： UNPOOLED | POOLED | JNDI | 自定义

? – UNPOOLED：不使用连接池， UnpooledDataSourceFactory

? – POOLED：使用连接池， PooledDataSourceFactory

? – JNDI： 在EJB或应用服务器这类容器中查找指定的数据源

? – 自定义：实现DataSourceFactory接口，定义数据源的获取方式。

? 实际开发中我们使用Spring管理数据源，并进行事务控制的配置来覆盖上述配置。

7. databaseProvider_多数据库支持

? 下图databaseId指定了在什么数据库环境下，才会执行这条sql语句。至于当前是在什么环境下，则在environments标签下设置default属性值，用于设置当前数据库运行环境。

? 例如：当前在MySQL环境下，因此一旦需要执行这条语句，那么就会执行这条语句，如果是Oracle环境下，就不会执行这条语句，而是会执行另一条databaseId为oracle的语句。

8. mappers_sql映射注册

? 将sql映射注册到全局配置中来

? 注解方式的举例：将sql语句写在注解上，注意在全局配置文件中使用class属性进行接口注册

public interface EmployeeMapperAnnotation {
  @Select({"select * from tbl_employee where id=#{id}"})
  Employee getEmpById(Integer paramInteger);
}

? 测试方法的编写：

    @Test
    public void testHelloByAnno() throws IOException {
        // 1.获取SqlSessionFactory实例
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();

        // 2.获取SqlSession实例，与数据库建立会话
        SqlSession sqlSession = sqlSessionFactory.openSession();

        try {
            // 3. 获取接口的实现类对象
            EmployeeMapperAnnotation mapper = sqlSession.getMapper(EmployeeMapperAnnotation.class);
            Employee emp = mapper.getEmpById(1001);
            System.out.println(emp);
        } finally {
            sqlSession.close();
        }
    }

四、MyBatis-映射文件(重要)

1. 增删改查

? 前提，MyBatis配置环境已经像前文一样配置完毕！

1.1 接口方法

public interface EmployeeMapper {

    Employee getEmpById(Integer paramInteger);

    // mybatis允许增删改直接定义以下类型返回值
    //      Integer、Long、Boolean、void
    Long addEmp(Employee employee);

    Long updateEmp(Employee employee);

    Long deleteEmp(Integer id);

}

1.2 Mapper配置文件

? 在mapper配置文件中，建立与接口方法的映射，同时记得在MyBatis全局配置文件中，进行注册：

? EmployeeMapper.xml:

	
    
        select * from info where id = #{id}
    

    
    
    
        insert into info(name, age) values (#{name}, #{age})
    

    
    
        update info
        set name=#{name}, age=#{age}
        where id=#{id}
    

    
    
        delete from info where id=#{id}
    

1.3 测试

    @Test
    public void EmpTest() throws IOException {
        // 1. 获取sqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        // 2. 获取sqlSession对象，但并不会自动提交
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 自动提交：sqlSessionFactory.openSession(true);

        try {
            // 3. 获取接口的代理对象
            EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);

            // 4. 更新数据
//            Long result = mapper.updateEmp(new Employee(1001, "Paul", 23));

            // 4. 添加数据，id是自增的，所以可以传一个null
            Long result = mapper.addEmp(new Employee(null, "Dick", 21));

            // 4. 删除操作，指定id值
//            Long result = mapper.deleteEmp(1005);

            System.out.println(result > 0 ? "操作成功！" : "操作失败！");

            // 5. 手动提交事务
            sqlSession.commit();
        } finally {
            // 5. 关闭会话
            sqlSession.close();
        }
    }

注意：

1. openSession()获取到的SqlSession实例是不会自动提交的，需要在sql语句执行完，手动commit提交，如果想自动提交，则使用openSession(true)方法获取实例。

2. 关于MySQL数据库使用自增id，当我们需要使用自增id时，类对象只需要将自增id传入一个null值即可，但一定要保证数据库中该键是开启了自动增长。如果报以下错误：

   java.sql.SQLException: Field 'id' doesn't have a default value

   ? 说明没有开启自动增长，开启后，需要重启以下数据库！

2. Insert

1. MySQL数据库获取自增主键的值：

	
	
	
		insert into tbl_employee(last_name,email,gender) 
		values(#{lastName},#{email},#{gender})
	

2. Oracle数据库不支持自增：

   使用序列来模拟自增，就需要手动执行sql语句，才查询下一个应该自增的值。

   有两种解决思路：

   1. 先执行查询sql，获取到自增主键值后，再进行insert插入语句。

      ? 用BEFORE修饰selectKey标签，并通过 .nextva 获取自增后的主键值，再进行插入操作

   2. 先执行insert插入语句，使用 .nextval 表示新记录自增主键值，然后执行AFTER修饰的selectKey标签，使用 .currval 获取当前新纪录自增后的主键值。

	
	
	
		
		
			
			
			select EMPLOYEES_SEQ.nextval from dual 
			
		
		
		
		
		insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL) 
		values(#{id},#{lastName},#{email}) 
		
		
	

3. 参数处理

3.1 单个参数/多个参数/命名参数

? 在mapper配置文件中，在将接口方法与CRUD标签进行映射的时候，需要使用接口方法中的参数作为sql语句查询的条件。MyBatis对于单个参数和多个参数有着不一样的处理：

? 单个参数：

? MyBatis不会做特殊处理，

? #{参数名/任意名}：取出参数值。

? 多个参数：

? Mybatis会做特殊处理。

? 多个参数会被封装成 一个map，规则如下：

? key：param1...paramN，或者参数的索引也可以

? value：传入的参数值

? #{}就是从map中获取指定的key的值；

异常：
org.apache.ibatis.binding.BindingException: 
Parameter 'id' not found. 
Available parameters are [1, 0, param1, param2]

错误操作：
	方法：public Employee getEmpByIdAndLastName(Integer id,String lastName);
	取值：#{id}, #{lastName} （正确取值操作：#{param1}, #{param2}）

? 命名参数：

? 明确指定封装参数时map的key；在接口方法中使用@Param注解；@Param("id")

? 多个参数会被封装成 一个map，

? key：使用@Param注解指定的值

? value：参数值

? #{指定的key}取出对应的参数值，如 #{id}， #{lastName}

Long deleteEmp(@Param("id") Integer id, @Param("name") String name)

3.2 POJO/Map/TO

? POJO：

? 如果多个参数正好是我们业务逻辑的数据模型，我们就可以直接传入pojo；

? #{属性名}：取出传入的pojo的属性值

? 就像上文中测试，因为数据参数传入的是一个实例对象，就可以直接使用属性值来获取值。

? Map：

? 如果多个参数不是业务模型中的数据，没有对应的pojo，不经常使用，为了方便，我们也可以传入map

? #{key}：取出map中对应的值

? 示例：

? TO：
? 如果多个参数不是业务模型中的数据，但是经常要使用，推荐来编写一个TO（Transfer Object）数据传输对象：

? Page{
? int index;
? int size;
? }

3.3 MyBatis的参数封装（源码理解）

? MyBatis如何处理参数的：

? 底层调用的sqlSession对象的一些增删改查的API

? 总结：参数多的时候，MyBatis会封装map，但为了不混乱，我们可以使用@Param来指定封

装时使用的key；

? #{key}就可以取出map中的值；

? (@Param("id")Integer id,@Param("lastName")String lastName);

ParamNameResolver解析参数封装map的：

? 该类有参构造器：

/**  names参数的确定流程：

        1.获取每一个被@Param注解修饰的参数的值，如：id，lastName的值，并赋值给name;
        
		2.每次解析一个参数给map中保存信息：（key：参数索引，value：name的值）
    		name的值要分两种情况：
    			第一种：标注了param注解，那么name的值就是注解指定的值。
    			第二种：没有标注（下面代码）
            		1.全局配置：useActualParamName（jdk1.8）：name=参数名
					2.name=map.size()；相当于当前元素的索引，所以最终保存形式如下：
    					{0=id, 1=lastName,2=2}
*/

    public ParamNameResolver(Configuration config, Method method) {
        ................
                if (name == null) {
                    if (config.isUseActualParamName()) { // 全局配置过没有？
                        name = this.getActualParamName(method, paramIndex);
                    }

                    if (name == null) {
                        name = String.valueOf(map.size());
                    }
                }

                map.put(paramIndex, name);
            }
        }

        this.names = Collections.unmodifiableSortedMap(map);
    }

? getNamedParams()方法：对args参数，用map类型进行封装

? 在遍历names集合的时候，进行了两次封装:

? 第一次封装：使得用户可以使用指定的key去获取参数，往往是用@Param进行修饰的，满足用户自定义param的需求。

? 第二次封装：是使用MyBatis提供的一种默认的方式，通过#{param1...paramN}这种方式进行参数值的获取。

// args传的参数：args[1，"Tom",'hello']
public Object getNamedParams(Object[] args) {
    final int paramCount = names.size(); 
    //1、参数为null直接返回
    if (args == null || paramCount == 0) {
      return null;
     
    //2、如果只有一个元素，并且没有Param注解；args[0]：单个参数直接返回
    } else if (!hasParamAnnotation && paramCount == 1) {
      return args[names.firstKey()];
      
    //3、多个元素或者有Param标注
    } else {
      final Map param = new ParamMap