带你学习Mybatis之Mybatis全局配置文件

拾光师

已于 2024-07-14 16:06:43 修改

阅读量893

点赞数 31

分类专栏： mybatis 文章标签： java

于 2024-05-31 15:42:52 首次发布

本文链接：https://blog.csdn.net/Lxn2zh/article/details/139354510

版权

mybatis 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

Mybatis全局配置文件

<?xml version="1.0" encoding="UTF-8"?>
<configuration> <!-- 配置 -->
    <properties/> <!-- 属性 -->
    <settings/> <!-- 设置 -->
    <typeAliases/> <!-- 类型别名 -->
    <typeHandlers/> <!-- 类型处理器 -->
    <objectFactory/> <!-- 对象工厂 -->
  	<plugins/> <!-- 插件 -->
    <!-- 环境 default表示默认使用环境  -->
    <environments default="development"> <!-- 配置环境 -->
        <environment id="development"> <!-- 环境变量 -->
            <transactionManager type="JDBC"/> <!-- 事务管理器 -->
          	<dataSource type="UNPOOLED"/> <!-- 数据源 -->
        </environment>
    </environments>

    <!-- 数据库厂商标识 -->
    <databaseIdProvider type="DB_VENDOR"/>
        
    <!-- mapper配置 -->
    <mappers/>
    
</configuration>

配置properties属性

可以在全局配置文件中配置properties标签来进行外部配置

设置属性的方式有三种

在properties的属性节点resource或url所指定的资源文件中配置
在properties的子节点property中配置
在构建SqlSessionFactory时通过方法传入参数

外部配置文件引入

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=123456

<!-- 使用 properties来引入外部配置文件内容-->
<!-- resource  引入类路径下的资源
     url  引入网路或磁盘路径下的资源
 -->
<properties resource="jdbc.properties">
</properties>

property子节点配置

<!-- 也可以使用property子节点来进行配置 -->
<properties resource="jdbc.properties">
    <property name="jdbc.password" value="123456"/>
    <!-- 启用默认值特性 -->
    <property name="org.apache.ibatis.parsing.PropertyParser.enable-default-value" value="true"/>
    <!-- 修改默认值的分隔符 -->
    <property name="org.apache.ibatis.parsing.PropertyParser.default-value-separator" value="?:"/>
</properties>

实例化时方法传参

public static SqlSessionFactory createFactory(){
    // 获取到mybatis-config.xml配置文件，进而构建SqlSessionFactory
    InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("mybatis-config.xml");
    Properties props = new Properties();
    props.put("jdbc.password","123456");
    return new SqlSessionFactoryBuilder().build(is,props);
}

使用

使用${}来引用配置好的属性值

<!-- 数据库配置 -->
<environments default="development">
    <environment id="development">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <property name="driver" value="${jdbc.driver}"/>
            <property name="url" value="${jdbc.url}"/>
            <property name="username" value="${jdbc.username}"/>
            <!-- 可以使用:来为占位符设置默认值，如果没有读取到该属性的值，会使用该默认值
             该特性默认关闭，需要配置        <property name="org.apache.ibatis.parsing.PropertyParser.enable-default-value" value="true"/>
             如果开启该特性，默认使用:分隔
             可以使用         <property name="org.apache.ibatis.parsing.PropertyParser.default-value-separator" value="?:"/>
             来修改默认分隔符
             -->
            <property name="password" value="${jdbc.password?:123456}"/>
        </dataSource>
    </environment>
</environments>

三种方式的顺序

首先读取property子节点中指定的属性
再读取使用resources或url引入的外部配置文件中属性，并覆盖之前的同名属性
最后读取作为方法传递的参数，并覆盖之前的同名属性

配置settings设置

mybatis中有很多默认的配置，可以使用settings来进行mybatis的自定义设置，覆盖掉mybatis中的默认配置

设置名	描述	有效值	默认值
cacheEnabled	全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。	true \| false	true
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置 `fetchType` 属性来覆盖该项的开关状态。	true \| false	false
aggressiveLazyLoading	开启时，任一方法的调用都会加载该对象的所有延迟加载属性。否则，每个延迟加载属性会按需加载（参考 `lazyLoadTriggerMethods`)。	true \| false	false （在 3.4.1 及之前的版本中默认为 true）
multipleResultSetsEnabled	是否允许单个语句返回多结果集（需要数据库驱动支持）。	true \| false	true
useColumnLabel	使用列标签代替列名。实际表现依赖于数据库驱动，具体可参考数据库驱动的相关文档，或通过对比测试来观察。	true \| false	true
useGeneratedKeys	允许 JDBC 支持自动生成主键，需要数据库驱动支持。如果设置为 true，将强制使用自动生成主键。尽管一些数据库驱动不支持此特性，但仍可正常工作（如 Derby）。	true \| false	False
autoMappingBehavior	指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示关闭自动映射； PARTIAL 只会自动映射没有定义嵌套结果映射的字段； FULL 会自动映射任何复杂的结果集（无论是否嵌套）	NONE, PARTIAL, FULL	PARTIAL
autoMappingUnknownColumnBehavior	指定发现自动映射目标未知列（或未知属性类型）的行为。 `NONE`: 不做任何反应 `WARNING`: 输出警告日志（`'org.apache.ibatis.session.AutoMappingUnknownColumnBehavior'` 的日志等级必须设置为 `WARN`） `FAILING`: 映射失败 (抛出 `SqlSessionException`)	NONE, WARNING, FAILING	NONE
defaultExecutorType	配置默认的执行器。 SIMPLE 就是普通的执行器； REUSE 执行器会重用预处理语句（PreparedStatement）； BATCH 执行器不仅重用语句还会执行批量更新。	SIMPLE REUSE BATCH	SIMPLE
defaultStatementTimeout	设置超时时间，它决定数据库驱动等待数据库响应的秒数。	任意正整数	未设置 (null)
defaultFetchSize	为驱动的结果集获取数量（fetchSize）设置一个建议值。此参数只可以在查询设置中被覆盖。	任意正整数	未设置 (null)
defaultResultSetType	指定语句默认的滚动策略。（新增于 3.5.2）	FORWARD_ONLY \| SCROLL_SENSITIVE \| SCROLL_INSENSITIVE \| DEFAULT（等同于未设置）	未设置 (null)
safeRowBoundsEnabled	是否允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为 false。	true \| false	False
safeResultHandlerEnabled	是否允许在嵌套语句中使用结果处理器（ResultHandler）。如果允许使用则设置为 false。	true \| false	True
mapUnderscoreToCamelCase	是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。	true \| false	False
localCacheScope	MyBatis 利用本地缓存机制（Local Cache）防止循环引用和加速重复的嵌套查询。默认值为 SESSION，会缓存一个会话中执行的所有查询。若设置值为 STATEMENT，本地缓存将仅用于执行语句，对相同 SqlSession 的不同查询将不会进行缓存。	SESSION \| STATEMENT	SESSION
jdbcTypeForNull	当没有为参数指定特定的 JDBC 类型时，空值的默认 JDBC 类型。某些数据库驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。	JdbcType 常量，常用值：NULL、VARCHAR 或 OTHER。	OTHER
lazyLoadTriggerMethods	指定对象的哪些方法触发一次延迟加载。	用逗号分隔的方法列表。	equals,clone,hashCode,toString
defaultScriptingLanguage	指定动态 SQL 生成使用的默认脚本语言。	一个类型别名或全限定类名。	org.apache.ibatis.scripting.xmltags.XMLLanguageDriver
defaultEnumTypeHandler	指定 Enum 使用的默认 `TypeHandler` 。（新增于 3.4.5）	一个类型别名或全限定类名。	org.apache.ibatis.type.EnumTypeHandler
callSettersOnNulls	指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这在依赖于 Map.keySet() 或 null 值进行初始化时比较有用。注意基本类型（int、boolean 等）是不能设置成 null 的。	true \| false	false
returnInstanceForEmptyRow	当返回行的所有列都是空时，MyBatis默认返回 `null`。当开启这个设置时，MyBatis会返回一个空实例。请注意，它也适用于嵌套的结果集（如集合或关联）。（新增于 3.4.2）	true \| false	false
logPrefix	指定 MyBatis 增加到日志名称的前缀。	任何字符串	未设置
logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J \| LOG4J \| LOG4J2 \| JDK_LOGGING \| COMMONS_LOGGING \| STDOUT_LOGGING \| NO_LOGGING	未设置
proxyFactory	指定 Mybatis 创建可延迟加载对象所用到的代理工具。	CGLIB \| JAVASSIST	JAVASSIST （MyBatis 3.3 以上）
vfsImpl	指定 VFS 的实现	自定义 VFS 的实现的类全限定名，以逗号分隔。	未设置
useActualParamName	允许使用方法签名中的名称作为语句参数名称。为了使用该特性，你的项目必须采用 Java 8 编译，并且加上 `-parameters` 选项。（新增于 3.4.1）	true \| false	true
configurationFactory	指定一个提供 `Configuration` 实例的类。这个被返回的 Configuration 实例用来加载被反序列化对象的延迟加载属性值。这个类必须包含一个签名为`static Configuration getConfiguration()` 的方法。（新增于 3.2.3）	一个类型别名或完全限定类名。	未设置
shrinkWhitespacesInSql	从SQL中删除多余的空格字符。请注意，这也会影响SQL中的文字字符串。 (新增于 3.5.5)	true \| false	false
defaultSqlProviderType	Specifies an sql provider class that holds provider method (Since 3.5.6). This class apply to the `type`(or `value`) attribute on sql provider annotation(e.g. `@SelectProvider`), when these attribute was omitted.	A type alias or fully qualified class name	Not set

    <settings>
        <!-- 开启二级缓存 -->
        <setting name="cacheEnabled" value="true"/>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <!-- 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。 -->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!-- 开启时，任一方法的调用都会加载该对象的所有延迟加载属性。 否则，每个延迟加载属性会按需加载 -->
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

也可以使用java实现

Configuration configuration = new Configuration();
configuration.setCacheEnabled(true);

配置typeAliases类型别名

由于在配置resultMap、resultType、parameterType的时候可能会用到类的全类名，而全类名一般又很长，可以为类来设置别名

系统定义别名

Mybatis中定义了一些经常使用的类型别名

//TypeAliasRegistry类中
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);

自定义别名

类型别名可以为java类型设置别名，之后使用全类名时可以使用别名

<typeAliases>
    <!-- typeAlias为某个类起别名 -->
    <typeAlias type="com.zhanghe.study.mybatis.model.User" alias="User"/>
    
    <!-- 为某个包下所有类批量起别名
        默认值为类名首字母小写
     -->
    <package name="com.zhanghe.study.mybatis.model"/>
</typeAliases>

也可以在类上使用@Alias注解来设置该类的别名

也可以使用java来实现

Configuration configuration = new Configuration();
configuration.getTypeAliasRegistry().registerAlias("User", User.class);

// 注册整个包
configuration.getTypeAliasRegistry().registerAliases("com.zhanghe.study.mybatis.model");

配置typeHandlers类型处理器

作用是将参数从javaType转化为jdbcType，或者从数据库中取出结果时把jdbcType转化为javaType

在使用原生JDBC的时候使用PreparedStatement来设置参数时，是需要自己根据不同的类型来使用不同的方法的

String sql = "insert into user (name) values (?)";
statement = conn.prepareStatement(sql);
statement.setString(1,name);

那么mybatis如何知道该使用什么方法呢，这里就用到了typeHandlers

系统定义typeHandler

mybatis中有很多类型处理器，对于所有的基本数据类型、基本数据类型包装类、byte[]、java.util.Date、java.sql.Date、java.sql.Time、java.sql.TimeStamp、java枚举等。

// TypeHandlerRegistry
register(Boolean.class, new BooleanTypeHandler());
register(boolean.class, new BooleanTypeHandler());
register(JdbcType.BOOLEAN, new BooleanTypeHandler());
register(JdbcType.BIT, new BooleanTypeHandler());

register(Byte.class, new ByteTypeHandler());
register(byte.class, new ByteTypeHandler());
register(JdbcType.TINYINT, new ByteTypeHandler());

register(Short.class, new ShortTypeHandler());
register(short.class, new ShortTypeHandler());
register(JdbcType.SMALLINT, new ShortTypeHandler());

register(Integer.class, new IntegerTypeHandler());
register(int.class, new IntegerTypeHandler());
register(JdbcType.INTEGER, new IntegerTypeHandler());

register(Long.class, new LongTypeHandler());
register(long.class, new LongTypeHandler());

register(Float.class, new FloatTypeHandler());
register(float.class, new FloatTypeHandler());
register(JdbcType.FLOAT, new FloatTypeHandler());

register(Double.class, new DoubleTypeHandler());
register(double.class, new DoubleTypeHandler());
register(JdbcType.DOUBLE, new DoubleTypeHandler());

register(Reader.class, new ClobReaderTypeHandler());
register(String.class, new StringTypeHandler());
register(String.class, JdbcType.CHAR, new StringTypeHandler());
register(String.class, JdbcType.CLOB, new ClobTypeHandler());
register(String.class, JdbcType.VARCHAR, new StringTypeHandler());
register(String.class, JdbcType.LONGVARCHAR, new StringTypeHandler());
register(String.class, JdbcType.NVARCHAR, new NStringTypeHandler());
register(String.class, JdbcType.NCHAR, new NStringTypeHandler());
register(String.class, JdbcType.NCLOB, new NClobTypeHandler());
register(JdbcType.CHAR, new StringTypeHandler());
register(JdbcType.VARCHAR, new StringTypeHandler());
register(JdbcType.CLOB, new ClobTypeHandler());
register(JdbcType.LONGVARCHAR, new StringTypeHandler());
register(JdbcType.NVARCHAR, new NStringTypeHandler());
register(JdbcType.NCHAR, new NStringTypeHandler());
register(JdbcType.NCLOB, new NClobTypeHandler());

register(Object.class, JdbcType.ARRAY, new ArrayTypeHandler());
register(JdbcType.ARRAY, new ArrayTypeHandler());

register(BigInteger.class, new BigIntegerTypeHandler());
register(JdbcType.BIGINT, new LongTypeHandler());

register(BigDecimal.class, new BigDecimalTypeHandler());
register(JdbcType.REAL, new BigDecimalTypeHandler());
register(JdbcType.DECIMAL, new BigDecimalTypeHandler());
register(JdbcType.NUMERIC, new BigDecimalTypeHandler());

register(InputStream.class, new BlobInputStreamTypeHandler());
register(Byte[].class, new ByteObjectArrayTypeHandler());
register(Byte[].class, JdbcType.BLOB, new BlobByteObjectArrayTypeHandler());
register(Byte[].class, JdbcType.LONGVARBINARY, new BlobByteObjectArrayTypeHandler());
register(byte[].class, new ByteArrayTypeHandler());
register(byte[].class, JdbcType.BLOB, new BlobTypeHandler());
register(byte[].class, JdbcType.LONGVARBINARY, new BlobTypeHandler());
register(JdbcType.LONGVARBINARY, new BlobTypeHandler());
register(JdbcType.BLOB, new BlobTypeHandler());

register(Object.class, unknownTypeHandler);
register(Object.class, JdbcType.OTHER, unknownTypeHandler);
register(JdbcType.OTHER, unknownTypeHandler);

register(Date.class, new DateTypeHandler());
register(Date.class, JdbcType.DATE, new DateOnlyTypeHandler());
register(Date.class, JdbcType.TIME, new TimeOnlyTypeHandler());
register(JdbcType.TIMESTAMP, new DateTypeHandler());
register(JdbcType.DATE, new DateOnlyTypeHandler());
register(JdbcType.TIME, new TimeOnlyTypeHandler());

register(java.sql.Date.class, new SqlDateTypeHandler());
register(java.sql.Time.class, new SqlTimeTypeHandler());
register(java.sql.Timestamp.class, new SqlTimestampTypeHandler());

register(String.class, JdbcType.SQLXML, new SqlxmlTypeHandler());

register(Instant.class, new InstantTypeHandler());
register(LocalDateTime.class, new LocalDateTimeTypeHandler());
register(LocalDate.class, new LocalDateTypeHandler());
register(LocalTime.class, new LocalTimeTypeHandler());
register(OffsetDateTime.class, new OffsetDateTimeTypeHandler());
register(OffsetTime.class, new OffsetTimeTypeHandler());
register(ZonedDateTime.class, new ZonedDateTimeTypeHandler());
register(Month.class, new MonthTypeHandler());
register(Year.class, new YearTypeHandler());
register(YearMonth.class, new YearMonthTypeHandler());
register(JapaneseDate.class, new JapaneseDateTypeHandler());

// issue #273
register(Character.class, new CharacterTypeHandler());
register(char.class, new CharacterTypeHandler());

自定义typeHandler

也可以来自定义一个typeHandler，通过实现 org.apache.ibatis.type.TypeHandler 接口，或继承 org.apache.ibatis.type.BaseTypeHandler，并且可以将它映射到一个 JDBC 类型

@MappedTypes({String.class}) // 定义的是javaType类型，可以指定哪些java类型被拦截
@MappedJdbcTypes(JdbcType.VARCHAR) // 定义的是jdbcType类型
public class ExampleTypeHandler extends BaseTypeHandler<String> {

  @Override
  public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException {
    ps.setString(i, parameter);
  }

  @Override
  public String getNullableResult(ResultSet rs, String columnName) throws SQLException {
    return rs.getString(columnName);
  }

  @Override
  public String getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
    return rs.getString(columnIndex);
  }

  @Override
  public String getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
    return cs.getString(columnIndex);
  }
}

<typeHandlers>
  <typeHandler handler="org.mybatis.example.ExampleTypeHandler"/>
</typeHandlers>

也可以使用java实现

Configuration configuration = new Configuration();
// 第一个参数为java类型  第二个参数为TypeHandler类
configuration.getTypeHandlerRegistry().register(String.class, StringTypeHandler.class);

配置objectFactory对象工厂

每次 MyBatis 创建结果对象的新实例时，它都会使用一个ObjectFactory实例来完成实例化工作。默认的objectFactory(DefaultObjectFactory)需要做的仅仅是实例化目标类，要么通过默认无参构造方法，要么通过存在的参数映射来调用带有参数的构造方法。如果想覆盖对象工厂的默认行为，可以通过创建自己的对象工厂来实现

public interface ObjectFactory {

  // 配置ObjectFactory,设置属性
  default void setProperties(Properties properties) {
    // NOP
  }

  // 使用无参构造器
  <T> T create(Class<T> type);

  // 使用有参构造器
  <T> T create(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs);

  
  <T> boolean isCollection(Class<T> type);

}

继承DefaultObjectFactory类

public class ExampleObjectFactory extends DefaultObjectFactory {
  public Object create(Class type) {
    return super.create(type);
  }
  public Object create(Class type, List<Class> constructorArgTypes, List<Object> constructorArgs) {
    return super.create(type, constructorArgTypes, constructorArgs);
  }
  public void setProperties(Properties properties) {
    super.setProperties(properties);
  }
  public <T> boolean isCollection(Class<T> type) {
    return Collection.class.isAssignableFrom(type);
  }
}

<objectFactory type="org.mybatis.example.ExampleObjectFactory">
  <property name="someProperty" value="100"/>
</objectFactory>

配置plugins插件

mybatis可以使用插件来在映射语句执行过程中的某一点进行拦截调用，包括

Executor (update、query、flushStatements、commit、rollback、getTransaction、close、isClose)
ParameterHandler (getParameterObject、setParameters)
ResultSetHandler (handleResultSets、handleOutputParameters)
StatementHandler (prepare、parameterize、batch、update、query)

需要实现Interceptor接口，并指定想要拦截的方法签名来使用插件

Intercepts({@Signature(
  type= Executor.class,
  method = "update",
  args = {MappedStatement.class,Object.class})})
public class ExamplePlugin implements Interceptor {
  private Properties properties = new Properties();
  public Object intercept(Invocation invocation) throws Throwable {
    // implement pre processing if need
    Object returnObject = invocation.proceed();
    // implement post processing if need
    return returnObject;
  }
  public void setProperties(Properties properties) {
    this.properties = properties;
  }
}

<plugins>
  <plugin interceptor="org.mybatis.example.ExamplePlugin">
    <property name="someProperty" value="100"/>
  </plugin>
</plugins>

注意：如果有多个插件拦截相同方法的时候，会按照配置的先后顺序来进行包装代理，在执行时会执行最外层的插件，也就是逆向执行

配置environments环境

mybatis可以配置多个环境，可以连接多个数据源，每一个数据源分为两部分：一个是数据源的配置，一个是数据库事务的配置，但是每个SqlSessionFactory实例只可以选择一种环境，如在开发环境、测试环境、生产环境等所用的配置可能不同，如果想要连接两个数据库，则需要创建两个SqlSessionFactory实例

在构建sqlSessionFactory的时候可以指定选择创建哪个环境，如果不传入environment，则会使用默认的环境

SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, environment);

<!-- 环境 default表示默认使用环境  -->
<environments default="development">
    <environment id="development">
        <!-- 事务管理器有两种类型
            1、JDBC  内部使用JdbcTransactionFactory来创建transactionManager，由应用程序来管理数据库连接的生命周期，该配置直接使用了JDBC的提交和回滚，依赖从数据源获得的连接来管理事务作用域
            2、MANAGED 内部使用ManagedTransactionFactory来创建transactionManager，使用容器(应用服务器)来管理事务的整个生命周期
						(与spring整合使用时，spring会使用自带的管理器，不需要配置mybatis的事务管理器)
         -->
        <transactionManager type="JDBC"/>
        <!-- 数据源有三种类型
            1、UNPOOLED  每次请求时打开和关闭连接  实现类UnpooledDataSource
                额外属性  - defaultTransactionIsolationLevel  默认的连接事务隔离级别
                         - defaultNetworkTimeout  等待数据库操作完成的默认网络超时时间
            2、POOLED  利用连接池的概念将JDBC连接对象组织起来，避免了创建新的连接实例 实现类PooledDataSource
                额外属性
                    - poolMaximumActiveConnections 在任意时间可存在的活动连接数，默认10
                    - poolMaximumIdleConnections  任意时间可能存在的空闲连接数
                    - poolMaximumCheckoutTime  在被强制返回之前，池中连接被检出时间，默认20000毫秒
                    - poolTimeToWait  如果获取连接花费了很长的时间，连接池会打印状态日志并重新尝试获取一个连接，默认20000毫秒
                    - poolMaximumLocalBadConnectionTolerance  如果一个线程获取到一个坏的连接，数据源允许这个线程尝试重新获取一个新的连接，
                                                              尝试次数不应该超过poolMaximumIdleConnections与poolMaximumLocalBadConnectionTolerance之和，默认为3
                    - poolPingQuery  发送到数据库的侦测查询，用来检验连接是否正常工作   默认 NO PING QUERY SET
                    - poolPingEnabled  是否启用侦测查询  默认false
                    - poolPingConnectionsNotUsedFor  配置poolPingQuery的频率(可以设置为和数据库连接超时时间一样，避免不必要的侦测)  默认0
            3、JNDI  在外部配置数据源，然后一个JNDI上下文数据源引用，使用JndiDataSourceFactory来获取数据源
                额外属性
                    - initial_context  用来在InitialContext中寻找上下文
                    - data_source  引用数据源实例的上下文路径
         -->
        <dataSource type="POOLED">
            <property name="driver" value="${jdbc.driver}"/>
            <property name="url" value="${jdbc.url}"/>
            <property name="username" value="${jdbc.username}"/>
            <!-- 可以使用:来为占位符设置默认值，如果没有读取到该属性的值，会使用该默认值
             该特性默认关闭，需要配置        <property name="org.apache.ibatis.parsing.PropertyParser.enable-default-value" value="true"/>
             如果开启该特性，默认使用:分隔
             可以使用         <property name="org.apache.ibatis.parsing.PropertyParser.default-value-separator" value="?:"/>
             来修改默认分隔符
             -->
            <property name="password" value="${jdbc.password?:123456}"/>
        </dataSource>
    </environment>
</environments>

也可以实现org.apache.ibatis.datasource.DataSourceFactory接口来自定义数据源实现，然后进行配置

也可以使用Java来编码实现

DataSource dataSource = new PooledDataSourceFactory().getDataSource();
// JDBC实例化JdbcTransactionFactory    MANAGED实例化ManagedTransactionFactory
TransactionFactory transactionFactory = new JdbcTransactionFactory();
Environment environment = new Environment("development",transactionFactory,dataSource);
Configuration configuration = new Configuration(environment);

自定义数据源

实现org.apache.ibatis.datasource.DataSourceFactory接口

配置 databaseIdProvider数据库厂商标识

mybatis可以根据不同的数据库厂商执行不同的语句，基于映射语句中的databaseId属性。mybatis会加载带有匹配当前数据库databaseId属性个所有不带databaseId属性的语句。如果同时找到带有databaseId的不带databaseId的相同语句，后者会被舍弃

<!-- 数据库厂商标识 
type="DB_VENDOR" 是启动Mybatis内部注册的策略器
-->
<databaseIdProvider type="DB_VENDOR">
  <!-- name为使用DatabaseMetaData#getDatabaseProductName()返回的厂商名称
             value为所设置的别名,使用databaseId时使用别名即可 -->
  <property name="MySQL" value="mysql"/>
  <property name="Oracle" value="oracle"/>
</databaseIdProvider>

在mapper.xml中可以使用databaseId配置不同数据库的sql语句

<!-- 查询数据的方法 -->
<!-- mysql -->
<select id="selectUser" resultType="User" databaseId="mysql">
    select * from users where id = #{id}
</select>
<!-- oracle -->
<select id="selectUser" resultType="User" databaseId="oracle">
    select * from users where id = #{id}
</select>

可以实现org.apache.ibatis.mapping.DatabaseIdProvider接口自定义DatabaseIdProvider

配置mappers映射器

将写好的sql映射文件(mapper.xml)注册到全局配置文件中

<!-- mapper配置 -->
<mappers>
    <!-- resource  引入类路径classpath下的资源  -->
    <mapper resource="mapper/UserMapper.xml"/>
    <!-- url  引入网络或者磁盘路径下的sql映射文件 指定协议为file或者http -->
    <mapper url=""/>
    <!-- class  基于注解的方式，注册类文件  这种方式要求mapper接口名称和mapper映射文件名称相同且在同一个目录下-->
    <mapper class="com.zhanghe.study.mybatis.mapper.UserMapper"/>
    <!-- 批量注册 注册整个包下的 这种方式要求mapper接口名称和mapper映射文件名称相同且在同一个目录-->
    <package name="com.zhanghe.study.mybatis.mapper"/>
</mappers>

也可以使用java来实现

Configuration configuration = new Configuration();
configuration.addMapper(User.class);

https://zhhll.icu/2021/框架/mybatis/基础/2.mybatis全局配置文件/

本文由mdnice多平台发布

拾光师

关注

31
点赞
踩
20

收藏

觉得还不错? 一键收藏
打赏
1
评论
带你学习Mybatis之Mybatis全局配置文件

如果想覆盖对象工厂的默认行为，可以通过创建自己的对象工厂来实现。mybatis可以配置多个环境，可以连接多个数据源，每一个数据源分为两部分：一个是数据源的配置，一个是数据库事务的配置，但是每个SqlSessionFactory实例只可以选择一种环境，如在开发环境、测试环境、生产环境等所用的配置可能不同，如果想要连接两个数据库，则需要创建两个SqlSessionFactory实例。mybatis中有很多默认的配置，可以使用settings来进行mybatis的自定义设置，覆盖掉mybatis中的默认配置。
复制链接

扫一扫