MyBatis框架

MyBatis框架

创建项目 在eclipse中 file other dynamic
那些核心配置文件啥的 需要新建一个resource folder 放在这里
使用教程：
https://mybatis.org/mybatis-3/zh/getting-started.html

**框架阶段：**基础阶段 -> 应用阶段

需要背的东西(不要去死记硬背，根据以前学的内容理解去记忆)比较多！

kgcnews：JSP + Servlet + DAO模式(映射)

// Servlet中目前是大量的多重if语句 opr来进行控制处理
// 接收到的参数都是字符串类型，每次都要进行相应转换
// 跳转页面，转发：request.getRe.......

// 添加
String sql = "insert into .....?,?,？";
Object[] param = { 
   xx,xx,xx};

// 查询
String sql = "select xx,xxx,xx from xxx";
while(rs.next()){ 
   
    rs.getXX();
}

1. 框架技术的介绍

1.1 框架技术的优点

框架是一个应用程序的半成品，提供可重用的公共结构，按一定规则组织的一组组件。

如果要编写一个PPT或者简历，使用模板有如下的优点。

1. 不用考虑布局、排版等，提高效率；

2. 可专心在简历内容上；

3. 结构统一，便于人事阅读；

4. 新手也可以作出专业的简历。

反之我们开发中，如果使用框架也是可以有类似于上方的这些优点。

• 不用考虑性能和扩展性等方面的问题，提高效率；
• 可以专心在项目应用业务上，而非环境和系统设计上；
• 项目结构统一，便于团队开发！
• 新手也可以开发出专业的项目。

1.2 主流后台开发框架(三层架构)

Spring Boot

**表现层：**Struts2、Spring MVC

**业务逻辑层：**Spring

**数据访问层：**Hibernate、MyBatis、Spring Data

S(Spring MVC)S(Spring)M(MyBatis)

S(Struts2)S(Spring)H(Hibernate)

不要学成墨守成规的书呆子，这些框架并非一定要按照上方的形式组合，它们都是独立的框架，你项目需求是什么样的，就根据情况去进行技术选型(架构师)。

2. MyBatis框架的介绍

2.1 数据持久化的概念和ORM原理

ORM：(Object Relational Mapping)对象关系映射 思想

**主要内容：**在编写程序的时候，使用面向对象的思想来进行数据使用，而在数据存储的时候，使用关系型数据库来进行存储。

【数据库表】   ->  【Java类】
  表字段      ->     类属性
一条条数据     ->    类的对象

在程序运行过程中，内存中的瞬时态数据会和持久态的数据进行转换，瞬时态 -> 持久态 (数据持久化)，这个时候存储数据的对象我们称之为持久化对象。

ORM的组成如下：

• 在持久化对象上执行基本的增、删、改、查操作

• 对持久化对象提供一种查询语言或者API

• 对象关系映射工具

• 提供与事务对象交互、执行检查、延迟加载以及其他优化功能

2.2 MyBatis的概念

ibatis -> mybatis

Apache的产品，都是在Apache开源社区上开源的，近几年产品开始在各个开源平台公开开源。

2010年，它被迁移到了Google Code开源平台，被改名了。

2013年，又从Google Code迁移到了GitHub开源平台。

MyBatis SQL映射器框架使关系数据库与面向对象的应用程序的使用变得更加容易。 MyBatis使用XML描述符或注释将对象与存储过程或SQL语句结合在一起。简单性是MyBatis数据映射器相对于对象关系映射工具的最大优势。

它是一个半自动的ORM框架，它不再是直接将对象和表进行映射，而是将对象和SQL语句进行映射。

全自动的ORM框架：对象 <-> 数据表(对象怎么变，数据表跟着变<SQL不用写>)

半自动ORM，MyBatis ： 保证灵活性 对象 <- SQL语句 -> 数据表

2.3 MyBatis环境搭建

官方使用说明书：http://www.mybatis.org/mybatis-3/zh/index.html

• 下载：https://github.com/mybatis/mybatis-3/releases

• 导包 （还要导入MySQL的JDBC驱动）

• 编写核心配置文件(XML)，用于SqlSessionFactory实例的产生

• “http://mybatis.org/dtd/mybatis-3-config.dtd”复制网址打开进行下载 自己随便保存位置

  因为在线约束网络影响比较大，可以配置本地约束。
  里面的标签是有顺序的 选中configuration以后就可以看到

配置本地约束 如果你选择的是http:
key type为URI

传统方式的配置文件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>
	<!-- 配置环境信息 default：表示采用的环境的id -->
	<environments default="mysql-env">
		<environment id="mysql-env">
			<!-- 事务管理器 -->
				<!-- 使用原生JDBC事务 type属性可取值 JDBC ：jdbc的原生事务处理属性 MANAGED:把事务转交给其他容器 原生JDBC事务被标上setAutoMapping（flase） -->
			<transactionManager type="JDBC"/>
			<!-- 数据源连接池配置 -->
				<!-- 连接池设置 type属性可取值 UNPOOLED 不使用数据库连接池 POOLED 使用数据库连接池 JNDI java本地目录命名接口 是用java调用其他语言资源 -->
			<dataSource type="POOLED">
				<property name="driver" value="com.mysql.jdbc.Driver"/>
				<property name="url" value="jdbc:mysql:///smbms"/>
				<property name="username" value="root"/>
				<property name="password" value="root"/>
			</dataSource>
		</environment>
		<!-- <environment id="oracle-env"></environment> -->
	</environments>
    <!-- 加载SQL映射器 resource后面 也是复制全类名 复制以后src前面的去掉 不包括src 可以点过去 -->
	<mappers>
	
		<mapper resource="cn/dao/UserMapper.xml"/>
	</mappers>
</configuration>

• 编写POJO

  /** * 用户POJO(Plain Ordinary Java Objects) 简单的Java对象 它类似于你的实体类entity * @author Charles7c * 2019年7月22日 上午10:16:11 */
  public class User implements Serializable { 
       
  
  	private static final long serialVersionUID = 1L;
  	
  	private Long id;
  	private String userCode;
  	private String userName;
  	private String userPassword;
  	private int gender;
  	private Date birthday;
  	private String phone;
  	private String address;
  	private Long userRole;
  	private Long createdBy;
  	private Date creationDate;
  	private Long modifyBy;
  	private Date modifyDate;
  	private String idPicPath;
  	// 省略...
  }
  

• 编写SQL映射(SQL Mapper)文件(MyBatis是一个半自动的ORM，SQL语句和对象映射)

  编写SQL语句和对象的映射联系的。也可以配置本地约束 和上面一样

  <?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：命名空间 用来【唯一】标识此Mapper文件的(mapper文件的id) 传统方式开发，namespace值随便起，但是必须保证唯一；接口方式开发，他必须为 Mapper.xml的namespace和接口的全类名一致 -->
  <mapper namespace="userMapper">
  
  	<!-- 用来执行查询语句和对象的映射的 id：相当于dao代码中的一个接口方法 使用的时候需要通过mapper的命名空间结合使用 userMapper.xxxx public List<User> getUserList()throws Exception; resultType：结果类型(返回值类型) -->
  	<select id="getUserList" resultType="cn.kgc.smbms.pojo.User">
  		select 
  			*
  		from 
  			smbms_user
  	</select>
  	
  </mapper>
  

集合的返回值的类型为他的泛型 全类名

• 构建SqlSessionFactory实例来进行运行

读取xml文件构造方式

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

`

// 从classpath路径加载刚才配置的核心配置文件 将其内容读取出来 用于构建SqlSessionFactory实例
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

// SqlSessionFactory产生SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();
// 执行对应的SQL映射语句 sql映射文件里面的namespace的名字.方法名
List<User> userList  = sqlSession.selectList("userMapper.getUserList");

// 遍历
for (User user : userList) { 
   
	System.out.println(user);
}

// 关流
sqlSession.close();

### 设置Logger输出级别和输出目的地（可以指定多个目的地） ###
### 一般在开发的时候使用debug，开发完成后使用error ###
### 他们对应的是输出信息的级别，级别越低信息输出越详细，使用debug级别的时候，info中的信息也能输出，使用info的时候，debug对应的信息显示不出来 ###
### 日志记录器输出级别：fatal>error>warn>info>debug ###
### 后面的两个对应下方的两处 一处打印在控制台 另一处打印在日志文件里
log4j.rootLogger=debug,console,logFile

#############################################################################################
### 把日志信息输出到控制台 ###
log4j.appender.console=org.apache.log4j.ConsoleAppender
### 信息打印到System.err上，红色 ###
log4j.appender.console.Target=System.out
### 指定日志在控制台上输出的布局类型  采用指定格式的类型 ###
log4j.appender.console.layout=org.apache.log4j.PatternLayout
### %r:输出自应用启动到输出该 log信息耗费的毫秒数    %x表示信息输出时左对齐 
### %5p:%p表示输出日志信息优先级，即 DEBUG， INFO， WARN， ERROR， FATAL 中间的5控制最小的宽度为5
### %F:%L %F:输出日志消息产生时所在的文件名称   %L:输出代码中的行号
### %l:输出日志事件的发生位置，相当于%C.%M(%F:%L)的组合,包括类目名、发生的线程，以及行数
### %m:输出代码中指定的消息,产生的日志具体信息  %n:输出一个回车换行符， Windows 平台为"\r\n"， Unix 平台为"\n"输出日志信息换行
log4j.appender.console.layout.ConversionPattern= (%r ms) - %d{ 
   yyyy-M-d HH:mm:ss}%x[%5p](%F:%L) %m%n
#############################################################################################

#############################################################################################
### 把日志信息输出到文件：jbit.log 注意：如果有路径\符号一定要写成\\ 否则会被转义  ###
log4j.appender.logFile=org.apache.log4j.FileAppender
### 指定日志输出的文件名 ###
log4j.appender.logFile.File=${ 
   catalina.home}/logs/smbms.log
### 指定转换模式 ###
log4j.appender.logFile.layout=org.apache.log4j.PatternLayout
### 指定日志布局类型 ###
###log4j.appender.logFile.layout.ConversionPattern=%d{ 
   yyyy-MM-dd HH:mm:ss}%l %F %p %m%n
###log4j.appender.logFile.layout.ConversionPattern= -> (%r ms) - %d{ 
   yyyy-M-d HH:mm:ss}%x[%5p](%F:%L) %m%n
log4j.appender.logFile.layout.ConversionPattern= (%r ms) - %d{ 
   yyyy-MM-dd HH:mm:ss}%x[%5p]%l %m%n
#############################################################################################

运行时提示log4j 因为缺乏日志的配置

mybatis的数据库的字段属性必须和实体类一致

传统方式开发 图中右侧 xml文件 #里面的内容（与数据库里面的字段属性名保持一致，也要与）传入的对象属性名一致，当传入的参数为对象时，
使用junit进行测试

2.4 MyBatis和JDBC的区别和联系

优点和缺点：【面试题】

优点：

• 与JDBC相比，减少了50%以上的代码量 (映射方面的代码量)
• 最简单的持久化框架，小巧并简单易学
• SQL代码从程序代码中彻底分离，可重用
• 提供XML标签，支持编写动态SQL(后期知识点 以前有条件参数可能非必填 那么一堆的if语句可以通过动态SQL优化)
• 提供映射标签，支持对象与数据库的ORM字段映射
• MyBatis因为是面向SQL的映射，所以灵活性比较高，SQL的性能也由我们自己来决定。

缺点：

• SQL语句编写工作量大，对开发人员有一定要求
• 数据库移植性差（假设现在数据库更换为了Oracle，SQL语句不一致，那么就需要再编写另一套SQL映射文件）

3. MyBatis的组件介绍

3.1 MyBatis核心API

SqlSessionFactoryBuilder：是 MyBatis 中应用构建者模式的一个类，用于读取核心配置文件内容构建SqlSessionFactory。
它的生命周期：用完即丢。

以下是它的常用方法：
• build(InputStream inputStream) : SqlSessionFactory 通过字节输入流构建
• build(Reader reader) : SqlSessionFactory 通过字符输入流构建
• build(Configuration config) : SqlSessionFactory 通过Configuration构建
• …
因为 SqlSessionFactory 对象构建需要的配置参数很多，且不能保证每个参数都是正确的或者不能一次性得到构建所需的所有参数（有些参数是初始化时需要的，如数据源配置，延迟加载配置，事务配置等，有些是框架运行过程中需要的，如SQL映射等[1]），所以不能采用简单的 new 方式来创建对象。

SqlSessionFactory：它是SQL会话工厂，用于产生和数据库的会话对象sqlSession。
以下是它的常用方法：
• openSession() : SqlSession 获取 SqlSession对象
该方法是我们最常用的方法，同时也是开启事务处理的（参见下方源码）
• openSession(boolean autoCommit) : SqlSession 获取SqlSession对象，自行指定是否开启事务
autoCommit 参数是用来指定是否开启自动提交的
如果 autoCommit 的值为 true，代表关闭事务处理。反之，代表开启事务处理

// DefaultSqlSessionFactory 是 SqlSessionFactory的实现类
public class DefaultSqlSessionFactory implements SqlSessionFactory { 
   
    // ...
    @Override
    public SqlSession openSession() { 
   
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
    }
    @Override
    public SqlSession openSession(boolean autoCommit) { 
   
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, autoCommit);
    }
    // ...
}

它的生命周期：全局，每一个MyBatis应用都有且仅有一个SqlSessionFactory实例(单例：单个实例)，它对应的就是一个environment环境。

使用单例模式优化此API：

【面试题】**单例模式：**在运行期间，单例类有且仅有一个实例向外提供！你在任何地方获取一个类的对象，它们都是同一个。

单例模式的组成：

• 私有化构造器(防止外部使用构造器创建对象)
• 提供静态的单例类实例变量(静态的信息只会随着类加载而加载，且被所有对象共享)
• 提供一个公共的静态的获取唯一实例的方法(给系统外部提供的接口)

/** * 单例类-懒汉(饱汉)模式 * @author Charles7c * 2019年7月22日 上午11:28:06 */
public class Singleton { 
   

	// 私有化构造
	private Singleton() { 
   }
	
	// 提供静态的实例变量
	private static Singleton singleton;
	
	// 提供一个公共的静态的获取唯一的实例的方法
	public static Singleton getInstance() { 
   
		// 懒汉模式 当有人需要唯一实例时才开始创建
		if(singleton == null) { 
   
			singleton = new Singleton();
		}
		return singleton;
	}
}

/** * 单例类-饿汉模式 * @author Charles7c * 2019年7月22日 上午11:28:06 */
public class Singleton2 { 
   

	// 私有化构造
	private Singleton2() { 
   }
	
	// 提供静态的实例变量 饿汉模式在类加载时就进行对象的初始化
	private static Singleton2 singleton = new Singleton2();
	
	// 提供一个公共的静态的获取唯一的实例的方法
	public static Singleton2 getInstance() { 
   
		return singleton;
	}
}

懒汉模式和饿汉模式的区别：

• 懒汉模式在类加载时不会进行唯一实例的初始化，在获取时才进行初始化，所以空间浪费比较小。

  饿汉模式在类加载时就会初始化，所以占用空间！

• 懒汉模式因为获取时需要判断然后初始化，所以效率比较低。

  饿汉模式，在后期获取实例比较快。

• 懒汉模式有线程安全问题。

  饿汉模式没有线程安全问题。

SqlSession 核心会话对象，SqlSession 是 MyBatis 执行持久化操作的关键对象，类似于 JDBC 中的 Connection。 SqlSession 对象包含了执行 SQL 所需的所有方法 ，它的底层封装了 JDBC 连接，可以用 SqlSession 实例来直接执行被映射的 SQL 语句。

以下是它的常用方法：
•insert(String statement, Object parameter) : int 增加操作
•delete(String statement, Object parameter) : int 删除操作
•update(String statement, Object parameter) : int 修改操作
•selectOne(String statement) : T 单个查询
•selectOne(String statement, Object parameter) : T 带参数单个查询
•selectList(String statement) : List 集合查询
•selectList(String statement, Object parameter) : List 带参数集合查询
•commit() : void 提交事务
•rollback() : void 回滚事务
•getMapper(Class type) : T 获取Mapper接口（Mapper接口开发）
•…

它的生命周期：线程(Thread)级别的，一次请求对应一个SqlSession！
每个线程都应该有它自己的 SqlSession 实例， SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的HttpSession。如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。[2] 使用完 SqlSeesion 之后一定记得关闭，可以采用 finally 块或 try-with-resources 。在 SqlSession 里可以执行多次 SQL 语句，但一旦关闭了 SqlSession 就需要重新创建。

List<User> userList = sqlSession.selectList("usermapper1.getUserList");

• SqlSession实例应用1：直接操作映射文件

…

• SqlSession实例应用2：Mapper接口开发【推荐采用】：

  • 创建Mapper接口

  • 将Mapper.xml和接口进行绑定（binding）

    • Mapper.xml的namespace和接口的全类名一致
    • xml中的SQL语句等信息要和接口中保持对应
    • Mapper接口和XML同名同包

  • 将Mapper接口引入到核心配置文件[ 接口的全类名

<mappers>
          <mapper class="cn.dao.UserMapper"/>
  	</mappers>

• 使用API操作
  

```java
SqlSession sqlSession = null;
try {
    sqlSession = MyBatisUtils.getSqlSession();

    // 获取Mapper接口
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    List<User> userList = userMapper.getUserList();
    for (User user : userList) {
        System.out.println(user);
    }

    sqlSession.commit();
} catch (Exception e) {
    e.printStackTrace();
    sqlSession.rollback();
}finally {
    MyBatisUtils.closeSqlSession(sqlSession);
}
```

接口开发的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标签 实现动态引入properties配置文件信息 -->
	<properties resource="db.properties"></properties>


	<typeAliases>
		<package name="cn.pojo" />
	</typeAliases>
	
	<!-- 配置MyBatis运行环境 可以准备多套 但是 只能同时运行一个(必须配置一个默认的) -->
	<environments default="default">
		<environment id="default">
			<!-- 事务管理 JDBC -->
			<transactionManager type="JDBC" />
			<!-- 配置数据源(type属性可以配置数据源是否采用池技术) -->
			<dataSource type="POOLED">
				<property name="driver" value="${mysql.driver}" />
				<property name="url" value="${mysql.url}" />
				<property name="username" value="${mysql.username}" />
				<property name="password" value="${mysql.password}" />
			</dataSource>

		</environment>
	</environments>

	<!-- 引入映射文件 路径是可以点过去的 -->
	<mappers>
		<package name="cn.dao"/>
	</mappers>
</configuration>

3.2 MyBatis核心配置文件

他的配置是有顺序的 鼠标放在configuration上面 有顺序

• properties（属性）：
  第一种 1.在内部编写

<?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>
        <property name="mysql.driver" value="com.mysql.jdbc.Driver"/>
        <property name="mysql.url" value="jdbc:mysql://localhost:3306/mybatis_demo_db"/>
        <property name="mysql.username" value="root"/>
        <property name="mysql.password" value="root"/>
        <property name="txType" value="JDBC"/>
    </properties>
    <!-- ...略... -->
    <environments default="develop">
        <!-- 单个环境配置 -->
        <environment id="develop">
            <!-- 事务管理配置 -->
            <transactionManager type="${txType}"/>
            <!-- 数据源配置 -->
            <dataSource type="POOLED">
                <property name="driver" value="${mysql.driver}"/>
                <property name="url" value="${mysql.url}"/>
                <property name="username" value="${mysql.username}"/>
                <property name="password" value="${mysql.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!-- ...略... -->
</configuration>

第二种：2.引入外部数据源文件(方便整个项目内的复用性和配置集中)
db.properties

mysql.driver=com.mysql.jdbc.Driver
mysql.url=jdbc:mysql:///smbms
mysql.username=root
mysql.password=root

在核心配置文件中

  <?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"/>
    <!-- ...略... -->
    <environments default="develop">
        <!-- 单个环境配置 -->
        <environment id="develop">
            <!-- 事务管理配置 -->
            <transactionManager type="JDBC"/>
            <!-- 数据源配置 -->
            <dataSource type="POOLED">
                <property name="driver" value="${mysql.driver}"/>
                <property name="url" value="${mysql.url}"/>
                <property name="username" value="${mysql.username}"/>
                <property name="password" value="${mysql.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!-- ...略... -->
</configuration>

• settings（后面介绍）：

• typeAliases（类型别名）：

  类型别名是为 Java 类型设置一个短的名字。
  它只和 XML 配置有关，存在的意义仅在于用来减少类完全限定名的冗余。
  两种：package name=”” 或者typeAlias type=””(不推荐)

  <typeAliases>
  		<!-- 此包和子包下的类都会被自动编写别名 不区分大小写 在xx.xml中 resultType就可以直接写成UsEr 不区分大小写 pojo下有类 user-->
  		<package name="cn.kgc.smbms.pojo"/>
  		<!-- type：全限定名 alias：别名 在xx.xml中 resultType就可以直接写成User -->
  		<!-- <typeAlias type="cn.kgc.smbms.pojo.User" alias="User"/> -->
  		<!-- <typeAlias type="cn.kgc.smbms.pojo.User" alias="user"/> <typeAlias type="cn.kgc.smbms.pojo.User" alias="User"/> -->
  </typeAliases>
  

  现在：以前写法：
  
  在 MyBatis 中有一个类 TypeAliasRegistry ，它的作用就是进行类型别名注册和解析，Java 中常见的类型都已经被它注册好了别名。

package org.apache.ibatis.type;
// ...略...
public class TypeAliasRegistry { 
   
   /** Map<类型别名, 对应类型的Class对象> */
   private final Map<String, Class<?>> typeAliases = new HashMap<>();
   /** 在创建对象时进行常用 Java 类型的别名注册 */
   public TypeAliasRegistry() { 
   
        // String 类型注册的别名为 string 
        registerAlias("string", String.class);

        registerAlias("byte", Byte.class);
        registerAlias("long", Long.class);
        registerAlias("short", Short.class);
        registerAlias("int", Integer.class);
        registerAlias("integer", Integer.class);
        registerAlias("double", Double.class);
        registerAlias("float", Float.class);
        registerAlias("boolean", Boolean.class);

        registerAlias("byte[]", Byte[].class);
        registerAlias("long[]", Long[].class);
        registerAlias("short[]", Short[].class);
        registerAlias("int[]", Integer[].class);
        registerAlias("integer[]", Integer[].class);
        registerAlias("double[]", Double[].class);
        registerAlias("float[]", Float[].class);
        registerAlias("boolean[]", Boolean[].class);

        registerAlias("_byte", byte.class);
        registerAlias("_long", long.class);
        registerAlias("_short", short.class);
        registerAlias("_int", int.class);
        registerAlias("_integer", int.class);
        registerAlias("_double", double.class);
        registerAlias("_float", float.class);
        registerAlias("_boolean", boolean.class);

        registerAlias("_byte[]", byte[].class);
        registerAlias("_long[]", long[].class);
        registerAlias("_short[]", short[].class);
        registerAlias("_int[]", int[].class);
        registerAlias("_integer[]", int[].class);
        registerAlias("_double[]", double[].class);
        registerAlias("_float[]", float[].class);
        registerAlias("_boolean[]", boolean[].class);

        registerAlias("date", Date.class);
        registerAlias("decimal", BigDecimal.class);
        registerAlias("bigdecimal", BigDecimal.class);
        registerAlias("biginteger", BigInteger.class);
        registerAlias("object", Object.class);

        registerAlias("date[]", Date[].class);
        registerAlias("decimal[]", BigDecimal[].class);
        registerAlias("bigdecimal[]", BigDecimal[].class);
        registerAlias("biginteger[]", BigInteger[].class);
        registerAlias("object[]", Object[].class);

        registerAlias("map", Map.class);
        registerAlias("hashmap", HashMap.class);
        registerAlias("list", List.class);
        registerAlias("arraylist", ArrayList.class);
        registerAlias("collection", Collection.class);
        registerAlias("iterator", Iterator.class);

        registerAlias("ResultSet", ResultSet.class);
   }

   /** * 解析别名 * @param string 要解析的别名 * @return 该别名对应的类型的Class对象 */
    public <T> Class<T> resolveAlias(String string) { 
   
        try { 
   
            if (string == null) { 
   
                return null;
            }
            // 查老师有话说：MyBatis 在【别名自动配置】和【解析映射文件中别名】时，对别名进行了小写转换。
            // 所以在使用别名的时候才不区分大小写。
            String key = string.toLowerCase(Locale.ENGLISH);
            Class<T> value;
            if (typeAliases.containsKey(key)) { 
   
                value = (Class<T>) typeAliases.get(key);
            } else { 
   
                value = (Class<T>) Resources.classForName(string);
            }
            return value;
        } catch (ClassNotFoundException e) { 
   
            throw new TypeException("Could not resolve type alias '" + string + "'. Cause: " + e, e);
        }
    }
    // ...略...
}

• environments（环境配置）：

  MyBatis 可以配置成适应多种环境，开发、测试和生产环境
  尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。

• mappers（映射器）：

• 第一种和第二种，它适合于传统的开发；第三种第四种专门用于接口的开发

  

今天的文章MyBatis框架分享到此就结束了，感谢您的阅读。