java web之mybatis(二)---初始化

最新推荐文章于 2021-02-10 18:34:46 发布

Eric010101

最新推荐文章于 2021-02-10 18:34:46 发布

阅读量212

点赞数

分类专栏： JavaWeb mybatis

JavaWeb 同时被 2 个专栏收录

85 篇文章 2 订阅

订阅专栏

mybatis

20 篇文章 1 订阅

订阅专栏

(1) Configuration创建和加载

MyBatis的初始化入口是从SqlSeesionFactory的创建开始的，将生成的配置文件输入流传递到SqlSessionBuilder类的build()方法中构建SqlSessionFactory实例

String resource = "mybatis/config.xml";
InputStream is = Main.class.getClassLoader().getResourceAsStream(resource);
SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);

调用build()方法的重载方法，首先根据配置文件输入流进行XML解析，再根据解析结果创建SqlSessionFactory实例

public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
    SqlSessionFactory var5;
    try {
        XMLConfigBuilder e = new XMLConfigBuilder(reader, environment, properties);
        var5 = this.build(e.parse());
    } catch (Exception var14) {
        throw ExceptionFactory.wrapException("Error building SqlSession.", var14);
    } finally {
        ErrorContext.instance().reset();
        try {
            reader.close();
        } catch (IOException var13) {
            ;
        }
    }
    return var5;
}

XMLConfigBuilder在构造器中创建XPathParser实例，进行XML配置输入流的解析

public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) {
    this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);
}

commentConstrutor()方法主要是对validation等属性进行定义，根据输入流创建Document的主要逻辑主要在createDocoument()方法中；

public XPathParser(InputStream inputStream, boolean validation, Properties variables, EntityResolver entityResolver) {
    this.commonConstructor(validation, variables, entityResolver);
    this.document = this.createDocument(new InputSource(inputStream));
}

createDocument()方法根据XML输入流创建Document实例的方法和Spring中将XML文件解析成Doucment方法相同，都是通过SAX的方法解析XML文档；
首先创建DocumentBuilderFactory，再通过DocumentBuilderFactory创建DocumentBuilder，进而解析inputSource()返回Document对象；在解析过程中调用”org.xml.sax”包下额SAX解析方法，创建DOM树；
解完的Document会存储在XPathParser实例对象中，XPathParser对象会存储在XMLConfigBuilder对象中，调用XMLConfigBuilder的parse()方法进行进一步解析；

private Document createDocument(InputSource inputSource) {
    try {
        DocumentBuilderFactory e = DocumentBuilderFactory.newInstance();
        e.setValidating(this.validation);
        e.setNamespaceAware(false);
        e.setIgnoringComments(true);
        e.setIgnoringElementContentWhitespace(false);
        e.setCoalescing(false);
        e.setExpandEntityReferences(true);
        DocumentBuilder builder = e.newDocumentBuilder();
        builder.setEntityResolver(this.entityResolver);
        builder.setErrorHandler(new ErrorHandler() {
            public void error(SAXParseException exception) throws SAXException {
                throw exception;
            }

            public void fatalError(SAXParseException exception) throws SAXException {
                throw exception;
            }

            public void warning(SAXParseException exception) throws SAXException {
            }
        });
        return builder.parse(inputSource);
    } catch (Exception var4) {
        throw new BuilderException("Error creating document instance.  Cause: " + var4, var4);
    }
}

XPathParser实例的parse()方法通过xpath的方法对XML进行解析,首先定位configuration标签作为根标签；
与Spring解析XML不同的是Spring仅仅通过SAX方法将XML文件解析成Document对象，然后对根节点下的标签进行遍历解析生成对应的BeanDefinitiion，而MyBatis在解析玩完Document后利用XPath对标签进行定位获取；

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

调用parseConfiguration()方法对XML进行解析，并根据标签解析结果对configuration对象进行属性的初始化设置

private void parseConfiguration(XNode root) {
    try {
        this.propertiesElement(root.evalNode("properties"));
        Properties e = this.settingsAsProperties(root.evalNode("settings"));
        this.loadCustomVfs(e);
        this.typeAliasesElement(root.evalNode("typeAliases"));
        this.pluginElement(root.evalNode("plugins"));
        this.objectFactoryElement(root.evalNode("objectFactory"));
        this.objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
        this.reflectorFactoryElement(root.evalNode("reflectorFactory"));
        this.settingsElement(e);
        this.environmentsElement(root.evalNode("environments"));
        this.databaseIdProviderElement(root.evalNode("databaseIdProvider"));
        this.typeHandlerElement(root.evalNode("typeHandlers"));
        this.mapperElement(root.evalNode("mappers"));
    } catch (Exception var3) {
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + var3, var3);
    }
}

创建Configuration实例对象装载在DefaultSqlSessionFactory对象中，并返回DefaultSqlSessionFactory对象实例用于创建SqlSession；

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

(2) Mappers标签的解析

mappers标签的解析主要是遍历mappers标签下的所有mapper标签，将mapper映射文件内的每条SQL语句对象化成一个个MapperStatement对象；mapper标签解析的入口是mapperElement()方法；

private void mapperElement(XNode parent) throws Exception {
    if(parent != null) {
        Iterator var2 = parent.getChildren().iterator();

        while(true) {
            while(var2.hasNext()) {
                XNode child = (XNode)var2.next();
                String resource;
                if("package".equals(child.getName())) {
                    resource = child.getStringAttribute("name");
                    this.configuration.addMappers(resource);
                } else {
                    resource = child.getStringAttribute("resource");
                    String url = child.getStringAttribute("url");
                    String mapperClass = child.getStringAttribute("class");
                    XMLMapperBuilder mapperParser;
                    InputStream mapperInterface1;
                    if(resource != null && url == null && mapperClass == null) {
                        ErrorContext.instance().resource(resource);
                        mapperInterface1 = Resources.getResourceAsStream(resource);
                        mapperParser = new XMLMapperBuilder(mapperInterface1, this.configuration, resource, this.configuration.getSqlFragments());
                        mapperParser.parse();
                    } else if(resource == null && url != null && mapperClass == null) {
                        ErrorContext.instance().resource(url);
                        mapperInterface1 = Resources.getUrlAsStream(url);
                        mapperParser = new XMLMapperBuilder(mapperInterface1, this.configuration, url, this.configuration.getSqlFragments());
                        mapperParser.parse();
                    } else {
                        if(resource != null || url != null || mapperClass == null) {
                            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
                        }

                        Class mapperInterface = Resources.classForName(mapperClass);
                        this.configuration.addMapper(mapperInterface);
                    }
                }
            }

            return;
        }
    }
}

每一个mapper映射文件都会创建一个XMLMapperBuilder对象，调用其parse()方法进行单个映射文件mapper的解析;
主要是对mapper映射文件下的ResultMap，cache-ref和具体的sql操作语句(select，insert，update，delete)进行解析；

public void parse() {
    if(!this.configuration.isResourceLoaded(this.resource)) {
        this.configurationElement(this.parser.evalNode("/mapper"));
        this.configuration.addLoadedResource(this.resource);
        this.bindMapperForNamespace();
    }

    this.parsePendingResultMaps();
    this.parsePendingCacheRefs();
    this.parsePendingStatements();
}

对具体sql操作语句的解析通过调用buildStatementFromContext()方法实现；

private void configurationElement(XNode context) {
    try {
        String e = context.getStringAttribute("namespace");
        if(e != null && !e.equals("")) {
            this.builderAssistant.setCurrentNamespace(e);
            this.cacheRefElement(context.evalNode("cache-ref"));
            this.cacheElement(context.evalNode("cache"));
            this.parameterMapElement(context.evalNodes("/mapper/parameterMap"));
            this.resultMapElements(context.evalNodes("/mapper/resultMap"));
            this.sqlElement(context.evalNodes("/mapper/sql"));
            this.buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
        } else {
            throw new BuilderException("Mapper\'s namespace cannot be empty");
        }
    } catch (Exception var3) {
        throw new BuilderException("Error parsing Mapper XML. Cause: " + var3, var3);
    }
}

通过XPath从mapper映射文件中获取全部SQL操作集合，每条操作创建一个XMLStatementBuilder对象进行解析

private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
    Iterator var3 = list.iterator();

    while(var3.hasNext()) {
        XNode context = (XNode)var3.next();
        XMLStatementBuilder statementParser = new XMLStatementBuilder(this.configuration, this.builderAssistant, context, requiredDatabaseId);

        try {
            statementParser.parseStatementNode();
        } catch (IncompleteElementException var7) {
            this.configuration.addIncompleteStatement(statementParser);
        }
    }

}

在XMLStatementBuilder对象的parseStatementNode()方法中构建SqlSource对象和MappedStatement对象

public void parseStatementNode() {
    String id = this.context.getStringAttribute("id");
    String databaseId = this.context.getStringAttribute("databaseId");
    if(this.databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
        Integer fetchSize = this.context.getIntAttribute("fetchSize");
        Integer timeout = this.context.getIntAttribute("timeout");
        String parameterMap = this.context.getStringAttribute("parameterMap");
        String parameterType = this.context.getStringAttribute("parameterType");
        Class parameterTypeClass = this.resolveClass(parameterType);
        String resultMap = this.context.getStringAttribute("resultMap");
        String resultType = this.context.getStringAttribute("resultType");
        String lang = this.context.getStringAttribute("lang");
        LanguageDriver langDriver = this.getLanguageDriver(lang);
        Class resultTypeClass = this.resolveClass(resultType);
        String resultSetType = this.context.getStringAttribute("resultSetType");
        StatementType statementType = StatementType.valueOf(this.context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
        ResultSetType resultSetTypeEnum = this.resolveResultSetType(resultSetType);
        String nodeName = this.context.getNode().getNodeName();
        SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
        boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
        boolean flushCache = this.context.getBooleanAttribute("flushCache", Boolean.valueOf(!isSelect)).booleanValue();
        boolean useCache = this.context.getBooleanAttribute("useCache", Boolean.valueOf(isSelect)).booleanValue();
        boolean resultOrdered = this.context.getBooleanAttribute("resultOrdered", Boolean.valueOf(false)).booleanValue();
        XMLIncludeTransformer includeParser = new XMLIncludeTransformer(this.configuration, this.builderAssistant);
        includeParser.applyIncludes(this.context.getNode());
        this.processSelectKeyNodes(id, parameterTypeClass, langDriver);
        SqlSource sqlSource = langDriver.createSqlSource(this.configuration, this.context, parameterTypeClass);
        String resultSets = this.context.getStringAttribute("resultSets");
        String keyProperty = this.context.getStringAttribute("keyProperty");
        String keyColumn = this.context.getStringAttribute("keyColumn");
        String keyStatementId = id + "!selectKey";
        keyStatementId = this.builderAssistant.applyCurrentNamespace(keyStatementId, true);
        Object keyGenerator;
        if(this.configuration.hasKeyGenerator(keyStatementId)) {
            keyGenerator = this.configuration.getKeyGenerator(keyStatementId);
        } else {
            keyGenerator = this.context.getBooleanAttribute("useGeneratedKeys", Boolean.valueOf(this.configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))).booleanValue()?Jdbc3KeyGenerator.INSTANCE:NoKeyGenerator.INSTANCE;
        }

        this.builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType, fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass, resultSetTypeEnum, flushCache, useCache, resultOrdered, (KeyGenerator)keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
    }
}

在创建MapperStatement对象前需要先创建SqlSource，BoundSql作为从mapper中解析出的sql语句的载体；BoundSql对象中的sql已经解析为带有占位符?的可执行的sql；parameterMappings是执行时传入的参数，因此每执行一次都会创建一个BoundSql对象；

public class BoundSql {
    private String sql;
    private List<ParameterMapping> parameterMappings;
    private Object parameterObject;
    private Map<String, Object> additionalParameters;
    private MetaObject metaParameters;

    public BoundSql(Configuration configuration, String sql, List<ParameterMapping> parameterMappings, Object parameterObject) {
        this.sql = sql;
        this.parameterMappings = parameterMappings;
        this.parameterObject = parameterObject;
        this.additionalParameters = new HashMap();
        this.metaParameters = configuration.newMetaObject(this.additionalParameters);
    }

    public String getSql() {
        return this.sql;
    }

    public List<ParameterMapping> getParameterMappings() {
        return this.parameterMappings;
    }

    public Object getParameterObject() {
        return this.parameterObject;
    }

    public boolean hasAdditionalParameter(String name) {
        String paramName = (new PropertyTokenizer(name)).getName();
        return this.additionalParameters.containsKey(paramName);
    }

    public void setAdditionalParameter(String name, Object value) {
        this.metaParameters.setValue(name, value);
    }

    public Object getAdditionalParameter(String name) {
        return this.metaParameters.getValue(name);
    }
}

在生成SqlSource对象过程中会用到XMLScriptBuilder对动态sql进行解析，转换成可执行的sql；

总结

MyBatis的初始化主要是加载解析XML配置文件，根据解析结果创建Configuration对象；将创建好的Configuration对象装载生成SqlSessionFactory实例对象；
加载mappers标签过程中，会对每个mapper映射文件创建一个XMLMapperBuilder对象进行解析，在单个mapper映射文件解析过程中，会对每个sql操作标签创建一个XMLStatementBuilder对象用于解析,解析每一个sql操作生成对应的MapperStatement对象用于后续的操作；