mybatis——sql.xml解析及接口映射器
mybatis-conf.xml解析：主要弄清楚sql.xml的解析成什么了，为后面直接执行+接口映射器做准备。
一、配置文件
mybatis-conf.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> <!-- 属性：定义配置外在化 --> <properties resource="db.properties" /> <!-- 环境：配置mybatis的环境 --> <environments default="dev"> <!-- 环境变量：可以配置多个环境变量，比如使用多数据源时，就需要配置多个环境变量 --> <environment id="dev"> <!-- 事务管理器 --> <transactionManager type="JDBC"></transactionManager> <!-- 数据源 --> <dataSource type="POOLED"> <property name="driver" value="${mysql.driver}"/> <property name="url" value="${mysql.url}"/> <property name="username" value="${mysql.username}"/> <property name="password" value="${mysql.password}"/> </dataSource> </environment> </environments> <!-- 映射器：指定映射文件或者映射类 --> <mappers> <mapper resource="mapper/UserMapper.xml"/> </mappers> </configuration>
userMapper.xml
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.app.aop.transactional.mapper.UserMapper"> <resultMap id="BaseResultMap" type="com.app.aop.transactional.model.User"> <id column="id" jdbcType="BIGINT" property="id" /> <result column="user_id" jdbcType="BIGINT" property="userId" /> <result column="user_name" jdbcType="VARCHAR" property="userName" /> </resultMap> <sql id="Base_Column_List"> id, user_id, user_name </sql> <select id="selectByPrimaryKey" parameterType="java.lang.Long" resultMap="BaseResultMap"> select <include refid="Base_Column_List" /> from user where id = #{id,jdbcType=BIGINT} </select> </mapper>
二、xml解析生成Configureration对象
xml配置解析主要是下面两行代码：
// 读取mybatis-config.xml文件 InputStream inputStream = Resources.getResourceAsStream("mybatis-conf.xml"); // 初始化mybatis，创建SqlSessionFactory类的实例 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
new SqlSessionFactoryBuilder().build(inputStream)：解析mybatis-conf.xml并生成sqlSessionFactory对象
/* org.apache.ibatis.session.SqlSessionFactoryBuilder#build(java.io.InputStream, java.lang.String, java.util.Properties) */ 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. } } }
Configration对象是通过XMLConfigBuilder.parse()解析的
/* org.apache.ibatis.builder.xml.XMLConfigBuilder#parse */ private XMLConfigBuilder(XPathParser parser, String environment, Properties props) { super(new Configuration());//生成一个new Configuration()对象 ErrorContext.instance().resource("SQL Mapper Configuration"); this.configuration.setVariables(props); this.parsed = false; 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 propertiesElement(root.evalNode("properties")); Properties settings = settingsAsProperties(root.evalNode("settings")); loadCustomVfs(settings); configuration.typeAliasRegistry<string,Class> 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 environmentsElement(root.evalNode("environments")); databaseIdProviderElement(root.evalNode("databaseIdProvider")); typeHandlerElement(root.evalNode("typeHandlers")); //重点看看sql.xml的解析成了什么 mapperElement(root.evalNode("mappers")); } catch (Exception e) { throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e); } }
mapperElement(root.evalNode("mappers))：解析sql.xml到Configuration对象中
private void mapperElement(XNode parent) throws Exception { if (parent != null) { for (XNode child : parent.getChildren()) { if ("package".equals(child.getName())) { String mapperPackage = child.getStringAttribute("name"); //将package下多个sql.xml解析到Configuration对象中， //便于理解，研究下面的单个sql.xml解析 configuration.addMappers(mapperPackage); } else { String resource = child.getStringAttribute("resource"); String url = child.getStringAttribute("url"); String mapperClass = child.getStringAttribute("class"); if (resource != null && url == null && mapperClass == null) { ErrorContext.instance().resource(resource); InputStream inputStream = Resources.getResourceAsStream(resource); //sql.xml解析到Configuration对象中 XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments()); mapperParser.parse(); } else if (resource == null && url != null && mapperClass == null) { ErrorContext.instance().resource(url); InputStream inputStream = Resources.getUrlAsStream(url); //sql.xml解析到Configuration对象中 XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments()); mapperParser.parse(); } else if (resource == null && url == null && mapperClass != null) { Class<?> mapperInterface = Resources.classForName(mapperClass); //接口直接绑定,直接接口方法注解@select等解析成sql configuration.addMapper(mapperInterface); } else { throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one."); } } } } }
① sql.xml解析
/* org.apache.ibatis.builder.xml.XMLMapperBuilder#parse */ public void parse() { if (!configuration.isResourceLoaded(resource)) { //解析sql.xml(根节点<mapper>) //将<insert><delete><update><select>解析成一个MappedStatement对象 //然后放入到configuration对象的mappedStatements容器中（Map类型） //<namespace+id , mappedStatement> configurationElement(parser.evalNode("/mapper")); //打标 configuration.addLoadedResource(resource); //加入到configuration.mapperRegistry.knownMappers容器中（Map类型） //type = class.forName(namespace) //Map<type,new MapperProxyFactory<T>(type)> bindMapperForNamespace(); } parsePendingResultMaps(); parsePendingCacheRefs(); parsePendingStatements(); }
解析生成的mappedStatement对象的属性。
public void parseStatementNode() { //<sql>标签中的id属性 String id = context.getStringAttribute("id"); String databaseId = context.getStringAttribute("databaseId"); //判断对应的databaseId中是否已存在id=namespace+id if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) { return; } Integer fetchSize = context.getIntAttribute("fetchSize"); Integer timeout = context.getIntAttribute("timeout"); //<sql>中的parameterMap属性 参数Map String parameterMap = context.getStringAttribute("parameterMap"); //<sql>中的paramterType属性 参数类型 String parameterType = context.getStringAttribute("parameterType"); //解析parameterType //① 类型别名typeAlias直接TYPE_ALIASES.get(paramterType) //② 不是别名Class.forName(paramterType) Class<?> parameterTypeClass = resolveClass(parameterType); //<sql>中resultMap属性 返回参数Map String resultMap = context.getStringAttribute("resultMap"); //<sql>中resultType属性 返回参数类型 String resultType = context.getStringAttribute("resultType"); //<sql>中lang属性 不常用，指定Diver类型常用的mysql String lang = context.getStringAttribute("lang"); LanguageDriver langDriver = getLanguageDriver(lang); //返回类型 别名转class，不是别名直接Class.forName(type) Class<?> resultTypeClass = resolveClass(resultType); //<sql>的resultSetType 不常用 String resultSetType = context.getStringAttribute("resultSetType"); //<sql>的statementType属性，编译类型，默认PreparedStatement StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString())); ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType); String nodeName = context.getNode().getNodeName(); SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH)); //是否<select>标签 boolean isSelect = sqlCommandType == SqlCommandType.SELECT; //<sql>的flushCache属性，是否清除缓存 默认<select>:false ; 非<select>:true boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect); //<sql>的userCache属性,是否使用缓存 默认<select>：true；非<select> : false boolean useCache = context.getBooleanAttribute("useCache", isSelect); //<sql>的resultOrdered属性 不常用 boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false); // Include Fragments before parsing XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant); includeParser.applyIncludes(context.getNode()); // Parse selectKey after includes and remove them. processSelectKeyNodes(id, parameterTypeClass, langDriver); // Parse the SQL (pre: <selectKey> and <include> were parsed and removed) //sql语句解析生成sql，三部分 sql语句+parameterMapping+parameterObject SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass); String resultSets = context.getStringAttribute("resultSets"); String keyProperty = context.getStringAttribute("keyProperty"); String keyColumn = context.getStringAttribute("keyColumn"); KeyGenerator keyGenerator; String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX; keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true); if (configuration.hasKeyGenerator(keyStatementId)) { keyGenerator = configuration.getKeyGenerator(keyStatementId); } else { keyGenerator = context.getBooleanAttribute("useGeneratedKeys", configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType)) ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE; } //创建mappedStatement对象，并初始化变量 builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType, fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass, resultSetTypeEnum, flushCache, useCache, resultOrdered, keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets); }
② 注解解析：
sql.xml解析时bindMapperForNamespace的主题逻辑也是执行addMapper(type)。
/* org.apache.ibatis.binding.MapperRegistry#addMapper */ public <T> void addMapper(Class<T> type) { if (type.isInterface()) { if (hasMapper(type)) { throw new BindingException("Type " + type + " is already known to the MapperRegistry."); } boolean loadCompleted = false; try { //加入到configuration.mapperRegistry.knownMappers容器中（Map类型） //type = class.forName(namespace) //Map<type,new MapperProxyFactory<T>(type)> knownMappers.put(type, new MapperProxyFactory<T>(type)); // 将type中methods上的注解@Insert@Delete@Update@Select转化为一个MapperStatement对象放入到configuration.mappedStatements容器中 //<type.getName+method.getName , mapperStatement> MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type); parser.parse(); loadCompleted = true; } finally { if (!loadCompleted) { knownMappers.remove(type); } } } }
小结一下sql的解析：支持sql.xml解析，支持接口解析,下面type.getName == namespace、method.getName == id
① 解析sql为一个MapperStatement对象，然后以<namespace+id , mapperStatement>的映射关系存储到configuration的容器mappedStatements中
② new了一个MapperProxyFactory对象,然后以<type , mapperProxyFactory>的映射关系存储到容器configuration.mapperRegistry.knownMappers中
三、接口映射器
看过sql的解析，然后来研究下sql执行时映射关系。
// 操作数据库方法一（ibatis主要使用方式）：获得xml映射文件中定义的操作语句 User s = session.selectOne("com.app.aop.transactional.mapper.UserMapper.selectByPrimaryKey", 1L); // 打印Student对象 System.out.println(s); // 操作数据库方法二（mybatis主要使用方式）：获得mapper接口的代理对象 UserMapper sm = session.getMapper(UserMapper.class); // 直接调用接口的方法，查询id为1的Student数据 User s2 = sm.selectByPrimaryKey(1L); // 打印Peson对象 System.out.println(s2);
方法一：很简单就是从configuration.mappedStatements.get(namespace+id)，然后执行.主要看方法二：接口映射器实现
1、接口映射器实现
sessiong.getMapper()-->configuration.getMapper()-->configuration.mapperRegistry.getMapper()
/* org.apache.ibatis.binding.MapperRegistry#getMapper */ public <T> T getMapper(Class<T> type, SqlSession sqlSession) { final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type); if (mapperProxyFactory == null) { throw new BindingException("Type " + type + " is not known to the MapperRegistry."); } try { return mapperProxyFactory.newInstance(sqlSession); } catch (Exception e) { throw new BindingException("Error getting mapper instance. Cause: " + e, e); } } /* org.apache.ibatis.binding.MapperProxyFactory*/ public T newInstance(SqlSession sqlSession) { final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache); return newInstance(mapperProxy); } protected T newInstance(MapperProxy<T> mapperProxy) { //实际用JDK动态代理生成了一个代理对象proxy object //mapperProxy是InvokeHandler实例 //那么target object是什么 return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy); }
MapperProxy.invoke() : 动态代理方法执行，好像没有target object 主要是proxy object 中每个method对象都代理sqlsession的一个行为。
例如：userMapper.selectUserById(1L)实际proxyObject.selectUserById(1L)--->sqlSession.selete("com.app.aop.transactional.mapper.UserMapper.selectByPrimaryKey",1L);
/* org.apache.ibatis.binding.MapperProxy#invoke */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { try { if (Object.class.equals(method.getDeclaringClass())) { //Object的方法直接执行mapperProxy的方法 return method.invoke(this, args); } else if (isDefaultMethod(method)) { //静态方法直接执行 return invokeDefaultMethod(proxy, method, args); } } catch (Throwable t) { throw ExceptionUtil.unwrapThrowable(t); } //new MapperMethod(mapperInterface, method, configuration) //实际new sqlCommond(mapperInterface, mehod, configuration) //sqlCommond.name = mapperStatement.getId //sqlCommond.type = ms.getSqlCommondType()--insert|delete|update|select final MapperMethod mapperMethod = cachedMapperMethod(method); //sqlSession根据sqlCommondType执行对应sql，例如当sqlCommondType == select时 //sqlsession.select(sqlCommond.name) return mapperMethod.execute(sqlSession, args); }
mapperMethod.execute()：sql执行
/* org.apache.ibatis.binding.MapperMethod#execute */ public Object execute(SqlSession sqlSession, Object[] args) { Object result; switch (command.getType()) { case INSERT: { Object param = method.convertArgsToSqlCommandParam(args); result = rowCountResult(sqlSession.insert(command.getName(), param)); break; } case UPDATE: { Object param = method.convertArgsToSqlCommandParam(args); result = rowCountResult(sqlSession.update(command.getName(), param)); break; } case DELETE: { Object param = method.convertArgsToSqlCommandParam(args); result = rowCountResult(sqlSession.delete(command.getName(), param)); break; } case SELECT: if (method.returnsVoid() && method.hasResultHandler()) { executeWithResultHandler(sqlSession, args); result = null; } else if (method.returnsMany()) { result = executeForMany(sqlSession, args); } else if (method.returnsMap()) { result = executeForMap(sqlSession, args); } else if (method.returnsCursor()) { result = executeForCursor(sqlSession, args); } else { Object param = method.convertArgsToSqlCommandParam(args); result = sqlSession.selectOne(command.getName(), param); } break; case FLUSH: result = sqlSession.flushStatements(); break; default: throw new BindingException("Unknown execution method for: " + command.getName()); } if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) { throw new BindingException("Mapper method '" + command.getName() + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ")."); } return result; }
四、总结
1、<Configuration>标签实际解析成了一个Configuration对象
2、mapper.xml实际是<configuration>里的一个<mapper>标签，mapper.xml中多个的<select|delete|update|insert>解析成对应的多个MappedStatement对象放入到configuration.mappedStatements（Map<namespace+id, mappedStatement）中
3、接口映射器的实质是通过JDK动态代理，生成一个mapperInterface接口的代理对象，InvokeHandler实例是new MapperProxy(mapperInterface)，调用接口方法实际是调用代理对象的方法，在MapperProxy.invoke方法中调用具体的sqlSession.selectOne(namespace+id, parameters)，找到上面mappedStatement然后执行sql。
