五、Mybatis 核心对象之 Configuration 对象初始化详解

妖狐艹你老母 2023-01-20 13:48 3阅读 0赞

*  源码地址：https://github.com/RononoaZoro/mybatis-book/tree/master 的 mybatis-book ( mybatis-chapter04 )
 *  文章内容出自《Mybatis 3 源码深度解析》第四章
 *  自己实现代码地址：https://github.com/RononoaZoro/mybatis-book/tree/master 的 archer-mybatis

## 1、说明 ##

*  本文以 XML 格式配置文件为例子，详解 Configuration 的初始化过程
 *  其他配置文件类型（如：注解形式，yml, properties 等）请按照相同思路参考源码

**mybatis-config.xml**

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
    		PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    		"http://mybatis.org/dtd/mybatis-3-config.dtd">
    
    <configuration>
    	<settings>
    		<setting name="useGeneratedKeys" value="true"/>
    		<setting name="mapUnderscoreToCamelCase" value="true"/>
    		<setting name="logImpl" value="LOG4J"/>
    	</settings>
    
    	<environments default="dev" >
    		<environment id="dev">
    			<transactionManager type="JDBC">
    				<property name="" value="" />
    			</transactionManager>
    			<dataSource type="UNPOOLED">
    				<property name="driver" value="org.hsqldb.jdbcDriver" />
    				<property name="url" value="jdbc:hsqldb:mem:mybatis" />
    				<property name="username" value="sa" />
    				<property name="password" value="" />
    			</dataSource>
    		</environment>
    		<environment id="qa">
    			<transactionManager type="JDBC">
    				<property name="" value="" />
    			</transactionManager>
    			<dataSource type="UNPOOLED">
    				<property name="driver" value="org.hsqldb.jdbcDriver" />
    				<property name="url" value="jdbc:hsqldb:mem:mybatis_qa" />
    				<property name="username" value="admin" />
    				<property name="password" value="admin" />
    			</dataSource>
    		</environment>
    	</environments>
    
    	<mappers>
    		<mapper resource="mapper/UserMapper.xml"/>
    		
    	</mappers>
    </configuration>

**log4j.properties**

log4j.rootLogger=INFO, stdout
    
    log4j.appender.stdout=org.apache.log4j.ConsoleAppender
    log4j.appender.Threshold=INFO
    log4j.appender.stdout.Target=System.out
    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern=%d %p [%c,%L] - %m%n

**UserEntity.java**

package com.luo.example.entity;
    
    import lombok.Data;
    
    import java.util.Date;
    
    @Data
    public class UserEntity {
        
        private Long id;
        private String name;
        private Date createTime;
        private String password;
        private String phone;
        private String nickName;
    }

**UserMappe.javar**

package com.luo.example.mapper;
    
    import com.luo.example.entity.UserEntity;
    import org.apache.ibatis.annotations.Param;
    import org.apache.ibatis.annotations.Select;
    
    import java.util.List;
    
    public interface UserMapper {
        
    
        List<UserEntity> listAllUser();
    
    //    @Select("select * from user where id=#{userId,jdbcType=INTEGER}")
        UserEntity getUserById(@Param("userId") String userId);
    
        List<UserEntity> getUserByEntity(UserEntity user);
    
        UserEntity getUserByPhone(@Param("phone") String phone);
    
    }

## 2、Configuration 初始化入口 ##

package com.blog4java.mybatis.configuration;
    
    import org.apache.ibatis.builder.xml.XMLConfigBuilder;
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.Configuration;
    import org.junit.Test;
    
    import java.io.IOException;
    import java.io.Reader;
    
    public class ConfigurationExample {
        
    
        @Test
        public void testConfiguration() throws IOException {
        
            Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
            // 创建XMLConfigBuilder实例
            XMLConfigBuilder builder = new XMLConfigBuilder(reader);
            // 调用XMLConfigBuilder.parse（）方法，解析XML创建Configuration对象
            Configuration conf = builder.parse();
        }
    
    }

## 3、Configuration 初始化详细步骤解析 ##

### 3.1、将配置文件读取到 IO 流 ###

//详细读取过程，请参考 Java 官方有关流的 API 
    Reader reader = Resources.getResourceAsReader("mybatis-config.xml");

### 3.2、创建解析 XML 文件所需相关对象 ###

#### 3.2.1、创建 XMLConfigBuilder 对象 ####

// 创建XMLConfigBuilder实例
    XMLConfigBuilder builder = new XMLConfigBuilder(reader);

#### 3.2.2、XMLConfigBuilder 的初始化源码解析 ####

*  1、创建了用于解析 XML 文件的对象（如：XPathParser, XMLMapperEntityResolve, Document 等）
 *  2、创建 Configuration 空对象
 *  3、说明：
    
     *  以下是部分 XMLConfigBuilder 核心代码，完整代码请参考源码
     *  BaseBuilder 定义了各种配置类型解析 Builder 对象的通用属性和方法

**XMLConfigBuilder**

public class XMLConfigBuilder extends BaseBuilder {
        
        private boolean parsed;
        private final XPathParser parser;
        
        
        public XMLConfigBuilder(Reader reader) {
        
        	this(reader, null, null);
      	}
        
        public XMLConfigBuilder(Reader reader, String environment, Properties props) {
        
        	this(new XPathParser(reader, true, props, new XMLMapperEntityResolver()), environment, props);
      	}
        
        private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
        
        super(new Configuration());
        ErrorContext.instance().resource("SQL Mapper Configuration");
        this.configuration.setVariables(props);
        this.parsed = false;
        this.environment = environment;
        this.parser = parser;
      }
    }

**BaseBuilder**

public abstract class BaseBuilder {
        
      protected final Configuration configuration;
      protected final TypeAliasRegistry typeAliasRegistry;
      protected final TypeHandlerRegistry typeHandlerRegistry;
    
      public BaseBuilder(Configuration configuration) {
        
        this.configuration = configuration;
        this.typeAliasRegistry = this.configuration.getTypeAliasRegistry();
        this.typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();
      }
    }

#### 3.2.3、解析 mybatis-config.xml ，保存到 Configuration 对象中 ####

*  完整解析过程参考源码

//调用XMLConfigBuilder.parse（）方法，解析XML 保存到 Configuration 对象
    Configuration conf = builder.parse();

public Configuration parse() {
        // 防止parse（）方法被同一个实例多次调用
        if (parsed) {
          throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        }
        parsed = true;
        // 调用XPathParser.evalNode（）方法，创建表示configuration节点的XNode对象。
        // 调用parseConfiguration（）方法对XNode进行处理
        parseConfiguration(parser.evalNode("/configuration"));
        return configuration;
      }
      
      private void parseConfiguration(XNode root) {
        try {
          //issue #117 read properties first
          propertiesElement(root.evalNode("properties"));
          Properties settings = settingsAsProperties(root.evalNode("settings"));
          loadCustomVfs(settings);
          typeAliasesElement(root.evalNode("typeAliases"));
          pluginElement(root.evalNode("plugins"));
          objectFactoryElement(root.evalNode("objectFactory"));
          objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
          reflectorFactoryElement(root.evalNode("reflectorFactory"));
          settingsElement(settings);
          // read it after objectFactory and objectWrapperFactory issue #631
          
          //数据源解析，并创建 DataSource 对象
          environmentsElement(root.evalNode("environments"));
          databaseIdProviderElement(root.evalNode("databaseIdProvider"));
          typeHandlerElement(root.evalNode("typeHandlers"));
          
          //Mapper 接口与 Mapper.xml 解析，并建立起绑定关系
          mapperElement(root.evalNode("mappers"));
        } catch (Exception e) {
          throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
        }
      }

## 4、自己实现简化版 Mybatis 的 Configuration ##

### 4.1、测试入口 ###

package com.luo.example;
    
    import com.luo.ibatis.builder.xml.ArcherXMLConfigBuilder;
    import com.luo.ibatis.session.ArcherConfiguration;
    import org.apache.ibatis.io.Resources;
    import org.junit.Test;
    
    import java.io.IOException;
    import java.io.Reader;
    
    public class ConfigurationExample {
        
    
        @Test
        public void testConfiguration() throws IOException {
        
            Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
            // 创建XMLConfigBuilder实例
            ArcherXMLConfigBuilder builder = new ArcherXMLConfigBuilder(reader);
            // 调用XMLConfigBuilder.parse（）方法，解析XML创建Configuration对象
            ArcherConfiguration conf = builder.parse();
        }
    
    }

### 4.2、ArcherXMLConfigBuilder 类（对应 XMLConfigBuilder） ###

package com.luo.ibatis.builder.xml;
    
    import com.luo.ibatis.builder.ArcherBaseBuilder;
    import com.luo.ibatis.session.ArcherConfiguration;
    import org.apache.ibatis.builder.BuilderException;
    import org.apache.ibatis.builder.xml.XMLMapperBuilder;
    import org.apache.ibatis.builder.xml.XMLMapperEntityResolver;
    import org.apache.ibatis.datasource.DataSourceFactory;
    import org.apache.ibatis.executor.ErrorContext;
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.logging.Log;
    import org.apache.ibatis.mapping.Environment;
    import org.apache.ibatis.parsing.XNode;
    import org.apache.ibatis.parsing.XPathParser;
    import org.apache.ibatis.reflection.DefaultReflectorFactory;
    import org.apache.ibatis.reflection.MetaClass;
    import org.apache.ibatis.reflection.ReflectorFactory;
    import org.apache.ibatis.session.Configuration;
    import org.apache.ibatis.transaction.TransactionFactory;
    import org.apache.ibatis.type.JdbcType;
    
    import javax.sql.DataSource;
    import java.io.InputStream;
    import java.io.Reader;
    import java.util.Properties;
    
    public class ArcherXMLConfigBuilder extends ArcherBaseBuilder {
        
    
        private boolean parsed;
        private final XPathParser parser;
        private String environment;
        private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();
    
    
        public ArcherXMLConfigBuilder(Reader reader) {
        
            this(reader, null, null);
        }
    
        public ArcherXMLConfigBuilder(Reader reader, String environment) {
        
            this(reader, environment, null);
        }
    
        public ArcherXMLConfigBuilder(Reader reader, String environment, Properties props) {
        
            this(new XPathParser(reader, true, props, new XMLMapperEntityResolver()), environment, props);
        }
    
        public ArcherXMLConfigBuilder(InputStream inputStream) {
        
            this(inputStream, null, null);
        }
    
        public ArcherXMLConfigBuilder(InputStream inputStream, String environment) {
        
            this(inputStream, environment, null);
        }
    
        public ArcherXMLConfigBuilder(InputStream inputStream, String environment, Properties props) {
        
            this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);
        }
    
        private ArcherXMLConfigBuilder(XPathParser parser, String environment, Properties props) {
        
            super(new ArcherConfiguration());
            ErrorContext.instance().resource("SQL Mapper Configuration");
    //        this.configuration.setVariables(props);
            this.parsed = false;
            this.environment = environment;
            this.parser = parser;
        }
    
        public ArcherConfiguration parse() {
        
            // 防止parse（）方法被同一个实例多次调用
            if (parsed) {
        
                throw new BuilderException("Each XMLConfigBuilder can only be used once.");
            }
            parsed = true;
            // 调用XPathParser.evalNode（）方法，创建表示configuration节点的XNode对象。
            // 调用parseConfiguration（）方法对XNode进行处理
            parseConfiguration(parser.evalNode("/configuration"));
            return configuration;
        }
    
        private void parseConfiguration(XNode root) {
        
            try {
        
    //            issue #117 read properties first
    
                //properties 节点解析
    //            propertiesElement(root.evalNode("properties"));
    
                //settings 节点解析为 Properties 对象
                Properties settings = settingsAsProperties(root.evalNode("settings"));
    
                //接入虚拟文件系统
    //            loadCustomVfs(settings);
    
                //别名解析
    //            typeAliasesElement(root.evalNode("typeAliases"));
    
                //插件解析
    //            pluginElement(root.evalNode("plugins"));
    
                //对象工厂
    //            objectFactoryElement(root.evalNode("objectFactory"));
    
                //对象工厂装饰类
    //            objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
    
                //反射
    //            reflectorFactoryElement(root.evalNode("reflectorFactory"));
    
                // 将 settings 节点里的详细保存到 Configuration 对象中
                settingsElement(settings);
    
    //            // read it after objectFactory and objectWrapperFactory issue #631
                //environments 节点解析 数据源信息相关，创建 DataSource 对象
                environmentsElement(root.evalNode("environments"));
    
                // 数据库厂商表示节点 解析
    //            databaseIdProviderElement(root.evalNode("databaseIdProvider"));
    
                //typeHandler 节点解析
    //            typeHandlerElement(root.evalNode("typeHandlers"));
    
                //mapper节点 文件解析
                mapperElement(root.evalNode("mappers"));
            } catch (Exception e) {
        
                throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
            }
        }
    
        private Properties settingsAsProperties(XNode context) {
        
            if (context == null) {
        
                return new Properties();
            }
            Properties props = context.getChildrenAsProperties();
            // Check that all settings are known to the configuration class
            MetaClass metaConfig = MetaClass.forClass(Configuration.class, localReflectorFactory);
            for (Object key : props.keySet()) {
        
                if (!metaConfig.hasSetter(String.valueOf(key))) {
        
                    throw new BuilderException("The setting " + key + " is not known.  Make sure you spelled it correctly (case sensitive).");
                }
            }
            return props;
        }
    
        private void environmentsElement(XNode context) throws Exception {
        
            if (context != null) {
        
                if (environment == null) {
        
                    environment = context.getStringAttribute("default");
                }
                for (XNode child : context.getChildren()) {
        
                    String id = child.getStringAttribute("id");
                    if (isSpecifiedEnvironment(id)) {
        
                        TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
                        DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
                        DataSource dataSource = dsFactory.getDataSource();
                        Environment.Builder environmentBuilder = new Environment.Builder(id)
                                .transactionFactory(txFactory)
                                .dataSource(dataSource);
                        configuration.setEnvironment(environmentBuilder.build());
                    }
                }
            }
        }
    
        private void settingsElement(Properties props) throws Exception {
        
            configuration.setUseGeneratedKeys(booleanValueOf(props.getProperty("useGeneratedKeys"), false));
            configuration.setMapUnderscoreToCamelCase(booleanValueOf(props.getProperty("mapUnderscoreToCamelCase"), false));
            @SuppressWarnings("unchecked")
            Class<? extends Log> logImpl = (Class<? extends Log>)resolveClass(props.getProperty("logImpl"));
            configuration.setLogImpl(logImpl);
        }
    
        private TransactionFactory transactionManagerElement(XNode context) throws Exception {
        
            if (context != null) {
        
                String type = context.getStringAttribute("type");
                Properties props = context.getChildrenAsProperties();
                TransactionFactory factory = (TransactionFactory) resolveClass(type).newInstance();
                factory.setProperties(props);
                return factory;
            }
            throw new BuilderException("Environment declaration requires a TransactionFactory.");
        }
    
        private DataSourceFactory dataSourceElement(XNode context) throws Exception {
        
            if (context != null) {
        
                String type = context.getStringAttribute("type");
                Properties props = context.getChildrenAsProperties();
                DataSourceFactory factory = (DataSourceFactory) resolveClass(type).newInstance();
                factory.setProperties(props);
                return factory;
            }
            throw new BuilderException("Environment declaration requires a DataSourceFactory.");
        }
    
        private void typeHandlerElement(XNode parent) throws Exception {
        
            if (parent != null) {
        
                for (XNode child : parent.getChildren()) {
        
                    if ("package".equals(child.getName())) {
        
                        String typeHandlerPackage = child.getStringAttribute("name");
                        typeHandlerRegistry.register(typeHandlerPackage);
                    } else {
        
                        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);
                        if (javaTypeClass != null) {
        
                            if (jdbcType == null) {
        
                                typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
                            } else {
        
                                typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
                            }
                        } else {
        
                            typeHandlerRegistry.register(typeHandlerClass);
                        }
                    }
                }
            }
        }
    
        private void mapperElement(XNode parent) throws Exception {
        
            if (parent != null) {
        
                for (XNode child : parent.getChildren()) {
        
                    // 通过<package>标签指定包名
                    if ("package".equals(child.getName())) {
        
                        String mapperPackage = child.getStringAttribute("name");
                        configuration.addMappers(mapperPackage);
                    } else {
        
                        String resource = child.getStringAttribute("resource");
                        String url = child.getStringAttribute("url");
                        String mapperClass = child.getStringAttribute("class");
                        // 通过resource属性指定XML文件路径
                        if (resource != null && url == null && mapperClass == null) {
        
                            ErrorContext.instance().resource(resource);
                            InputStream inputStream = Resources.getResourceAsStream(resource);
                            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
                            mapperParser.parse();
                        } else if (resource == null && url != null && mapperClass == null) {
        
                            // 通过url属性指定XML文件路径
                            ErrorContext.instance().resource(url);
                            InputStream inputStream = Resources.getUrlAsStream(url);
                            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
                            mapperParser.parse();
                        } else if (resource == null && url == null && mapperClass != null) {
        
                            // 通过class属性指定接口的完全限定名
                            Class<?> mapperInterface = Resources.classForName(mapperClass);
                            configuration.addMapper(mapperInterface);
                        } else {
        
                            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
                        }
                    }
                }
            }
        }
    
    
        private boolean isSpecifiedEnvironment(String id) {
        
            if (environment == null) {
        
                throw new BuilderException("No environment specified.");
            } else if (id == null) {
        
                throw new BuilderException("Environment requires an id attribute.");
            } else if (environment.equals(id)) {
        
                return true;
            }
            return false;
        }
    
    
    }

### 4.3、ArcherBaseBuilder 类（对应 BaseBuilder） ###

package com.luo.ibatis.builder;
    
    import com.luo.ibatis.session.ArcherConfiguration;
    import org.apache.ibatis.builder.BuilderException;
    import org.apache.ibatis.mapping.ParameterMode;
    import org.apache.ibatis.mapping.ResultSetType;
    import org.apache.ibatis.type.JdbcType;
    import org.apache.ibatis.type.TypeAliasRegistry;
    import org.apache.ibatis.type.TypeHandlerRegistry;
    
    import java.util.Arrays;
    import java.util.HashSet;
    import java.util.Set;
    import java.util.regex.Pattern;
    
    public abstract class ArcherBaseBuilder {
        
    
        protected final ArcherConfiguration configuration;
        protected final TypeAliasRegistry typeAliasRegistry;
        protected final TypeHandlerRegistry typeHandlerRegistry;
    
    
        public ArcherBaseBuilder(ArcherConfiguration configuration) {
        
            this.configuration = configuration;
            this.typeAliasRegistry = this.configuration.getTypeAliasRegistry();
            this.typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();
        }
    
        public ArcherConfiguration getConfiguration() {
        
            return configuration;
        }
    
        protected JdbcType resolveJdbcType(String alias) {
        
            if (alias == null) {
        
                return null;
            }
            try {
        
                return JdbcType.valueOf(alias);
            } catch (IllegalArgumentException e) {
        
                throw new BuilderException("Error resolving JdbcType. Cause: " + e, e);
            }
        }
    
        protected ParameterMode resolveParameterMode(String alias) {
        
            if (alias == null) {
        
                return null;
            }
            try {
        
                return ParameterMode.valueOf(alias);
            } catch (IllegalArgumentException e) {
        
                throw new BuilderException("Error resolving ParameterMode. Cause: " + e, e);
            }
        }
    
        protected <T> Class<? extends T> resolveClass(String alias) {
        
            if (alias == null) {
        
                return null;
            }
            try {
        
                return resolveAlias(alias);
            } catch (Exception e) {
        
                throw new BuilderException("Error resolving class. Cause: " + e, e);
            }
        }
    
        protected Object createInstance(String alias) {
        
            Class<?> clazz = resolveClass(alias);
            if (clazz == null) {
        
                return null;
            }
            try {
        
                return resolveClass(alias).newInstance();
            } catch (Exception e) {
        
                throw new BuilderException("Error creating instance. Cause: " + e, e);
            }
        }
    
    
        protected ResultSetType resolveResultSetType(String alias) {
        
            if (alias == null) {
        
                return null;
            }
            try {
        
                return ResultSetType.valueOf(alias);
            } catch (IllegalArgumentException e) {
        
                throw new BuilderException("Error resolving ResultSetType. Cause: " + e, e);
            }
        }
    
        protected <T> Class<? extends T> resolveAlias(String alias) {
        
            return typeAliasRegistry.resolveAlias(alias);
        }
    
        protected Pattern parseExpression(String regex, String defaultValue) {
        
            return Pattern.compile(regex == null ? defaultValue : regex);
        }
    
        protected Boolean booleanValueOf(String value, Boolean defaultValue) {
        
            return value == null ? defaultValue : Boolean.valueOf(value);
        }
    
        protected Integer integerValueOf(String value, Integer defaultValue) {
        
            return value == null ? defaultValue : Integer.valueOf(value);
        }
    
        protected Set<String> stringSetValueOf(String value, String defaultValue) {
        
            value = (value == null ? defaultValue : value);
            return new HashSet<String>(Arrays.asList(value.split(",")));
        }
    
    
    }

### 4.4、ArcherConfiguration 类（对应 Configuration） ###

package com.luo.ibatis.session;
    
    import com.luo.ibatis.mapping.ArcherMappedStatement;
    import org.apache.ibatis.binding.MapperRegistry;
    import org.apache.ibatis.cache.decorators.FifoCache;
    import org.apache.ibatis.cache.decorators.LruCache;
    import org.apache.ibatis.cache.decorators.SoftCache;
    import org.apache.ibatis.cache.decorators.WeakCache;
    import org.apache.ibatis.cache.impl.PerpetualCache;
    import org.apache.ibatis.datasource.jndi.JndiDataSourceFactory;
    import org.apache.ibatis.datasource.pooled.PooledDataSourceFactory;
    import org.apache.ibatis.datasource.unpooled.UnpooledDataSourceFactory;
    import org.apache.ibatis.executor.loader.cglib.CglibProxyFactory;
    import org.apache.ibatis.executor.loader.javassist.JavassistProxyFactory;
    import org.apache.ibatis.logging.Log;
    import org.apache.ibatis.logging.LogFactory;
    import org.apache.ibatis.logging.commons.JakartaCommonsLoggingImpl;
    import org.apache.ibatis.logging.jdk14.Jdk14LoggingImpl;
    import org.apache.ibatis.logging.log4j.Log4jImpl;
    import org.apache.ibatis.logging.log4j2.Log4j2Impl;
    import org.apache.ibatis.logging.nologging.NoLoggingImpl;
    import org.apache.ibatis.logging.slf4j.Slf4jImpl;
    import org.apache.ibatis.logging.stdout.StdOutImpl;
    import org.apache.ibatis.mapping.Environment;
    import org.apache.ibatis.mapping.VendorDatabaseIdProvider;
    import org.apache.ibatis.parsing.XNode;
    import org.apache.ibatis.scripting.LanguageDriverRegistry;
    import org.apache.ibatis.scripting.defaults.RawLanguageDriver;
    import org.apache.ibatis.scripting.xmltags.XMLLanguageDriver;
    import org.apache.ibatis.session.Configuration;
    import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
    import org.apache.ibatis.transaction.managed.ManagedTransactionFactory;
    import org.apache.ibatis.type.TypeAliasRegistry;
    import org.apache.ibatis.type.TypeHandlerRegistry;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class ArcherConfiguration extends Configuration{
        
        protected Environment environment;
    
    
        protected boolean mapUnderscoreToCamelCase;
        protected boolean useGeneratedKeys;
    
    
        protected Class<? extends Log> logImpl;
    
        protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();
        protected final LanguageDriverRegistry languageRegistry = new LanguageDriverRegistry();
        protected final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry();
        protected final MapperRegistry mapperRegistry = new MapperRegistry(this);
    
        protected final Map<String, ArcherMappedStatement> mappedStatements = new StrictMap<ArcherMappedStatement>("Mapped Statements collection");
    
        protected final Map<String, XNode> sqlFragments = new StrictMap<XNode>("XML fragments parsed from previous mappers");
    
    
        public ArcherConfiguration(Environment environment) {
        
            this();
            this.environment = environment;
        }
    
        public ArcherConfiguration() {
        
            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);
        }
    
        public Environment getEnvironment() {
        
            return environment;
        }
    
        public void setEnvironment(Environment environment) {
        
            this.environment = environment;
        }
    
        public boolean isMapUnderscoreToCamelCase() {
        
            return mapUnderscoreToCamelCase;
        }
    
        public void setMapUnderscoreToCamelCase(boolean mapUnderscoreToCamelCase) {
        
            this.mapUnderscoreToCamelCase = mapUnderscoreToCamelCase;
        }
    
        public boolean isUseGeneratedKeys() {
        
            return useGeneratedKeys;
        }
    
        public void setUseGeneratedKeys(boolean useGeneratedKeys) {
        
            this.useGeneratedKeys = useGeneratedKeys;
        }
    
        public Class<? extends Log> getLogImpl() {
        
            return logImpl;
        }
    
        public void setLogImpl(Class<? extends Log> logImpl) {
        
            if (logImpl != null) {
        
                this.logImpl = logImpl;
                // 调用LogFactory类的useCustomLogging（）方法指定日志实现类
                LogFactory.useCustomLogging(this.logImpl);
            }
        }
    
        public TypeAliasRegistry getTypeAliasRegistry() {
        
            return typeAliasRegistry;
        }
    
    
        public TypeHandlerRegistry getTypeHandlerRegistry() {
        
            return typeHandlerRegistry;
        }
    
        public void addMappers(String packageName, Class<?> superType) {
        
            mapperRegistry.addMappers(packageName, superType);
        }
    
        public void addMappers(String packageName) {
        
            mapperRegistry.addMappers(packageName);
        }
    
        public <T> void addMapper(Class<T> type) {
        
            mapperRegistry.addMapper(type);
        }
    
        public Map<String, XNode> getSqlFragments() {
        
            return sqlFragments;
        }
    
    
        protected static class StrictMap<V> extends HashMap<String, V> {
        
    
            private static final long serialVersionUID = -4950446264854982944L;
            private final String name;
    
            public StrictMap(String name, int initialCapacity, float loadFactor) {
        
                super(initialCapacity, loadFactor);
                this.name = name;
            }
    
            public StrictMap(String name, int initialCapacity) {
        
                super(initialCapacity);
                this.name = name;
            }
    
            public StrictMap(String name) {
        
                super();
                this.name = name;
            }
    
            public StrictMap(String name, Map<String, ? extends V> m) {
        
                super(m);
                this.name = name;
            }
    
            @SuppressWarnings("unchecked")
            public V put(String key, V value) {
        
                if (containsKey(key)) {
        
                    throw new IllegalArgumentException(name + " already contains value for " + key);
                }
                if (key.contains(".")) {
        
                    final String shortKey = getShortName(key);
                    if (super.get(shortKey) == null) {
        
                        super.put(shortKey, value);
                    } else {
        
                        super.put(shortKey, (V) new Ambiguity(shortKey));
                    }
                }
                return super.put(key, value);
            }
    
            public V get(Object key) {
        
                V value = super.get(key);
                if (value == null) {
        
                    throw new IllegalArgumentException(name + " does not contain value for " + key);
                }
                if (value instanceof Ambiguity) {
        
                    throw new IllegalArgumentException(((Ambiguity) value).getSubject() + " is ambiguous in " + name
                            + " (try using the full name including the namespace, or rename one of the entries)");
                }
                return value;
            }
    
            private String getShortName(String key) {
        
                final String[] keyParts = key.split("\\.");
                return keyParts[keyParts.length - 1];
            }
    
            protected static class Ambiguity {
        
                final private String subject;
    
                public Ambiguity(String subject) {
        
                    this.subject = subject;
                }
    
                public String getSubject() {
        
                    return subject;
                }
            }
        }
    
    }