2.configuration解析

最新推荐文章于 2023-09-02 20:05:16 发布
最新推荐文章于 2023-09-02 20:05:16 发布
阅读量2k 收藏 4
点赞数
分类专栏： MyBatis 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangbo199308/article/details/120108513
版权

1. 配置文件初始化

mybatis 中包含了很多的配置项，具体每一项的讲解 官网 也很详细，对配置项解析后由Configuration 类维护

  • configuration（配置）
  • properties（属性）
  • settings（设置）
  • typeAliases（类型别名）
  • typeHandlers（类型处理器）
  • objectFactory（对象工厂）
  • plugins（插件）
  • environments（环境配置）
    • environment（环境变量）
    • transactionManager（事务管理器）
    • dataSource（数据源）
  • mappers（映射器）

1.1 Java API 初始化

PooledDataSource dataSource = new PooledDataSource();
dataSource.setDriver("com.mysql.cj.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/mybatis?serverTimezone=GMT");
dataSource.setUsername("root");
dataSource.setPassword("root");
TransactionFactory transactionFactory = new JdbcTransactionFactory();
Environment environment = new Environment("development", transactionFactory, dataSource);
Configuration configuration = new Configuration(environment);
configuration.addMapper(UserMapper.class);
sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);

1.2 XML 配置初始化

相交于 Java API 的方式，XML 配置初始化，必然会多出 XML 的解析部分。代码如下：

String resource = "com/scarecrow/mybatis/config/mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
Properties properties = new Properties();
properties.setProperty("password", "scarecrow");
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream, "development1", properties);

下面是一个相对完整的配置示例：

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

<!-- ELEMENT 标签有顺序 -->
<configuration>
  <!-- properties resource 指定配置文件-->
  <properties resource="com/scarecrow/mybatis/properties/mybatis.properties">
    <!-- 启用默认值特性 -->
    <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="driver" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mybatis-test?serverTimezone = GMT"/>
    <property name="password" value="scarecrow"/>
  </properties>
  <settings>
    <setting name="cacheEnabled" value="true"/>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
  </settings>
  <!-- 类型的别名,简化全路径类名的拼写 xml中的type 我们可以不用写全路径类名。可以使用别名或者直接使用类名即可-->
  <!-- TypeAliasRegistry 系统预先定义好的类型别名-->
  <typeAliases>
    <!-- package 与 typeAlias 不可共用-->
    <!-- package 报下的类名也可使用@Alias注解指定别名，不使用类名 -->
    <package name="com.scarecrow.mybatis.po"/>
    <!-- xml中使用 alias 指定的别名即可-->
    <!--<typeAlias type="com.scarecrow.mybatis.po.UserPO" alias="userPo"/>-->
  </typeAliases>
  <typeHandlers>
    <typeHandler handler="org.apache.ibatis.type.DateTypeHandler" jdbcType="DATE" javaType="java.util.Date"/>
    <typeHandler handler="com.scarecrow.mybatis.type.CustomBooleanTypeHandler"/>
  </typeHandlers>
  <!-- 数据库返回的结果集转换为实体类 -->
  <objectFactory type="com.scarecrow.mybatis.objectfactory.MyCustomObjectFactory">
    <property name="scarecrow" value="scarecrow"/>
    <property name="scarecrow1" value="scarecrow1"/>
  </objectFactory>
  <plugins>
    <plugin interceptor="com.scarecrow.mybatis.plugins.MyCustomPlugin">
      <property name="selectPlugin" value="selectPlugin"/>
    </plugin>
  </plugins>
  <environments default="development1">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <!-- properties 中的配置项 -->
        <property name="driver" value="${driver}"/>
        <!-- properties文件中的配置 -->
        <property name="url" value="${url1}"/>
        <!-- 如果属性 username 没有被配置，username 属性的值将为 root -->
        <!-- 这个特性默认是关闭的。要启用这个特性，需要添加一个特定的属性 enable-default-value 来开启这个特性 -->
        <!-- 默认分隔符: default-value-separator 来修改默认分隔符为?:-->
        <property name="username" value="${username?:root}"/>
        <property name="password" value="${password}"/>
      </dataSource>
    </environment>
    <environment id="development1">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username?:root}"/>
        <property name="password" value="${password}"/>
      </dataSource>
    </environment>
  </environments>

  <!-- 数据库厂商标示 -->
  <!-- name属性是数据库名称，value是我们自定义的别名-->
  <databaseIdProvider type="VENDOR">
    <property name="DB2" value="db2"/>
    <property name="Oracle" value="oracle" />
    <property name="MySQL" value="mysql"/>
  </databaseIdProvider>

  <mappers>
    <!-- 三者使用其中一个即可-->
     <mapper resource="com/scarecrow/mybatis/mapper/UserMapper.xml"/>
    <!-- <mapper class="com.scarecrow.mybatis.mapper.UserMapper"/>-->
     <!--<package name="com.scarecrow.mybatis.mapper"/>-->
  </mappers>

</configuration>

2. Configuration详解

image-20210428232947699

Configuration类保存了所有Mybatis的配置信息。一般情况下Mybatis在运行过程中只会创建一个Configration对象，并且配置信息不能再被修改。

configuration的属性主要分为两大部分：

  • 从mybatis-config.xml中读取的配置

    // 环境
protected Environment environment;
// ---------以下都是<settings>节点-------
protected boolean safeRowBoundsEnabled;
protected boolean safeResultHandlerEnabled = true;
protected boolean mapUnderscoreToCamelCase;
protected boolean aggressiveLazyLoading;
protected boolean multipleResultSetsEnabled = true;
protected boolean useGeneratedKeys;
protected boolean useColumnLabel = true;
// 默认启用缓存
protected boolean cacheEnabled = true;
protected boolean callSettersOnNulls;
protected boolean useActualParamName = true;
protected boolean returnInstanceForEmptyRow;
protected boolean shrinkWhitespacesInSql;

protected String logPrefix;
protected Class<? extends Log> logImpl;
protected Class<? extends VFS> vfsImpl;
protected Class<?> defaultSqlProviderType;
protected LocalCacheScope localCacheScope = LocalCacheScope.SESSION;
protected JdbcType jdbcTypeForNull = JdbcType.OTHER;
protected Set<String> lazyLoadTriggerMethods = new HashSet<>(Arrays.asList("equals", "clone", "hashCode", "toString"));
protected Integer defaultStatementTimeout;
protected Integer defaultFetchSize;
protected ResultSetType defaultResultSetType;
protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE;
protected AutoMappingBehavior autoMappingBehavior = AutoMappingBehavior.PARTIAL;
protected AutoMappingUnknownColumnBehavior autoMappingUnknownColumnBehavior = AutoMappingUnknownColumnBehavior.NONE;

protected Properties variables = new Properties();
protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory();
protected ObjectFactory objectFactory = new DefaultObjectFactory();
protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory();

protected boolean lazyLoadingEnabled = false;
protected ProxyFactory proxyFactory = new JavassistProxyFactory(); // #224 Using internal Javassist instead of OGNL

protected String databaseId;

// mybatis 插件
protected final InterceptorChain interceptorChain = new InterceptorChain();
// 类型处理器
protected final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry(this);
// 类型别名
protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();
// mapper代理对象接口
protected final MapperRegistry mapperRegistry = new MapperRegistry(this);
protected final LanguageDriverRegistry languageRegistry = new LanguageDriverRegistry();

  • 从mapper配置文件或Mapper注解读取的配置

    // 解析后的SQL语句
protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection")
    .conflictMessageProducer((savedValue, targetValue) ->
        ". please check " + savedValue.getResource() + " and " + targetValue.getResource());
protected final Map<String, Cache> caches = new StrictMap<>("Caches collection");

// 存储解析后的resultMap
protected final Map<String, ResultMap> resultMaps = new StrictMap<>("Result Maps collection");
protected final Map<String, ParameterMap> parameterMaps = new StrictMap<>("Parameter Maps collection");
protected final Map<String, KeyGenerator> keyGenerators = new StrictMap<>("Key Generators collection");
// 存储加载后的 sql 片段，在解析SQL节点时会用到
protected final Map<String, XNode> sqlFragments = new StrictMap<>("XML fragments parsed from previous mappers");

Configuration的无参的构造方法，默认注册了很多类型别名。我们只需这些别名就可以知道具体的类型

public Configuration() {
  typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
  typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);

  typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
  typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
  typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);

  typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class);
  typeAliasRegistry.registerAlias("FIFO", FifoCache.class);
  typeAliasRegistry.registerAlias("LRU", LruCache.class);
  typeAliasRegistry.registerAlias("SOFT", SoftCache.class);
  typeAliasRegistry.registerAlias("WEAK", WeakCache.class);

  typeAliasRegistry.registerAlias("DB_VENDOR", VendorDatabaseIdProvider.class);

  typeAliasRegistry.registerAlias("XML", XMLLanguageDriver.class);
  typeAliasRegistry.registerAlias("RAW", RawLanguageDriver.class);

  typeAliasRegistry.registerAlias("SLF4J", Slf4jImpl.class);
  typeAliasRegistry.registerAlias("COMMONS_LOGGING", JakartaCommonsLoggingImpl.class);
  typeAliasRegistry.registerAlias("LOG4J", Log4jImpl.class);
  typeAliasRegistry.registerAlias("LOG4J2", Log4j2Impl.class);
  typeAliasRegistry.registerAlias("JDK_LOGGING", Jdk14LoggingImpl.class);
  typeAliasRegistry.registerAlias("STDOUT_LOGGING", StdOutImpl.class);
  typeAliasRegistry.registerAlias("NO_LOGGING", NoLoggingImpl.class);

  typeAliasRegistry.registerAlias("CGLIB", CglibProxyFactory.class);
  typeAliasRegistry.registerAlias("JAVASSIST", JavassistProxyFactory.class);

  languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);
  languageRegistry.register(RawLanguageDriver.class);
}

3. 解析流程

image-20210428232340105

3.1 SqlSessionFactoryBuilder

主要用途：解析配置文件configuration，及创建SqlSessionFactory 会话工厂

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
  try {
    XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
    return build(parser.parse());
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error building SqlSession.", e);
  } finally {
    ErrorContext.instance().reset();
    try {
      inputStream.close();
    } catch (IOException e) {
      // Intentionally ignore. Prefer previous error.
    }
  }
}

public SqlSessionFactory build(Configuration config) {
  return new DefaultSqlSessionFactory(config);
}

3.2 XMLConfigBuilder

主要解析mybatis-config 配置文件，与之相关的还有下面几个

  • XMLConfigBuilder：解析mybatis-config文件
  • XMLMapperBuilder：解析 Mapper 映射器
  • XMLStatementBuilder：解析增删改查标签

image-20210428235302557

private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
  // Configuration 对象在这里创建。配置文件的解析属性就学会放在 此对象中
  super(new Configuration());
  ErrorContext.instance().resource("SQL Mapper Configuration");
  // 创建SqlSessionFactory对象传进来的属性
  this.configuration.setVariables(props);
  this.parsed = false;
  // 创建SqlSessionFactory对象传进来的运行环境。与config文件的environments 配置节点有关
  this.environment = environment;
  this.parser = parser;
}

public Configuration parse() {
    if (parsed) {
        throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
}

private void parseConfiguration(XNode root) {
  try {
    // issue #117 read properties first
    // 分部解析自定义的config文件
    // 1.properties（variables）
    propertiesElement(root.evalNode("properties"));
    // 2.settings
    Properties settings = settingsAsProperties(root.evalNode("settings"));
    loadCustomVfs(settings);
    // 显式定义用什么log框架，不定义则用默认的自动发现jar包机制
    loadCustomLogImpl(settings);
    // 3.typeAliases 类型别名（TypeAliasRegistry）
    typeAliasesElement(root.evalNode("typeAliases"));
    // 4.插件(interceptorChain)
    pluginElement(root.evalNode("plugins"));
    // 5.对象工厂(objectFactory)
    objectFactoryElement(root.evalNode("objectFactory"));
    // 6.对象包装工厂
    objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
    reflectorFactoryElement(root.evalNode("reflectorFactory"));
    // 7.设置（settongs）
    settingsElement(settings);
    // read it after objectFactory and objectWrapperFactory issue #631
    // 8.环境
    environmentsElement(root.evalNode("environments"));
    // 9.databaseIdProvider
    databaseIdProviderElement(root.evalNode("databaseIdProvider"));
    // 10.类型处理器
    typeHandlerElement(root.evalNode("typeHandlers"));
    // 11.映射器
    mapperElement(root.evalNode("mappers"));
  } catch (Exception e) {
    throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
  }
}

4. 配置文件的详细解析

4.1 properties节点

private void propertiesElement(XNode context) throws Exception {
  if (context != null) {
    // 如果在这些地方,属性多于一个的话,MyBatis 按照如下的顺序加载它们:
    // 1).在 properties 元素体内指定的属性首先被读取。
    // 2).从类路径resource下资源或 properties 元素的 url 属性中加载的属性第二被读取,它会覆盖已经存在的完全一样的属性。
    // 3).作为方法参数传递的属性最后被读取, 它也会覆盖任一已经存在的完全一样的属性,这些属性可能是从 properties 元素体内和资源/url 属性中加载的。

    // 1.XNode.getChildrenAsProperties函数方便得到孩子所有Properties
    Properties defaults = context.getChildrenAsProperties();
    // 2.然后查找resource或者url,加入前面的Properties
    String resource = context.getStringAttribute("resource");
    String url = context.getStringAttribute("url");
    if (resource != null && url != null) {
      throw new BuilderException("The properties element cannot specify both a URL and a resource based property file reference.  Please specify one or the other.");
    }
    if (resource != null) {
      defaults.putAll(Resources.getResourceAsProperties(resource));
    } else if (url != null) {
      defaults.putAll(Resources.getUrlAsProperties(url));
    }
    // 3.Variables也全部加入Properties
    Properties vars = configuration.getVariables();
    if (vars != null) {
      defaults.putAll(vars);
    }
    parser.setVariables(defaults);
    configuration.setVariables(defaults);
  }
}

4.2 settings节点

private void settingsElement(Properties props) {
  // 如何自动映射列到字段/属性
  configuration.setAutoMappingBehavior(AutoMappingBehavior.valueOf(props.getProperty("autoMappingBehavior", "PARTIAL")));
  configuration.setAutoMappingUnknownColumnBehavior(AutoMappingUnknownColumnBehavior.valueOf(props.getProperty("autoMappingUnknownColumnBehavior", "NONE")));
  // 缓存
  configuration.setCacheEnabled(booleanValueOf(props.getProperty("cacheEnabled"), true));
  // proxyFactory (CGLIB | JAVASSIST)
  // 延迟加载的核心技术就是用代理模式，CGLIB/JAVASSIST两者选一
  configuration.setProxyFactory((ProxyFactory) createInstance(props.getProperty("proxyFactory")));
  // 延迟加载
  configuration.setLazyLoadingEnabled(booleanValueOf(props.getProperty("lazyLoadingEnabled"), false));
  // 延迟加载时，每种属性是否还要按需加载
  configuration.setAggressiveLazyLoading(booleanValueOf(props.getProperty("aggressiveLazyLoading"), false));
  // 允不允许多种结果集从一个单独 的语句中返回
  configuration.setMultipleResultSetsEnabled(booleanValueOf(props.getProperty("multipleResultSetsEnabled"), true));
  // 使用列标签代替列名
  configuration.setUseColumnLabel(booleanValueOf(props.getProperty("useColumnLabel"), true));
  // 允许 JDBC 支持生成的键
  configuration.setUseGeneratedKeys(booleanValueOf(props.getProperty("useGeneratedKeys"), false));
  // 配置默认的执行器
  configuration.setDefaultExecutorType(ExecutorType.valueOf(props.getProperty("defaultExecutorType", "SIMPLE")));
  // 超时时间
  configuration.setDefaultStatementTimeout(integerValueOf(props.getProperty("defaultStatementTimeout"), null));

  configuration.setDefaultFetchSize(integerValueOf(props.getProperty("defaultFetchSize"), null));
  configuration.setDefaultResultSetType(resolveResultSetType(props.getProperty("defaultResultSetType")));
  // 是否将DB字段自动映射到驼峰式Java属性（A_COLUMN-->aColumn）
  configuration.setMapUnderscoreToCamelCase(booleanValueOf(props.getProperty("mapUnderscoreToCamelCase"), false));
  // 嵌套语句上使用RowBounds
  configuration.setSafeRowBoundsEnabled(booleanValueOf(props.getProperty("safeRowBoundsEnabled"), false));
  // 默认用session级别的缓存
  configuration.setLocalCacheScope(LocalCacheScope.valueOf(props.getProperty("localCacheScope", "SESSION")));
  // 为null值设置jdbctype
  configuration.setJdbcTypeForNull(JdbcType.valueOf(props.getProperty("jdbcTypeForNull", "OTHER")));
  // Object的哪些方法将触发延迟加载
  configuration.setLazyLoadTriggerMethods(stringSetValueOf(props.getProperty("lazyLoadTriggerMethods"), "equals,clone,hashCode,toString"));
  //使用安全的ResultHandler
  configuration.setSafeResultHandlerEnabled(booleanValueOf(props.getProperty("safeResultHandlerEnabled"), true));
  //动态SQL生成语言所使用的脚本语言
  configuration.setDefaultScriptingLanguage(resolveClass(props.getProperty("defaultScriptingLanguage")));
  configuration.setDefaultEnumTypeHandler(resolveClass(props.getProperty("defaultEnumTypeHandler")));
  configuration.setCallSettersOnNulls(booleanValueOf(props.getProperty("callSettersOnNulls"), false));
  configuration.setUseActualParamName(booleanValueOf(props.getProperty("useActualParamName"), true));
  configuration.setReturnInstanceForEmptyRow(booleanValueOf(props.getProperty("returnInstanceForEmptyRow"), false));
  //logger名字的前缀
  configuration.setLogPrefix(props.getProperty("logPrefix"));
  configuration.setConfigurationFactory(resolveClass(props.getProperty("configurationFactory")));
  configuration.setShrinkWhitespacesInSql(booleanValueOf(props.getProperty("shrinkWhitespacesInSql"), false));
  configuration.setDefaultSqlProviderType(resolveClass(props.getProperty("defaultSqlProviderType")));
}

4.3 typeAliases节点

<typeAliases>
  <!-- package 与 typeAlias 不可共用-->
  <!-- package 报下的类名也可使用@Alias注解指定别名，不使用类名 -->
  <package name="com.scarecrow.mybatis.po"/>
  <!-- xml中使用 alias 指定的别名即可-->
  <!--<typeAlias type="com.scarecrow.mybatis.po.UserPO" alias="userPo"/>-->
</typeAliases>

private void typeAliasesElement(XNode parent) {
  if (parent != null) {
    for (XNode child : parent.getChildren()) {
      if ("package".equals(child.getName())) {
        // 如果是package
        String typeAliasPackage = child.getStringAttribute("name");
        // 调用TypeAliasRegistry.registerAliases，去包下找所有类,然后注册别名(有@Alias注解则用，没有则取类的simpleName)
        configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
      } else {
        // 如果是typeAlias
        String alias = child.getStringAttribute("alias");
        String type = child.getStringAttribute("type");
        try {
          Class<?> clazz = Resources.classForName(type);
          // 根据Class名字来注册类型别名
          // 调用TypeAliasRegistry.registerAlias
          // alias可以省略
          if (alias == null) {
            typeAliasRegistry.registerAlias(clazz);
          } else {
            typeAliasRegistry.registerAlias(alias, clazz);
          }
        } catch (ClassNotFoundException e) {
          throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + e, e);
        }
      }
    }
  }
}
4.3.1 TypeAliasRegistry

类型别名注册：

  1. 通过config xml配置的alias优先级最高

  2. @Alias注解的value值

  3. class.simpleName()

String key = alias.toLowerCase(Locale.ENGLISH);

register时会把别名全部转为小写字母当作key。

resolve时也会把别名全部转为小写字母当作key。

/**
 * @author Clinton Begin
 * 类型别名注册
 * 1、通过xml配置的alias优先级最高
 * 2、@Alias注解的value值
 * 3、class.simpleName()
 */
public class TypeAliasRegistry {

  // key是别名，value是 对象的class类型
  private final Map<String, Class<?>> typeAliases = new HashMap<>();
    
  // 构造函数里注册系统内置的类型别名
  public TypeAliasRegistry() {
      // ...
  }  
  // 扫描并注册包下的所有类
  public void registerAliases(String packageName) {
    registerAliases(packageName, Object.class);
  }

  // 扫描并注册包下所有继承于superType的类型别
  public void registerAliases(String packageName, Class<?> superType) {
    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
    // IsA是ResolverUtil的内部类
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
    // 列出注册包下的所有类
    Set<Class<? extends Class<?>>> typeSet = resolverUtil.getClasses();
    for (Class<?> type : typeSet) {
      // Ignore inner classes and interfaces (including package-info.java)
      // Skip also inner classes. See issue #6
      // 不是匿名类，不是接口，不是内部类
      if (!type.isAnonymousClass() && !type.isInterface() && !type.isMemberClass()) {
        registerAlias(type);
      }
    }
  }
    
  public void registerAlias(Class<?> type) {
    // 如果没有类型别名，用Class.getSimpleName来注册(类名而非全路径类名)
    String alias = type.getSimpleName();
    // 通过Alias注解来注册(Class.getAnnotation)
    Alias aliasAnnotation = type.getAnnotation(Alias.class);
    if (aliasAnnotation != null) {
      alias = aliasAnnotation.value();
    }
    registerAlias(alias, type);
  }
  // 注册类型别名
  public void registerAlias(String alias, Class<?> value) {
    if (alias == null) {
      throw new TypeException("The parameter alias cannot be null");
    }
    // issue #748
    String key = alias.toLowerCase(Locale.ENGLISH);
    // 如果已经存在key了，且value和之前不一致异常
    if (typeAliases.containsKey(key) && typeAliases.get(key) != null && !typeAliases.get(key).equals(value)) {
      throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + typeAliases.get(key).getName() + 	       "'.");
    }
    typeAliases.put(key, value);
  }
    
  // 注册类型别名
  public void registerAlias(String alias, String value) {
    try {
      // 通过全路径类名
      registerAlias(alias, Resources.classForName(value));
    } catch (ClassNotFoundException e) {
      throw new TypeException("Error registering type alias " + alias + " for " + value + ". Cause: " + e, e);
    }
  }
  
  // 解析类型别名
  public <T> Class<T> resolveAlias(String string) {
    try {
      if (string == null) {
        return null;
      }
      // issue #748
      String key = string.toLowerCase(Locale.ENGLISH);
      Class<T> value;
      // 原理就很简单了，从HashMap里找对应的键值，找到则返回类型别名对应的Class
      if (typeAliases.containsKey(key)) {
        value = (Class<T>) typeAliases.get(key);
      } else {
        // 找不到，再试着将String直接转成Class(这样怪不得我们也可以直接用java.lang.Integer的方式定义，也可以就int这么定义)
        value = (Class<T>) Resources.classForName(string);
      }
      return value;
    } catch (ClassNotFoundException e) {
      throw new TypeException("Could not resolve type alias '" + string + "'.  Cause: " + e, e);
    }
  }  
}

4.4 typeHandlers节点

<typeHandlers>
  <typeHandler handler="org.apache.ibatis.type.DateTypeHandler" jdbcType="DATE" javaType="java.util.Date"/>
  <typeHandler handler="com.scarecrow.mybatis.type.CustomBooleanTypeHandler"/>
</typeHandlers>

/**
 * 数据库存储字段为 bit
 * 1：是，0：否
 * 通过类型处理器的泛型，MyBatis 可以得知该类型处理器处理的 Java 类型
 * 1、在类型处理器的配置元素（typeHandler 元素）上增加一个 javaType 属性
 * 2、在类型处理器的类上增加一个 @MappedTypes 注解指定与其关联的 Java 类型列表。如果在 javaType 属性中也同时指定，则注解上的配置将被忽略
 *
 * 通过两种方式来指定关联的 JDBC 类型
 * 1、在类型处理器typeHandler的配置元素上增加一个 jdbcType 属性
 * 2、在类型处理器的类上增加一个 @MappedJdbcTypes 注解指定与其关联的 JDBC 类型列表。 如果在 jdbcType 属性中也同时指定，则注解上的配置将被忽略
 *
 *  当在 ResultMap 中决定使用哪种类型处理器时，此时 Java 类型是已知的（从结果类型中获得），但是 JDBC 类型是未知的。
 *  因此 Mybatis 使用 javaType=[Java 类型], jdbcType=null 的组合来选择一个类型处理器。详见UserMapper.resultMap
 *  如果希望能在 ResultMap 中隐式地使用类型处理器，那么设置 @MappedJdbcTypes 注解的 includeNullJdbcType=true 即可
 *
 *  自定义注册的TypeHandler比系统注册的使用优先级高
 */
@MappedJdbcTypes(value = JdbcType.BOOLEAN, includeNullJdbcType=true)
@MappedTypes(Boolean.class)
public class CustomBooleanTypeHandler extends BaseTypeHandler<Boolean> {
  // ...
}

private void typeHandlerElement(XNode parent) {
  if (parent != null) {
    for (XNode child : parent.getChildren()) {
      // 如果是package
      if ("package".equals(child.getName())) {
        String typeHandlerPackage = child.getStringAttribute("name");
        // 调用TypeHandlerRegistry.register，去包下找所有类
        typeHandlerRegistry.register(typeHandlerPackage);
      } else {
        // 如果是typeHandler
        String javaTypeName = child.getStringAttribute("javaType");
        String jdbcTypeName = child.getStringAttribute("jdbcType");
        String handlerTypeName = child.getStringAttribute("handler");
        Class<?> javaTypeClass = resolveClass(javaTypeName);
        JdbcType jdbcType = resolveJdbcType(jdbcTypeName);
        Class<?> typeHandlerClass = resolveClass(handlerTypeName);
        // 调用TypeHandlerRegistry.register(以下是3种不同的参数形式)
        if (javaTypeClass != null) {
          if (jdbcType == null) {
            typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
          } else {
            typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
          }
        } else {
          typeHandlerRegistry.register(typeHandlerClass);
        }
      }
    }
  }
}

5. 总结

创建SqlSessionFactory对象是通过SqlSessionFactoryBuilder的build方法，他会返回它的默认实现类DefaultSqlSessionFactory，而这个类只有一个属性就是Configuration。

solveJdbcType(jdbcTypeName);
Class<?> typeHandlerClass = resolveClass(handlerTypeName);
// 调用TypeHandlerRegistry.register(以下是3种不同的参数形式)
if (javaTypeClass != null) {
if (jdbcType == null) {
typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
} else {
typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
}
} else {
typeHandlerRegistry.register(typeHandlerClass);
}
}
}
}
}


# 5. 总结

创建SqlSessionFactory对象是通过SqlSessionFactoryBuilder的build方法，他会返回它的默认实现类DefaultSqlSessionFactory，而这个类只有一个属性就是Configuration。

Configuration是通过XMLConfigBuilder的parse方法来的，而parse方法是通过XPathParser读取mybatis配置文件中的配置进行填充Configuration类。
我只是有点困呦
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MyBatis 核心配置综述之 Configuration详解
Java极客技术
08-13 1万+
颓废青年，快出来挨打！点击上方“Java极客技术”，选择“设为星标”后台回复“java”，获取Java知识体系/面试必看资料资料会持续更新，已更新第四次！文章精品专栏记一...
Pandora.Runtime.Configuration
03-31
《Pandora.Runtime.Configuration 深入解析》 在IT领域，配置管理是任何软件系统不可或缺的一部分，它关乎系统的灵活性、可扩展性和可维护性。本文将深入探讨名为"Pandora.Runtime.Configuration"的项目，这是一个...
configuration2 使用
moonpure的专栏
09-04 1508
import org.apache.commons.configuration.reloading.FileChangedReloadingStrategy; import org.apache.commons.configuration.reloading.ReloadingStrategy; import org.apache.commons.configuration2.CompositeC...
@Configuration
04stone37
07-01 6210
作用 　　声明当前类是一个配置类，相当于一个Spring的XML配置文件，与@Bean配合使用。 　　 Instead of using the XML files, we can use plain Java classes to annotate the configurations by using the @Configuration annotation. If you an...
spring中的@Configration详解
u012422446的博客
07-08 5374
虽然 2.0 版本发布以来，Spring 陆续提供了十多个注解，但是提供的这些注解只是为了在某些情况下简化 XML 的配置，并非要取代 XML 配置方式。这一点可以从 Spring IoC 容器的初始化类可以看出：ApplicationContext 接口的最常用的实现类是 ClassPathXmlApplicationContext 和 FileSystemXmlApplicationCon
<configuration>报错
weixin_41785310的博客
10-22 1932
     如果出现以下的错误： The content of element type "configuration" must match "(properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,objectWrapperFactory?,reflectorFactory?,plugins?,environments?...
NetEscapades.Configuration:与ASP.NET Core一起使用的其他配置提供程序
05-14
YAML配置提供程序一个使用加载和解析您的YAML文件的YAML配置提供程序。正在安装使用安装： PM> Install-Package NetEscapades.Configuration.Yaml用法安装软件包时，应将其添加到csproj文件中。 或者，您可以通过...
Autofac.Configuration.3.1.0
03-21
2. **Autofac容器**：Autofac的核心是容器，它负责管理对象的生命周期，包括创建、存储和销毁对象。通过容器，我们可以注册服务（接口或抽象类）及其对应的实现，并在需要时请求这些服务。 3. **配置API**：Autofac...
Autofac.Configuration.3.2.0
03-21
Autofac.Configuration.3.2.0 是一个针对Autofac框架的配置模块，主要用于扩展Autofac容器的配置能力。Autofac是一款强大的、开源的依赖注入（DI）容器，广泛应用于.NET应用程序中，帮助开发者实现解耦和管理对象的...
DSM Configuration Guide.pdf
12-13
DSM是QRadar系统中的一个重要组成部分，它允许系统与特定类型的第三方设备进行通信，收集和解析这些设备产生的安全事件数据。DSM的配置对于确保全面、准确的安全监控至关重要，因为它可以定制化处理不同设备发送的...
Mybatis源码分析 之 Configration
carl.zhao的专栏
04-03 800
在上面一篇文章中分析Mybatis中是如何把xml里面的sql解析成框架中的对象以及mybatis是如何解析动态sql，设置参数以及获取结果集的整个过程。下面我们就来分析一下Mybatis的配置文件，其中包含了影响了Mybatis行为的设置和属性信息。首先我们先来看一下mybatis的配置文件。
2、Configuration详解
等风的帆
06-16 5720
Configuration类Configuration类的位置org.apache.ibatis.session.Configuration Configuration类保存了所有Mybatis的配置信息。 。一般情况下Mybatis在运行过程中只会创建一个Configration对象，并且配置信息不能再被修改。Configuration的属性configuration的属性主要分为两大部
Configuration组件详解
qq_45701514的博客
04-18 671
MyBatis框架的配置信息有两种，一种是配置MyBatis框架属性的主配置文件；另一种是配置执行SQL语句的Mapper配置文件。Configuration的作用是描述MyBatis主配置文件的信息。configuration（配置）properties（属性）settings（设置typeAliases（类型别名）typeHandlers（类型处理器）objectFactory（对象工厂）plugins（插件）environments（环境配置）
【Logback】＜configuration＞标签详解
柒杯红酒
04-08 786
logback，configuration
Configuration(三)
XingTree的博客
07-26 1538
上一篇文章中,我们找到了新的切入点Configuration,现在就让我们来看看parser.parse()是怎么样把xml配置文件转化成Configuration的.我们先来看XMLConfigBuilder的构造方法: public XMLConfigBuilder(Reader reader, String environment, Properties props) { this(
MyBatis 起步的核心环境配置，下面我们来一起看一下 Configuration 类
最新发布
白话机器学习
09-02 124
本文主要概括了Configuration 的创建过程。
Configration和Importresource注解
weixin_50635790的博客
01-24 109
学习前置
configuration
WORKSPACE
04-26 173
无聊写点sample,供以后抄袭 JNDI方式 [code="java"] 1、SpringJNDI数据源配置信息： java:comp/env/jcptDataSourceJNDI jcptDataSourceJNDI是tomcat或者其他应用服务器配置的JNDI. ...
配置hadoop环境
awyo96572的博客
12-04 350
配置hadoop环境 1.安装java环境，具体参照博客 2.创建hadoop用户 2.1 输入如下命令创建新用户 ,这条命令创建了可以登陆的 hadoop 用户，并使用 /bin/bash 作为 shell。 sudo useradd -m hadoop...
org.apache.hadoop.shaded.org.apache.commons.configuration2.Configuration
07-25
回答: org.apache.hadoop.shaded.org.apache.commons.configuration2.Configuration是Apache Hadoop中的一个类，它是用于处理配置文件的接口。它提供了一种方便的方式来读取和解析配置文件，以便在Hadoop集群中进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值