前面我们看到的Mybatis全局文件并没有全部列举出来,所以这一章我们来详细的介绍一遍,Mybatis的全局配置文件并不是很复杂,它的所有元素和代码如下所示:
DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<properties/>
<settings/>
<typeAliases/>
<typeHandlers/>
<objectFactory/>
<plugins/>
<environments default="">
<environment id="">
<transactionManager type=""/>
<dataSource type=""/>
environment>
environments>
<databaseIdProvider type=""/>
<mappers/>
configuration>
注意:Mybatis的配置文件的顺序是严格按照从上至下的顺序声明,不颠倒顺序,如果颠倒了它们的顺序,那么Mybatis在启动阶段就会产生异常,导致程序无法运行
properties 的作用是引用java属性文件中的配置信息,比如:加载连接数据库的各种属性的配置文件。
mybatis提供了三种方式使用properties属性:
以上一章的例子为基础,使用property子元素将数据库的连接配置信息进行改写,如下所示:
DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<properties>
<property name="database.driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="database.url" value="jdbc:mysql://localhost:3306/user?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8"/>
<property name="database.username" value="root"/>
<property name="database.password" value="root"/>
properties>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC">transactionManager>
<dataSource type="POOLED">
<property name="driver" value="${database.driver}"/>
<property name="url" value="${database.url}"/>
<property name="username" value="${database.username}"/>
<property name="password" value="${database.password}"/>
dataSource>
environment>
environments>
configuration>
这种配置方式时有缺点的,虽然这样定义一次可以到处引用,但是如果配置项很多,那么就会让配置文件显得很庞大,所以使用这种方式显然不是一个很好的选择,为了解决这个缺点,我们可以使用下面的配置方式,也就是使用properties文件的方式。
使用properties文件的方式在我们的开发中是比较常用,主要的这种方式简单,方便日后的维护和修改。首先将上述配置中的所有property属性提取到一个叫做 databse.properties 的配置文件中,
如下代码所示:
#数据库连接配置
database.driver=com.mysql.cj.jdbc.Driver
database.url=jdbc:mysql://localhost:3306/user?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
database.username=root
database.password=root
然后在Mybatis配置文件中使用元素的resource属性来引入properties文件。
"database.properties" />
这样就相当于将 database.properties 中的所有配置都加载到MyBatis的配置文件中了,然后再按照 ${database.username} 的方式引入properties文件的属性参数即可。但是这种使用方式也存在它的缺点,当外部配置文件中的值需要加密时,如连接数据库的用户名和密码,无法在配置文件中进行解密,所以只能通过程序代码传递的方式,就是要介绍的第三种,如下。
在真实的开发环境中,数据库的用户名和密码对开发人员和其他人员是保密的。而运维人员为了数据保密,一般都会把数据库的用户名和密码进行加密处理,会把加密后的数据配置到properties文件中。所以开发人员就必须用解密后的用户名和密码连接数据库,不可能用加密的数据进行连接。此时就需要使用到此种方式来对配置文件进行解密。其实这种方式一般会和第二种配合使用,作用对特殊配置进行覆盖或重写,以上面的database.properties为例,在使用到数据库配置信息时对配置中的用户名和密码进行解密。这里举个MyBatis中获取SqlSessionFactory的例子,代码如下:
public static SqlSessionFactory getSqlSessionFactoryByXml() {
synchronized (Lock) {
if (null != sqlSessionFactory) {
return sqlSessionFactory;
}
String resource = "mybatis-config.xml";
InputStream inputStream;
InputStream is = null;
try {
// 加载数据库配置文件
is = Resources.getResourceAsStream("database.properties");
Properties properties = new Properties();
properties.load(is);
// 获取加密信息
String username= properties.getProperty("database.username");
String password= properties.getProperty("database.password");
// 解密用户名和密码,并重置属性
properties.setProperty("database.username", CyperTool.decodeByBase64(username));
properties.setProperty("database.password", CyperTool.decodeByBase64(password));
// 读取mybatis配置文件
inputStream = Resources.getResourceAsStream(resource);
// 通过SqlSessionFactoryBuilder类的builder方法进行构建,并使用程序传递的方式覆盖原有属性
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream, properties);
} catch (IOException e) {
e.printStackTrace();
return null;
}
return sqlSessionFactory;
}
}
我们为了保证数据的准确性,加了synchronized锁。首先使用Resources对象读取了database.properties配置文件,然后获取了它原来配置的用户和密码,进行解密操作,最后使用SqlSessionFactoryBuilder的build方法,传递多个properties参数来完成。这将覆盖之前加密的配置,这样就可以连接数据库了,同时也能满足因为人员对数据库的用户名和密码的安全要求。
settings是MyBatis中最复杂的配置,它能深刻影响MyBatis底层的运行,但是大部分情况下使用默认值便可以运行,所以在大部分情况下不需要大量配置,只需要修改一些常用的规则即可。常用规则有自动映射、驼峰命名映射、级联规则、是否启动缓存、执行器类型等。
所有配置可参考MyBatis官方文档:https://mybatis.org/mybatis-3/zh/configuration.html#settings。可以看到settings的配置项非常之多,但是我们真正使用的并不会太多,我们只需把常用的搞清楚就可以了。比如关于缓存的CacheEnabled,关于级联的lazyLoadingEnabled和aggressiveLazyLoading,关于自动映射的autoMappingBehavior和mapUnderscoreToCamelCase,关于执行器类型的defaultExecutorType等。本文列出重要的几个配置项及意义,并挑几个常用配置加以说明:
<settings>
<setting name="cacheEnabled" value="true" />
<setting name="lazyLoadingEnabled" value="false" />
<setting name="multipleResultSetsEnabled" value="true" />
<setting name="useColumnLabel" value="true" />
<setting name="useGeneratedKeys" value="false" />
<setting name="autoMappingBehavior" value="PARTIAL" />
<setting name="autoMappingUnknownColumnBehavior" value="WARNING" />
<setting name="defaultExecutorType" value="SIMPLE" />
<setting name="defaultStatementTimeout" value="25"/>
<setting name="defaultFetchSize" value="100" />
<setting name="safeRowBoundsEnabled" value="false" />
<setting name="mapUnderscoreToCamelCase" value="true" />
<setting name="localCacheScope" value="SESSION" />
<setting name="jdbcTypeForNull" value="OTHER" />
<setting name="lazyLoadTriggerMethods" value="equals" />
settings>
typeAlianses属性就是起个别名,是为了在映射文件中更方便的编写输入参数类型和输出结果类型,因为平时的输入输出映射的全限定名显得很长,在使用过程中不是很方便,所以MyBatis中允许我们使用一种简写的方式来代替全限定名,这样可以提高我们的开发效率。
别名分为系统别名和自定义别名,系统别名就是系统默认给我们起的别名,例如我们在输入一个数值型的参数是,可以直接写parameterType=”int”,这是因为系统将Integer的Java类型起的别名为int。我们可以通过Mybatis的官方文档来查看:https://mybatis.org/mybatis-3/zh/configuration.html#typeAliases。而自定义别名是自己定义的名称,后面会介绍如何使用。
Mybatis本身给我们定义了大量的别名,包括有基本数据类型,包装类、对象型、集合和Map等等。系统定义的别名是通过TypeAliasRegistry类来定义的,所以我们既可以通过这个对象获取系统中已经定义好的别名,也能自定义别名,先通过一段代码来获取系统中都预定义了哪些别名。
/**
* 获取系统别名配置
*/
public static void getTypeAlias() {
try {
InputStream stream = getResourceAsStream("mybatis-config.xml");
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(stream);
SqlSession sqlSession = factory.openSession();
//获取TypeAliasRegistry对象
TypeAliasRegistry typeAliasRegistry = sqlSession.getConfiguration().getTypeAliasRegistry();
Map<String, Class<?>> tarMap = typeAliasRegistry.getTypeAliases();
int i =0;
for (String key : tarMap.keySet()) {
//这个++i统计数量
System.out.println(++i+"*****"+tarMap.get(key).getSimpleName()+"*****"+key);
}
System.out.println("系统定义的别名个数为:"+i);
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
getTypeAlias();
}
输出结果就不贴出来了,有点长,可以自行运行。通过运行结果可以发现系统自定义的别名一共有72个(这72个别名的使用不区分大小写)。所以我们可以使用别名代替冗长的全限定名,比如在MyBatis的映射文件中,我们设置一个SQL语句的参数类型或返回类型的时候,如果这个类型是字符串,我们完全可以用string代替java.lang.String。但是这就会有一个问题,我怎么知道哪个类型的别名是什么呢?在不知道的情况下有两种方式可以知道:
保险的方法:将系统别名打印出来,或者找官方文档查询;
寻规律:其实从上面的结果可以发现一个规律,就是如果类名以大写开头,则只要将大写变为小写就是该类的别名;而如果类名本来就是小写,只需要在小写前面加上下划线即可。
我们在平时的开发中,系统中会有大量的类,比如User类,需要对其进行反复的使用,而这些类系统并没有给我们取别名,难道我们要反复的编写很长的全限定名吗?NO,Mybatis给我们提供了用户自定义别名的规则,我们可以通过配置文件、包扫描或者注解进行注册。下面来介绍一下如何使用:
<typeAliases>
<typeAlias alias="user" type="com.thr.pojo.User">typeAlias>
<typeAlias alias="student" type="com.thr.pojo.Student">typeAlias>
typeAliases>
这样我们就为两个类定义好了别名,但是这种方式有个缺点,如果多个类需要配置别名时就显得很麻烦,所以这种方式显然不行。
<typeAliases>
<package name="com.thr.pojo1"/>
<package name="com.thr.pojo2"/>
<package name="com.thr.pojo3"/>
typeAliases>
这种方式会为扫描到的包下的所有类起一个别名,别名的命名规则为,将类名的第一个字母变为小写作为别名,比如com.thr.pojo.User变为别名为user。但是使用这种方式还有缺点,就是如果两个不同的包下出现了同名的类,那么在扫描的时候就会出现异常(通常不会出现这种情况)。这个时候可以通过注解@Alians(“user1”)来进行区分。
这种方式比较简单,只要在对应包下的对应类上面使用注解@Alias("别名")即可,如下:
package com.thr.pojo;
import org.apache.ibatis.type.Alias;
@Alias("user")
public class User {
省略......
}
这样就能够避免因为避免重复而导致扫描失败的问题。
typeHandlers叫类型处理器,在JDBC中,需要在PreparedStatement中设置预编译SQL所需的参数。在执行SQL后,会根据结果集ResultSet对象得到数据库的数据,需要将数据库中的类型和java中字段的类型进行转换一样,这些操作在MyBatis中通过typeHandler来实现。在typeHandler中,包含有javaType和jdbcType两种类型,其中javaType用来定义Java类型,jdbcType用来定义数据库类型,那么typeHandler的作用就是承担javaType和jdbcType两种类型的转换,如下图所示。
MyBatis中的typeHandlers存在系统定义的和自定义两种,MyBatis会根据javaType和jdbcType来决定采用哪个typeHandler来处理这些转换规则,而且系统定义的能满足大部分需求,但是有些情况是不够用的,比如我们的特殊转换规则,枚举类型,这时我们就需要自定义的typeHandlers了。下面分别介绍这两种typeHandler的使用。
Mybatis内部定义了许多有用的typeHandler,我们可以参考Mybatis的官方文档查看:https://mybatis.org/mybatis-3/zh/configuration.html#typeHandlers,也可以自己通过程序代码进行打印,代码如下:
/**
* 获取类型处理器
*/
public static void getTypeHandlers() {
//SqlSession代码省略......
TypeHandlerRegistry typeHandlerRegistry = sqlSession.getConfiguration().getTypeHandlerRegistry();
Collection<TypeHandler<?>> handlers = typeHandlerRegistry.getTypeHandlers();
System.out.println(handlers.size());
int i = 0;
for (TypeHandler<?> typeHandler : handlers) {
System.out.println(++i+"*****"+typeHandler.getClass().getName());
}
}
执行结果就不列出来了,Mybatis一共定义了39个类型处理器。在大部分情况下我们不需要显示的声明JavaType和jdbcType,因为Mybatis会自动探测到。
在Mybatis中typeHandler都需要实现接口org.apache.ibatis.type.TypeHandler,所以我们来看看这个接口长啥样。源代码如下:
public interface TypeHandler<T> {
void setParameter(PreparedStatement var1, int var2, T var3, JdbcType var4) throws SQLException;
T getResult(ResultSet var1, String var2) throws SQLException;
T getResult(ResultSet var1, int var2) throws SQLException;
T getResult(CallableStatement var1, int var2) throws SQLException;
}
简单介绍一下内部定义了内容:
其中T表示泛型,专指JavaType,比如我们需要String类型的参数,那么实现类就是可以写成implement TypeHandler。
setParameter方法,是使用typeHandler通过PreparedStatement对象进行设置SQL参数的时候使用的具体方法,其中i是请查收在SQL的下标,parameter是参数,jdbcType为数据库类型。
其中三个getResult的方法,它的作用是从JDBC结果集中获取数据进行转换,要么使用列名,要么使用下标来获取数据库的数据,其中最后一个方法是存储过程专用的方法。
既然学习了TypeHandler接口,那么接着来学习它的实现了BaseTypeHandler类。源代码如下(只贴出少量):
public abstract class BaseTypeHandler<T> extends TypeReference<T> implements TypeHandler<T> {
......
public void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {
......
}
public T getResult(ResultSet rs, String columnName) throws SQLException {
......
}
public T getResult(ResultSet rs, int columnIndex) throws SQLException {
......
}
public T getResult(CallableStatement cs, int columnIndex) throws SQLException {
......
}
public abstract void setNonNullParameter(PreparedStatement var1, int var2, T var3, JdbcType var4) throws SQLException;
public abstract T getNullableResult(ResultSet var1, String var2) throws SQLException;
public abstract T getNullableResult(ResultSet var1, int var2) throws SQLException;
public abstract T getNullableResult(CallableStatement var1, int var2) throws SQLException;
}
简单分析一下:
public class StringTypeHandler extends BaseTypeHandler<String> {
public StringTypeHandler() {
}
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);
}
}
从上述代码可以看出它继承了BaseTypeHandler类,并且实现了BaseTypeHandler的4个抽象方法,方法如下:
这里Mybatis把JavaType和jdbcType进行互换,那么他们是怎么进行注册的呢?在Mybatis中采用TypeHandlerRegistry类对象的register方法来进行则。
public TypeHandlerRegistry(Configuration configuration) {
......
this.register((Class)Boolean.class, (TypeHandler)(new BooleanTypeHandler()));
this.register((Class)Boolean.TYPE, (TypeHandler)(new BooleanTypeHandler()));
this.register((JdbcType)JdbcType.BOOLEAN, (TypeHandler)(new BooleanTypeHandler()));
this.register((JdbcType)JdbcType.BIT, (TypeHandler)(new BooleanTypeHandler()));
......
}
这样就是实现了用代码的形式注册typeHandler。但是注意,自定义的typeHandler一般不会使用代码进行注册,而是通过配置或者扫描,使用下面我们来学习如何自定义typeHandler。
我们知道在大部分场景下,Mybatis的typeHandler都能应付,但是有时候也会不够用,比如枚举类型,这个时候就需要自定义typeHandler来进行处理了。从系统定义的typeHandler可以知道,要实现typeHandler就需要去实现接口typeHandler或者实现baseTypeHandler。
下面我们使用实现TypeHandler接口的方式创建一个MyTypeHandler,用来完成javaType中的String类型与jdbcType中的类型之间的转化。
public class MyTypeHandler implements TypeHandler<String> {
Logger log = Logger.getLogger(MyTypeHandler.class);
@Override
public void setParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException {
log.info("设置string参数:"+parameter);
ps.setString(i,parameter);
}
@Override
public String getResult(ResultSet rs, String columnName) throws SQLException {
String result = rs.getString(columnName);
log.info("读取string参数1:"+result);
return result;
}
@Override
public String getResult(ResultSet rs, int columnIndex) throws SQLException {
String result = rs.getString(columnIndex);
log.info("读取string参数2:"+result);
return result;
}
@Override
public String getResult(CallableStatement cs, int columnIndex) throws SQLException {
String result = cs.getString(columnIndex);
log.info("读取string参数3:"+result);
return result;
}
}
我们定义的泛型为String则表示我们要把数据库类型的数据转化为String类型,然后实现设置参数和获取结果集的方法。但是这个时候还没有启动typeHandler。还需要在配置文件中配置一下。
<typeHandlers>
<typeHandler jdbcType="VARCHAR" javaType="string"
handler="com.typeHandler.MyTypeHandler"/>
typeHandlers>
配置完成之后系统才会读取它,这样就注册完毕了,当JavaType和jdbcType能与MyTypeHandler对应的时候,它就会启动MyTypeHandler。我们有两种方式来使用自定义的typeHandler。
<select id="selectUserByName" parameterType="string" resultType="user">
select * from t_user where username like concat ('%',#{username,typeHandler=com.typeHandler.MyTypeHandler},'%');
select>
或者:
<select id="selectUserByName" parameterType="string" resultType="user">
select * from t_user where username like concat ('%',#{username,javaType=string,jdbcType=VARCHAR},'%');
select>
注意,要么指定了与自定义typeHandler一致的jdbcType和JavaType,要么直接使用typeHandler指定的具体实现类。在一些因为数据库返回为空导致无法判定采用哪个typeHandler来处理,而又没有注册对应的JavaType的typeHandler是,Mybatis无法找到使用哪个typeHandler来转换数据。
<typeHandlers>
<package name="com.typeHandler"/>
typeHandlers>
但是这样会无法指定jdbcType和JavaType,不过我们可以通过注解来处理它们,我们把MyTypeHandler类修改一些即可。
@MappedTypes(String.class)
@MappedJdbcTypes(JdbcType.VARCHAR)
public class MyTypeHandler implements TypeHandler<String> {
......
}
最后:在我们的日常开发中,一般都不需要定义,使用默认的就可以,除非是像枚举这种特殊类型就需要自己实现。
objectFacotry表示为对象工厂。对象工厂我们只需了解即可,因为到时候与spring整合后,都会由spring来管理。
我们在使用MyBatis执行查询语句的时候,通常都会有一个返回类型,这个是在mapper文件中给sql增加一个resultType(或resultMap)属性进行控制。resultType和resultMap都能控制返回类型,只要定义了这个配置就能自动返回我想要的结果,于是我就很纳闷这个自动过程的实现原理,想必大多数人刚开始的时候应该也有和我一样的困惑和好奇,那么今天我就把自己的研究分享一下。在JDBC中查询的结果会保存在一个结果集中,其实MyBatis也是这个原理,只不过MyBatis在创建结果集的时候,会使用其定义的对象工厂DefaultObjectFactory来完成对应的工作。
插件是Mybatis中最强大和灵活的组件,同时也是最复杂、最难使用的组件,并且它十分的危险,因为它将覆盖Mybatis底层对象的核心方法和属性。如果操作不当将产生非常严重的后果,甚至是摧毁Mybatis框架,所以我们在不了解Mybatis的底层结构的情况下,千万不要去碰这个插件属性。如果你想研究一下插件,那么前提是要清楚掌握Mybatis底层的结构和运行原理,否则将难以安全高效的使用它。而我们平时使用Mybatis的常规功能完全满足日常的开发,所以这里就不介绍了,有兴趣的可以自行去学习。
environments属性表示的是运行环境,主要的作用是配置数据库的一些信息,我们可以配置多个数据库,但只能选择一个。它里面分为两个可配置的元素:事务管理器(transactionManager)、数据源(DataSource)。而在我们的日常开发中,这些都会交给Spring来管理,不用在全局配置中编写,这些会在后面Mybatis整合Spring中进行讲解。我们先来看看environments环境配置的配置代码吧。
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC">transactionManager>
<dataSource type="POOLED">
<property name="driver" value="${database.driver}"/>
<property name="url" value="${database.url}"/>
<property name="username" value="${database.username}"/>
<property name="password" value="${database.password}"/>
dataSource>
environment>
environments>
configuration>
下面我们主要来详细介绍 transactionManager 和 DataSource 这两个元素。
在MyBatis中,transactionManager提供了两个实现类,它们都需要实现接口Transaction,所以我们可以查看以下Transaction的源代码:
public interface Transaction {
Connection getConnection() throws SQLException;
void commit() throws SQLException;
void rollback() throws SQLException;
void close() throws SQLException;
Integer getTimeout() throws SQLException;
}
从上面的方法可知,它主要的工作就是提交(commit)、回滚(rollback)、关闭(close)数据库的事务。MyBatis中为Transaction接口提供了两个实现类,分别是 JdbcTransaction 和 ManagedTransaction。如下图所示:
并且分别对应着 JdbcTransactionFactory 和 ManagedTransactionFactory 两个工厂,这两个工厂实现了 TransactionFactory 这个接口,当我们在配置文件中通过 transactionManager 的type属性配置事务管理器类型的时候,Mybatis就会自动从对应的工厂获取实例。我们可以把事务管理器配置成为以下两种方式:
<transactionManager type="JDBC"/>
<transactionManager type="MANAGED"/>
下面说一下这两者的区别:
JDBC:使用JdbcTransactionFactory工厂生成的JdbcTransaction对象实现,以JDBC的方式进行数据库的提交、回滚等操作。
MANAGED:使用ManagedTransactionFactory工厂生成的ManagedTransaction对象实现,它的提交和回滚不需要任何操作,而是把事务交给容器进行处理,默认情况下会关闭连接,如果不希望默认关闭,只要将其中的closeConnection属性设置为false即可。
<transactionManager type="MANAGED">
<property name="closeConnection" value="false"/>
transactionManager>
在测试的过程中发现的最明显的区别就是,如果我使用JDBC的事务处理方式,当我向数据库中插入一条数据时,在调用完插入接口执行SQL之后,必须 执行sqlSession.commit();进行提交,否则虽然插入成功但是数据库中还是看不到刚才插入的数据;而使用MANAGED方式就不一样了,只需调用接口即可,无需手动提交。
当然除了使用默认的,我们还可以根据需要自定义一个事务管理器,需要以下三步:
第一步:创建一个自定义事务工厂MyTransactionFactory,需要实现TransactionFactory接口,代码如下:
/**
* 创建自定义事务工厂
*/
public class MyTransactionFactory implements TransactionFactory {
@Override
public void setProperties(Properties props) {
}
@Override
public Transaction newTransaction(Connection connection) {
//后面我们会创建这个类,它自定义的事务类
return new MyTransaction(connection);
}
@Override
public Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean b) {
return new MyTransaction(dataSource,level,b);
}
}
这里就实现了TransactionFactory所有定义的工厂方法了,这时还要一个自定义的事务类,下面我们来创建。
第二步:创建一个自定义事务类MyTransaction,用来实现Transaction接口,代码如下。
MyTransaction
第三步:配置自定义事务管理器
<transactionManager type="com.transaction.MyTransactionFactory"/>
注意:这个地方配置的是自定义的工厂类,而不是事务管理类,因为mybatis是根据配置的工厂获取具体实例对象的。
在Mybatis中,数据库是通过PooledDataSourceFactory、UnpooledDataSourceFactory和JndiDataSourceFactory三个工厂类来提供,前两者分别产生PooledDataSource和UnpooledDataSource类对象,第三个则会根据JNDI的信息拿到外部容器实现的数据库连接对象,但是不管怎样,它们最后都会生成一个实现了DataSource接口的数据库连接对象。
因为有三种数据源,所以它们的配置信息如下:
<dataSource type="POOLED">
<dataSource type="UNPOOLED">
<dataSource type="JNDI">
下面介绍一下这三种数据源的意义:
UNPOOLED采用非数据库池的管理方式,每次请求都会新建一个连接,所以性能不是很高,使用这种数据源的时候,UNPOOLED类型的数据源可以配置以下属性:
POOLED采用连接池的概念将数据库链接对象Connection组织起来,可以在初始化时创建多个连接,使用时直接从连接池获取,避免了重复创建连接所需的初始化和认证时间,从而提升了效率,所以这种方式比较适合对性能要求高的应用中。除了UNPOOLED中的配置属性之外,还有下面几个针对池子的配置:
JNDI数据源JNDI的实现是为了能在如EJB或应用服务器这类容器中使用,容器可以集中或在外部配置数据源,然后放置一个JNDI上下文的引用。这种数据源只需配置两个属性:
除了上述三种数据源之外,Mybatis还提供第三方数据源,如DBCP,但是需要我们自定义数据源工厂并进行配置,这一点暂时不做研究。
databaseIdProvider元素主要是为了支持不同厂商的数据库,这个元素不常用。比如有的公司内部开发使用的数据库都是MySQL,但是客户要求使用Oracle,那麻烦了,因为Mybatis的移植性不如Hibernate,但是Mybatis也不会那么蠢,在Mybatis中我们可以使用databaseIdProvider这个元素实现数据库兼容不同厂商,即配置多中数据库。
下面以Oracle和MySQL两种数据库来介绍它们,要配置的属性如下:
<databaseIdProvider type="DB_VENDOR">
<property name="Oracle" value="oracle"/>
<property name="MySQL" value="mysql"/>
<property name="DB2" value="d2"/>
databaseIdProvider>
databaseIdProvider的type属性是必须的,不配置时会报错。上面这个属性值使用的是VendorDatabaseIdProvider类的别名。
property子元素是配置一个数据库,其中的name属性是数据库名称,value是我们自定义的别名,通过别名我们可以在SQL语句中标识适用于哪种数据库运行。如果不知道数据库名称,我们可以通过以下代码获取connection.getMetaData().getDatabaseProductName()来获取,代码如下:
/**
* 获取数据库名称
*/
public static void getDbInfo() {
SqlSession sqlSession = null;
Connection connection = null;
try {
InputStream stream = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(stream);
sqlSession = sqlSessionFactory.openSession();
connection = sqlSession.getConnection();
String dbName = connection.getMetaData().getDatabaseProductName();
String dbVersion = connection.getMetaData().getDatabaseProductVersion();
System.out.println("数据库名称是:" + dbName + ";版本是:" + dbVersion);
} catch (SQLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
我的输出结果是:数据库名称是:MySQL;版本是:5.7.28-log
然后下面我们就可以在自己的sql语句中使用属性databaseId来标示数据库类型了。配置如下:
<select id="selectAllUser" resultType="com.thr.User" databaseId="oracle">
select * from t_user
select>
注意:在上面的SQL中,我配置的databaseId是oracle,但是我的实际的数据库是mysql,结果最后肯定会报BindingException异常(但是我这个代码不知道为什么报的另一种异常,就很奇怪,百度了好久无果)。如果我们把databaseId=”oracle”换成mysql的,就能获取正确结果了。除上述方法之外,我们还可以不在SQL中配置databaseId,这样mybatis会使用默认的配置,也是可以成功运行的。
过上面的实践知道了:使用多数据库SQL时需要配置databaseIdProvider 属性。当databaseId属性被配置的时候,系统会优先获取和数据库配置一致的SQL,否则取没有配置databaseId的SQL,可以把它当默认值;如果还是取不到,就会抛出异常。
除了系统自定义的标识外,我们也可以自定义一个规则,需要实现MyBatis提供的DatabaseIdProvider接口,如下:
MyDatabaseIdProvider
然后在databaseIdProvider中做如下配置:
<databaseIdProvider type="com.databaseidprovider.MyDatabaseIdProvider" />
property属性可以不做配置了,其它都一样。
mapper属性是用来加载映射文件的,也就是加载我们配置的SQL映射文件。它有四种方式加载:
用文件路径引入
使用URL方式引入
用类注册引入
用包名引入(推荐)
<mappers>
<mapper resource="com/thr/mapper/UserMapper.xml" />
<mapper resource="com/thr/mapper/StudentMapper.xml" />
<mapper resource="com/thr/mapper/TeacherMapper.xml" />
mappers>
这种方式是相对路径,相对于项目目录下,所以得用 / 分开。
<mappers>
<mapper url="D:/mappers/UserMapper.xml" />
<mapper url="D:/mappers/StudentMapper.xml" />
mappers>
这种方式是绝对路径,就是从我们的磁盘读取映射文件,一般不会使用这种方式。
<mappers>
<mapper class="com.thr.mapper.UserMapper" />
<mapper class="com.thr.mapper.StudentMapper" />
<mapper class="com.thr.mapper.TeacherMapper" />
mappers>
这种方式使用Mapper接口的全限定名,不用管路径问题,让Mybatis自己通过全限定名去找映射文件。但是前提是Mapper接口的名称必须与映射文件的名称相同,并且要在同一个包名下,否则会找不到。比如:UserMapper.java(接口)—UserMapper.xml(映射文件)。关于Mapper接口对应的Mapper映射文件后面会详细介绍。
<mappers>
<package name="com.thr.mapper"/>
mappers>
推荐使用这种方式,表示引入该包下的所有mapper接口,这里引入了com.thr.mapper包下的所有接口文件,然后让Mybatis自己通过全限定名去找映射文件。
注意:这种方式的要求同样是Mapper接口和Mapper的映射文件的名称要相同,并且要放在相同的包名下,否则会导致找不到。