Mybatis3详解 之 全局配置文件详解

这篇具有很好参考价值的文章主要介绍了Mybatis3详解 之 全局配置文件详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1、全局配置文件

前面我们看到的Mybatis全局文件并没有全部列举出来,所以这一章我们来详细的介绍一遍,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> <!--配置-->
    <properties/> <!--属性-->
    <settings/> <!--全局配置参数-->
    <typeAliases/> <!--类型别名-->
    <typeHandlers/> <!--类型处理器-->
    <objectFactory/><!--对象工厂-->
    <plugins/><!--创建-->
    <environments default=""><!--环境配置-->
        <environment id=""><!--环境变量-->
            <transactionManager type=""/><!--事务管理器-->
            <dataSource type=""/><!--数据源-->
        </environment>
    </environments>
    <databaseIdProvider type=""/><!--数据库厂商标识-->
    <mappers/><!--映射器-->
</configuration>

注意:Mybatis的配置文件的顺序是严格按照从上至下的顺序声明,不颠倒顺序,如果颠倒了它们的顺序,那么Mybatis在启动阶段就会产生异常,导致程序无法运行

2、properties属性

properties 的作用是引用java属性文件中的配置信息,比如:加载连接数据库的各种属性的配置文件。

mybatis提供了三种方式使用properties属性:

  • property子元素(不推荐):就是在properties属性中增加子属性property,从而设置一些配置的key-value。
  • properties文件:就是直接使用properties引入外部配置文件,相当于将子属性抽取成一个独立的外部文件引入,例如db.properties。
  • 程序代码传递参数:就是通过代码的方式设置该配置相关的信息,如数据库配置文件中的用户名和密码一般是密文,但是连接数据库时需要对配置进行解密,此时就只能通过程序代码的方式配置了。

2.1、property子元素(不推荐)

以上一章的例子为基础,使用property子元素将数据库的连接配置信息进行改写,如下所示:

<?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子元素定义-->
        <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">
                <!--配置连接数据库的4个基本信息-->
                <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文件的方式。

2.2、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文件。

<properties resource="database.properties" />

这样就相当于将 database.properties 中的所有配置都加载到MyBatis的配置文件中了,然后再按照 ${database.username} 的方式引入properties文件的属性参数即可。但是这种使用方式也存在它的缺点,当外部配置文件中的值需要加密时,如连接数据库的用户名和密码,无法在配置文件中进行解密,所以只能通过程序代码传递的方式,就是要介绍的第三种,如下。

2.3、程序代码传递参数

在真实的开发环境中,数据库的用户名和密码对开发人员和其他人员是保密的。而运维人员为了数据保密,一般都会把数据库的用户名和密码进行加密处理,会把加密后的数据配置到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参数来完成。这将覆盖之前加密的配置,这样就可以连接数据库了,同时也能满足因为人员对数据库的用户名和密码的安全要求。

3、settings属性

settings是MyBatis中最复杂的配置,它能深刻影响MyBatis底层的运行,但是大部分情况下使用默认值便可以运行,所以在大部分情况下不需要大量配置,只需要修改一些常用的规则即可。常用规则有自动映射、驼峰命名映射、级联规则、是否启动缓存、执行器类型等。

所有配置可参考MyBatis官方文档:https://mybatis.org/mybatis-3/zh/configuration.html#settings。可以看到settings的配置项非常之多,但是我们真正使用的并不会太多,我们只需把常用的搞清楚就可以了。比如关于缓存的CacheEnabled,关于级联的lazyLoadingEnabled和aggressiveLazyLoading,关于自动映射的autoMappingBehavior和mapUnderscoreToCamelCase,关于执行器类型的defaultExecutorType等。本文列出重要的几个配置项及意义,并挑几个常用配置加以说明:

<settings>
    <!--缓存配置的全局开关:如果这里设置成false,那么即便在映射器中配置开启也无济于事 -->
    <setting name="cacheEnabled" value="true" />
    <!--延时加载的全局开关 -->
    <setting name="lazyLoadingEnabled" value="false" />
    <!-- 是否允许单一语句返回多结果集 -->
    <setting name="multipleResultSetsEnabled" value="true" />
    <!-- 使用列标签代替列名,需要兼容驱动 -->
    <setting name="useColumnLabel" value="true" />
    <!-- 允许JDBC自动生成主键,需要驱动兼容。如果设置为true,则这个设置强制使用自动生成主键,尽管一些驱动不能兼容但仍能正常工作 -->
    <setting name="useGeneratedKeys" value="false" />
    <!-- 指定MyBatis该如何自动映射列到字段或属性:NONE表示取消自动映射;PARTIAL表示只会自动映射,没有定义嵌套结果集和映射结果集;
    FULL会自动映射任意复杂的结果集,无论是否嵌套 -->
    <setting name="autoMappingBehavior" value="PARTIAL" />
    <!-- 指定发现自动映射目标未知列(或未知属性类型)的行为。NONE: 不做任何反应WARNING: 输出警告日志FAILING: 映射失败 (抛出 SqlSessionException) -->
    <setting name="autoMappingUnknownColumnBehavior" value="WARNING" />
    <!-- 配置默认的执行器:SIMPLE是普通的执行器;REUSE会重用预处理语句;BATCH会重用语句并执行批量更新 -->
    <setting name="defaultExecutorType" value="SIMPLE" />
    <!--设置超时时间:它决定驱动等待数据库响应的秒数,任何正整数-->
    <setting name="defaultStatementTimeout" value="25"/>
    <!--设置数据库驱动程序默认返回的条数限制,此参数可以重新设置,任何正整数 -->
    <setting name="defaultFetchSize" value="100" />
    <!-- 允许在嵌套语句中使用分页(RowBounds) -->
    <setting name="safeRowBoundsEnabled" value="false" />
    <!-- 是否开启自动驼峰命名规则,即从a_example到aExample的映射 -->
    <setting name="mapUnderscoreToCamelCase" value="true" />
    <!-- 本地缓存机制,防止循环引用和加速重复嵌套循环 -->
    <setting name="localCacheScope" value="SESSION" />
    <!-- 当没有为参数提供特定JDBC类型时,为空值指定JDBC类型。某些驱动需要指定列的JDBC类型,多数情况直接用一般类型即可,如NULL/VARCHAR/OTHER -->
    <setting name="jdbcTypeForNull" value="OTHER" />
    <!-- 指定触发延迟加载的方法,如equals/clone/hashCode/toString -->
    <setting name="lazyLoadTriggerMethods" value="equals" />
</settings>

4、typeAlianses属性

typeAlianses属性就是起个别名,是为了在映射文件中更方便的编写输入参数类型和输出结果类型,因为平时的输入输出映射的全限定名显得很长,在使用过程中不是很方便,所以MyBatis中允许我们使用一种简写的方式来代替全限定名,这样可以提高我们的开发效率。

别名分为系统别名和自定义别名,系统别名就是系统默认给我们起的别名,例如我们在输入一个数值型的参数是,可以直接写parameterType=”int”,这是因为系统将Integer的Java类型起的别名为int。我们可以通过Mybatis的官方文档来查看:https://mybatis.org/mybatis-3/zh/configuration.html#typeAliases。而自定义别名是自己定义的名称,后面会介绍如何使用。

4.1、系统定义的别名

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。但是这就会有一个问题,我怎么知道哪个类型的别名是什么呢?在不知道的情况下有两种方式可以知道:

保险的方法:将系统别名打印出来,或者找官方文档查询;
寻规律:其实从上面的结果可以发现一个规律,就是如果类名以大写开头,则只要将大写变为小写就是该类的别名;而如果类名本来就是小写,只需要在小写前面加上下划线即可。

4.2、自定义别名

我们在平时的开发中,系统中会有大量的类,比如User类,需要对其进行反复的使用,而这些类系统并没有给我们取别名,难道我们要反复的编写很长的全限定名吗?NO,Mybatis给我们提供了用户自定义别名的规则,我们可以通过配置文件、包扫描或者注解进行注册。下面来介绍一下如何使用:

①、使用配置文件的typeAliases属性

<!--配置别名-->
<typeAliases>
    <!--对类单独进行别名设置  -->
    <typeAlias alias="user" type="com.thr.pojo.User"></typeAlias>
    <typeAlias alias="student" type="com.thr.pojo.Student"></typeAlias>
</typeAliases>

这样我们就为两个类定义好了别名,但是这种方式有个缺点,如果多个类需要配置别名时就显得很麻烦,所以这种方式显然不行。

②、通过package自动扫描

<!--配置别名-->
<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 {
    省略......
}

这样就能够避免因为避免重复而导致扫描失败的问题。

5、typeHandlers属性(了解)

typeHandlers叫类型处理器,在JDBC中,需要在PreparedStatement中设置预编译SQL所需的参数。在执行SQL后,会根据结果集ResultSet对象得到数据库的数据,需要将数据库中的类型和java中字段的类型进行转换一样,这些操作在MyBatis中通过typeHandler来实现。在typeHandler中,包含有javaType和jdbcType两种类型,其中javaType用来定义Java类型,jdbcType用来定义数据库类型,那么typeHandler的作用就是承担javaType和jdbcType两种类型的转换,如下图所示。

Mybatis3详解 之 全局配置文件详解,# MyBatis,# 架构解刨中心,产品开发 与 编程学习,java,经验分享,运维,mybatis

MyBatis中的typeHandlers存在系统定义的和自定义两种,MyBatis会根据javaType和jdbcType来决定采用哪个typeHandler来处理这些转换规则,而且系统定义的能满足大部分需求,但是有些情况是不够用的,比如我们的特殊转换规则,枚举类型,这时我们就需要自定义的typeHandlers了。下面分别介绍这两种typeHandler的使用。

5.1、系统定义的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;
 }

简单分析一下:

  • setParameter方法,当参数parameter和jdbcType同时为空时,Mybatis将抛出异常。如果能目前jdbcType,则会继续空设置;如果参数不为空,那么他将曹勇setNonNullParameter方法设置参数。
  • getResult方法,非空结果集是通过getNullableResult方法获取的。如果判断为空,则返回null。
  • getNullableResult方法用于存储过程。
    在Mybatis中使用最多的typeHandler为StringTypeHandler。它用于字符串的转换,所以我们来学习一下。源代码如下:
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个抽象方法,方法如下:

  • setNonNullParameter:这个方法是用来将javaType转换成jdbcTpe。
  • getNullableResult:这个方法用来将从结果集根据列名称获取到的数据的jdbcType转换成javaType。
  • getNullableResult:这个方法用来将从结果集根据列索引获取到的数据的jdbcType转换成javaType。
  • getNullableResult:这个方法用在存储过程中。

这里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。

5.2、自定义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。

<!-- 模糊查询,根据username字段查询用户-->
<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来转换数据。

Mybatis3详解 之 全局配置文件详解,# MyBatis,# 架构解刨中心,产品开发 与 编程学习,java,经验分享,运维,mybatis
有时候类很多的时候,我们还可以采用包扫描的方式。

<typeHandlers>
    <package name="com.typeHandler"/>
</typeHandlers>

但是这样会无法指定jdbcType和JavaType,不过我们可以通过注解来处理它们,我们把MyTypeHandler类修改一些即可。

@MappedTypes(String.class)
@MappedJdbcTypes(JdbcType.VARCHAR)
public class MyTypeHandler implements TypeHandler<String> {
    ......
}

最后:在我们的日常开发中,一般都不需要定义,使用默认的就可以,除非是像枚举这种特殊类型就需要自己实现。

6、objectFacotry属性(了解)

objectFacotry表示为对象工厂。对象工厂我们只需了解即可,因为到时候与spring整合后,都会由spring来管理。

我们在使用MyBatis执行查询语句的时候,通常都会有一个返回类型,这个是在mapper文件中给sql增加一个resultType(或resultMap)属性进行控制。resultType和resultMap都能控制返回类型,只要定义了这个配置就能自动返回我想要的结果,于是我就很纳闷这个自动过程的实现原理,想必大多数人刚开始的时候应该也有和我一样的困惑和好奇,那么今天我就把自己的研究分享一下。在JDBC中查询的结果会保存在一个结果集中,其实MyBatis也是这个原理,只不过MyBatis在创建结果集的时候,会使用其定义的对象工厂DefaultObjectFactory来完成对应的工作。

7、plugins属性(了解)

插件是Mybatis中最强大和灵活的组件,同时也是最复杂、最难使用的组件,并且它十分的危险,因为它将覆盖Mybatis底层对象的核心方法和属性。如果操作不当将产生非常严重的后果,甚至是摧毁Mybatis框架,所以我们在不了解Mybatis的底层结构的情况下,千万不要去碰这个插件属性。如果你想研究一下插件,那么前提是要清楚掌握Mybatis底层的结构和运行原理,否则将难以安全高效的使用它。而我们平时使用Mybatis的常规功能完全满足日常的开发,所以这里就不介绍了,有兴趣的可以自行去学习。

8、environments属性

environments属性表示的是运行环境,主要的作用是配置数据库的一些信息,我们可以配置多个数据库,但只能选择一个。它里面分为两个可配置的元素:事务管理器(transactionManager)、数据源(DataSource)。而在我们的日常开发中,这些都会交给Spring来管理,不用在全局配置中编写,这些会在后面Mybatis整合Spring中进行讲解。我们先来看看environments环境配置的配置代码吧。

<configuration>
    <!-- 配置环境.-->
    <environments default="development">
        <!-- id属性必须和上面的default一致 -->
        <environment id="development">
            <!--配置事务的类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!--dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象源 -->
            <dataSource type="POOLED">
                <!--配置连接数据库的4个基本信息-->
                <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 这两个元素。

8.1、transactionManager(事务管理)

在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。如下图所示:

Mybatis3详解 之 全局配置文件详解,# MyBatis,# 架构解刨中心,产品开发 与 编程学习,java,经验分享,运维,mybatisMybatis3详解 之 全局配置文件详解,# MyBatis,# 架构解刨中心,产品开发 与 编程学习,java,经验分享,运维,mybatis

并且分别对应着 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是根据配置的工厂获取具体实例对象的。

8.2、DataSource(数据源)

在Mybatis中,数据库是通过PooledDataSourceFactory、UnpooledDataSourceFactory和JndiDataSourceFactory三个工厂类来提供,前两者分别产生PooledDataSource和UnpooledDataSource类对象,第三个则会根据JNDI的信息拿到外部容器实现的数据库连接对象,但是不管怎样,它们最后都会生成一个实现了DataSource接口的数据库连接对象。

因为有三种数据源,所以它们的配置信息如下:

<dataSource type="POOLED">
<dataSource type="UNPOOLED">
<dataSource type="JNDI">

下面介绍一下这三种数据源的意义:

①、UNPOOLED

UNPOOLED采用非数据库池的管理方式,每次请求都会新建一个连接,所以性能不是很高,使用这种数据源的时候,UNPOOLED类型的数据源可以配置以下属性:

  • driver:数据库驱动名
  • url:数据库连接URL
  • username:用户名
  • password:密码
  • defaultTransactionIsolationLevel:默认的事务隔离级别,如果要传递属性给驱动,则属性的前缀为driver

②、POOLED

POOLED采用连接池的概念将数据库链接对象Connection组织起来,可以在初始化时创建多个连接,使用时直接从连接池获取,避免了重复创建连接所需的初始化和认证时间,从而提升了效率,所以这种方式比较适合对性能要求高的应用中。除了UNPOOLED中的配置属性之外,还有下面几个针对池子的配置:

  • poolMaximumActiveConnections:任意时间都会存在的连接数,默认值为10
  • poolMaxmumIdleConnections:可以空闲存在的连接数
  • poolMaxmumCheckoutTime:在被强制返回之前,检查出存在空闲连接的等待时间。即如果有20个连接,只有一个空闲,在这个空闲连接被找到之前的等待时间就用这个属性配置。
    poolTimeToWait:等待一个数据库连接成功所需的时间,如果超出这个时间则尝试重新连接。
    还有其他的一些配置,不详述了。

③、JNDI

JNDI数据源JNDI的实现是为了能在如EJB或应用服务器这类容器中使用,容器可以集中或在外部配置数据源,然后放置一个JNDI上下文的引用。这种数据源只需配置两个属性:

  • initial_context:用来在InitialContext中寻找上下文。可选,如果忽略,data_source属性将会直接从InitialContext中寻找;
  • data_source:引用数据源实例位置上下文的路径。当提供initial_context配置时,data_source会在其返回的上下文进行查找,否则直接从InitialContext中查找。

除了上述三种数据源之外,Mybatis还提供第三方数据源,如DBCP,但是需要我们自定义数据源工厂并进行配置,这一点暂时不做研究。

9、databaseIdProvider属性(了解)

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属性可以不做配置了,其它都一样。

10、mappers属性

mapper属性是用来加载映射文件的,也就是加载我们配置的SQL映射文件。它有四种方式加载:

用文件路径引入
使用URL方式引入
用类注册引入
用包名引入(推荐)

10.1、用文件路径引入

<mappers>
    <mapper resource="com/thr/mapper/UserMapper.xml" />
    <mapper resource="com/thr/mapper/StudentMapper.xml" />
    <mapper resource="com/thr/mapper/TeacherMapper.xml" />
</mappers>

这种方式是相对路径,相对于项目目录下,所以得用 / 分开。

10.2、使用URL方式引入

<mappers>
    <mapper url="D:/mappers/UserMapper.xml" />
    <mapper url="D:/mappers/StudentMapper.xml" />
</mappers>

这种方式是绝对路径,就是从我们的磁盘读取映射文件,一般不会使用这种方式。

10.3、用类注册引入

<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映射文件后面会详细介绍。

10.4、用包名引入(推荐)

<mappers>
    <package name="com.thr.mapper"/>
</mappers>

推荐使用这种方式,表示引入该包下的所有mapper接口,这里引入了com.thr.mapper包下的所有接口文件,然后让Mybatis自己通过全限定名去找映射文件。

注意:这种方式的要求同样是Mapper接口和Mapper的映射文件的名称要相同,并且要放在相同的包名下,否则会导致找不到。文章来源地址https://www.toymoban.com/news/detail-729589.html

到了这里,关于Mybatis3详解 之 全局配置文件详解的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • MyBatis配置文件 —— 相关标签详解

    目录 相关导读 一、Mybatis配置文件 — properties标签 二、Mybatis配置文件 — settings标签

    2023年04月08日
    浏览(48)
  • mybatis学习笔记之核心配置文件详解

    environments/environments 表示的是里面能配置多个环境 environment /environment 表示其中的一个环境 而如上的核心配置文件中的那个唯一环境表示的是连接的数据库是demo,可以后面再配置一个文件去连接另一个数据库。(一个环境对应一个数据库,而一个数据库对应一个SqlSessionFacto

    2024年02月16日
    浏览(58)
  • 详解MyBatis配置文件开发与注解式开发

    一.框架介绍 MyBatis 的主要特点 二.MyBatis工作流程 1. 初始化和配置 2. 创建 SqlSessionFactory 3. 获取 SqlSession 4. 映射器绑定 5. 执行操作 6. 处理结果 7. 提交或回滚事务 8. 释放资源 示例 注意事项  三.核心配置文件 四.配置文件开发 五.注解式开发 1. 配置 Mapper 扫描 2. 使用注解定义

    2024年04月27日
    浏览(40)
  • 【MyBatis】1、MyBatis 核心配置文件、多表查询、实体映射文件 ......

    SSM( S pring、 S pringMVC、 M yBatis) Apache Shiro SpringBoot 事务 :若将 N 个 数据库操作 (CRUD)放到同一个事务中,则这 N 个数据库操作最终要么全都生效,要么全都不生效 🍀 开启事务【 START TRANSACTION 】 🍀 回滚事务:若事务中的某个数据库操作失败,其他所有数据库操作都需要

    2024年02月08日
    浏览(80)
  • MyBatis 配置详解

    目录 mybatis-config.xml 核心配置文件 1. environments元素 1.1 子元素environment 1.2 transactionManager 事务管理器(共两种) 2. mappers 元素(定义映射SQL语句文件) 3.properties 4. typeAliases(定义别名) 其他配置【设置】 mybatis-config.xml 包含的内容如下 configuration(配置) properties(属性) se

    2024年02月02日
    浏览(45)
  • Mybatis Generator 配置详解

    因原版观感不佳,搬运至此。 作者:Jimin 链接: https://www.imooc.com/article/21444 来源:慕课网

    2024年02月06日
    浏览(41)
  • MyBatis基础知识和快速入门、MyBatis核心配置文件讲解

    什么是Mybatis MyBatis 是一个优秀的基于java的 持久层框架 ,它内部封装了jdbc,使开发者只需要关注sql语句本身,而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。 mybatis通过xml或注解的方式将要执行的各种 statement配置起来,并通过java对象和statement中

    2024年02月04日
    浏览(106)
  • Mybatis核心配置文件介绍

    核心配置文件包含了 MyBatis 最核心的设置和属性信息 properties标签引入外部文件 具体使用,如下配置   typeAliases:为全类名起别名的父标签。 typeAlias:为全类名起别名的子标签。 属性 type:指定全类名 alias:指定别名 package:为指定包下所有类起别名的子标签。(别名就是类名

    2024年02月17日
    浏览(53)
  • mybatis核心配置文件解读

    目录 标签具体含义  数据源dataSource  properties导入配置 配置文档的顶层结构如下(必须严格按照以下顺序): configuration(配置)     properties(属性)     settings(设置)     typeAliases(类型别名)     typeHandlers(类型处理器)     objectFactory(对象工厂)     plugins(插件

    2024年02月16日
    浏览(51)
  • 【Spring】— MyBatis配置文件元素

    使用MyBatis框架进行开发,需要创建MyBatis的核心配置文件,该配置文件包含重要的元素,熟悉配置文件中各个元素的功能十分重要。 在MyBatis框架的核心配置文件中, configuration 元素是配置文件的根元素,其他元素都要在 contiguration 元素内配置。 MyBatis配置文件中的主要元素如

    2024年02月06日
    浏览(39)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包