Mybatis之编程式开发

2.MyBatis 编程式开发

2.1.开发步骤

2.1.1.mybatis和MySQL jar包依赖

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

2.1.2、全局配置文件mybatis-config.xml

<?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>

    <properties resource="db.properties"></properties>
    <settings>
        <!-- 打印查询语句 -->
        <setting name="logImpl" value="STDOUT_LOGGING" />

        <!-- 控制全局缓存（二级缓存）-->
        <setting name="cacheEnabled" value="true"/>

        <!-- 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。默认 false  -->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!-- 当开启时，任何方法的调用都会加载该对象的所有属性。默认 false，可通过select标签的 fetchType来覆盖-->
        <setting name="aggressiveLazyLoading" value="false"/>
        <!--  Mybatis 创建具有延迟加载能力的对象所用到的代理工具，默认JAVASSIST -->
        <!--<setting name="proxyFactory" value="CGLIB" />-->
        <!-- STATEMENT级别的缓存，使一级缓存，只针对当前执行的这一statement有效 -->
        <!--
                <setting name="localCacheScope" value="STATEMENT"/>
        -->
        <setting name="localCacheScope" value="SESSION"/>
    </settings>

    <typeAliases>
        <typeAlias alias="blog" type="com.ggaoxinfu.domain.Blog" />
    </typeAliases>
    
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/><!-- 单独使用时配置成MANAGED没有事务 -->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="BlogMapper.xml"/>
        <mapper resource="BlogMapperExt.xml"/>
    </mappers>

</configuration>

2.1.3.映射器 Mapper.xml

SQL的xml文件

2.1.4.Mapper接口

主要是每一张表的Mapper接口

2.2.MyBatis核心对象及其作用域

String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

SqlSession session = sqlSessionFactory.openSession();
try {
   Blog blog = (Blog) session.selectOne("com.gaoxinfu.mapper.BlogMapper.selectBlogById", 1);
   System.out.println(blog);
} finally {
   session.close();
}

Mapper（实际上是一个代理对象）是从 SqlSession 中获取的。
BlogMapper mapper = session.getMapper(BlogMapper.class)

2.3.MyBatis配置文件

参考官网
http://www.mybatis.org/mybatis-3/zh/getting-started.html

2.3.1.全局配置文件-mybatis-config.xml

2.3.1.1.configuration节点

源码代码:处理Xml文件中的一级标签如properties setttings等等标签

org.apache.ibatis.session.Configuration

配置文件

2.3.1.2.属性（properties）

http://www.mybatis.org/mybatis-3/zh/configuration.html#properties

2.3.1.3.设置（settings）

2.3.1.4.类型别名（typeAliases）

org.apache.ibatis.type.TypeAliasRegistry

<typeAliases>
  <typeAlias alias="blog" type="com.gapxinfu.domain.Blog" />
</typeAliases>

2.3.1.5.类型处理器（typeHandlers）

1.解决的问题主要是Java 类型和数据库的 JDBC 类型的对应

2.对应的默认类处理 org.apache.ibatis.type.TypeHandlerRegistry

如上MyBatis 已经内置了很多 TypeHandler（在 type 包下）[如:StringTypeHandler,ClobTypeHandler等你等]，
它们全部注册在 TypeHandlerRegistry中，他们都继承了抽象类 BaseTypeHandler，
泛型就是要处理的Java数据类型呢

StringTypeHandler源码举例

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.type;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class StringTypeHandler extends BaseTypeHandler<String> {
    public StringTypeHandler() {
    }
	//setNonNullParameter： 设置非空参数
    public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException {
        ps.setString(i, parameter);
    }
	//获取空结果集（根据列名）， 一般都是调用这个
    public String getNullableResult(ResultSet rs, String columnName) throws SQLException {
        return rs.getString(columnName);
    }
	//获取空结果集（根据下标值）
    public String getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        return rs.getString(columnIndex);
    }
	//获取空结果集 存储过程用的
    public String getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        return cs.getString(columnIndex);
    }
}

2.3.1.5.1 自己配置一个typeHandler

比如我们想要在获取或者设置 String 类型的时候做一些特殊处理，
我们可以写一个String 类型的 TypeHandler

package com.gaoxinfu.type;

import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedJdbcTypes;
import org.apache.ibatis.type.MappedTypes;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class MyTypeHandler extends BaseTypeHandler<String> {
    public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType)
            throws SQLException {
        // 设置 String 类型的参数的时候调用，Java类型到JDBC类型
        // 注意只有在字段上添加typeHandler属性才会生效
        // insertBlog name字段
        System.out.println("---------------setNonNullParameter1："+parameter);
        ps.setString(i, parameter);
    }

    public String getNullableResult(ResultSet rs, String columnName) throws SQLException {
        // 根据列名获取 String 类型的参数的时候调用，JDBC类型到java类型
        // 注意只有在字段上添加typeHandler属性才会生效
        System.out.println("---------------getNullableResult1："+columnName);
        return rs.getString(columnName);
    }

    public String getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        // 根据下标获取 String 类型的参数的时候调用
        System.out.println("---------------getNullableResult2："+columnIndex);
        return rs.getString(columnIndex);
    }

    public String getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        System.out.println("---------------getNullableResult3：");
        return cs.getString(columnIndex);
    }
}

配置如下

<typeHandlers>
	<typeHandler handler="com.gupaoedu.type.MyTypeHandler"></typeHandler>
</typeHandlers>

查询应用:JDBC到JAVA类型

插入应用:JAVA类型到JDBC类型

2.3.1.6.对象工厂（objectFactory）

1.主要是对数据库查询结果每个对象的处理

1.默认的对象工厂:org.apache.ibatis.reflection.factory.DefaultObjectFactory

工厂类的接口:ObjectFactory

package org.apache.ibatis.reflection.factory;

import java.util.List;
import java.util.Properties;

/**
 * MyBatis uses an ObjectFactory to create all needed new Objects.
 *
 * @author Clinton Begin
 */
public interface ObjectFactory {

  /**
   * Sets configuration properties.
   * @param properties configuration properties
   */
   //设置参数时调用
  void setProperties(Properties properties);

  /**
   * Creates a new object with default constructor.
   * @param type Object type
   * @return
   */
   //创建对象（调用无参构造函数）
  <T> T create(Class<T> type);

  /**
   * Creates a new object with the specified constructor and params.
   * @param type Object type
   * @param constructorArgTypes Constructor argument types
   * @param constructorArgs Constructor argument values
   * @return
   */
   //创建对象（调用带参数构造函数）
  <T> T create(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs);

  /**
   * Returns true if this object can have a set of other objects.
   * It's main purpose is to support non-java.util.Collection objects like Scala collections.
   *
   * @param type Object type
   * @return whether it is a collection or not
   * @since 3.1.0
   */
   //判断是否集合
  <T> boolean isCollection(Class<T> type);

}

应用举例

public class MyObjectFactory extends DefaultObjectFactory {
    @Override
    public Object create(Class type) {
        System.out.println("创建对象方法：" + type);
        if (type.equals(Blog.class)) {
            Blog blog = (Blog) super.create(type);
            blog.setName("object factory");
            blog.setBid(1111*100);
            blog.setAuthorId(2222);
            return blog;
        }
        Object result = super.create(type);
        return result;
    }
}

<!-- mybatis-config.xml -->
<objectFactory type="org.mybatis.gaoxinfu.MyObjectFactory ">
  <property name="someProperty" value="100"/>
</objectFactory>

2.3.2.核心配置文件-Mapper.xml

2.3.2.1.动态SQL

http://www.mybatis.org/mybatis-3/zh/dynamic-sql.html

<if>
<choose> (<when>,<otherwise>)
<trim> (<where>,<set>)
<foreach>

2.3.2.2.批量操作[插入 删除 更新]

mybatis操作数据库,默认最大4M数据包

1.把所有的循环的,弄成一次插入或者删除,可以减少数据库的交互次数;
2.但是数据量太大,不太好,因为数据库操作,数据包最大4M,ping接的太大,可能会报错;

样例

insert into tbl_emp (emp_id, emp_name, gender,email, d_id) values ( ?,?,?,?,? ) , ( ?,?,?,?,? ) , ( ?,?,?,?,? ) , ( ?,?,?,?,? ) ,
( ?,?,?,?,? ) , ( ?,?,?,?,? ) , ( ?,?,?,?,? ) , ( ?,?,?,?,? ) , ( ?,?,?,?,? ) , ( ?,?,?,?,? );

delete from tbl_emp where emp_id in (?,?,?,?);

    @Test
    public void testJdbcBatch() throws IOException {
        Connection conn = null;
        //支持预编译和缓存  PreparedStatement.addBatch()添加批次,批量执行  PreparedStatement.executeBatch();
        PreparedStatement ps = null;

        try {
            // 注册 JDBC 驱动
            Class.forName("com.mysql.jdbc.Driver");

            // 打开连接
            conn = DriverManager.getConnection(
                    "jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&rewriteBatchedStatements=true",
                    "root",
                    "root");
            ps = conn.prepareStatement(
                    "INSERT into blog values (?, ?, ?)");

            for (int i = 1000; i < 101000; i++) {
                Blog blog = new Blog();
                ps.setInt(1, i);
                ps.setString(2, String.valueOf(i));
                ps.setInt(3, 1001);
                ps.addBatch();
            }

            ps.executeBatch();
            // conn.commit();
            ps.close();
            conn.close();
        } catch (SQLException se) {
            se.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (ps != null) ps.close();
            } catch (SQLException se2) {
            }
            try {
                if (conn != null) conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
        }
    }

Batch Executor
底层和上面的PreparedStatement批量执行原理一样

SIMPLE 对应Statement
REUSE 对应PreparedStatement