Mybatis源码分析之（三）mapper接口底层原理（为什么不用写方法体就能访问到数据库）

转x33g5p2x  于2022-01-13 转载在 其他  
字(8.4k)|赞(0)|评价(0)|浏览(333)

mybatis是怎么拿sqlSession

在 上一篇的时候，我们的SqlSessionFactoryBuilder已经从xml文件中解析出了Configuration并且返回了sessionFactory。

然后我们要从session;中拿到sqlSession

  1. public class DefaultSqlSessionFactory implements SqlSessionFactory {
  3.   private final Configuration configuration;
  4.   @Override
  5.   public SqlSession openSession() {
  6.   //默认情况下ExecutorType是ExecutorType.SIMPLE类型的
  7.     return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
  8.   }
  10.  private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
  11.     Transaction tx = null;
  12.     try {
  13.     //获取配置的环境信息
  14.       final Environment environment = configuration.getEnvironment();
  15.       //获取environment中的TransactionFactory
  16.       final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
  17.       //生成Transaction
  18.       tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
  19.       //生成Executor（重要，之后的查询都得靠它）
  20.       final Executor executor = configuration.newExecutor(tx, execType);
  21.       //返回DefaultSqlSession
  22.       return new DefaultSqlSession(configuration, executor, autoCommit);
  23.     } catch (Exception e) {
  24.       closeTransaction(tx); // may have fetched a connection so lets call close()
  25.       throw ExceptionFactory.wrapException("Error opening session. Cause: " + e, e);
  26.     } finally {
  27.       ErrorContext.instance().reset();
  28.     }
  29.   }
  30. }
  33. //DefaultSqlSession类的组成，其实新建的时候就只是把他的字段赋值而已
  34. public class DefaultSqlSession implements SqlSession {
  36.   private Configuration configuration;
  37.   private Executor executor;
  39.   private boolean autoCommit;
  40.   private boolean dirty;
  41.   private List<Cursor<?>> cursorList;
  42. }
  44.   public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
  45.     this.configuration = configuration;
  46.     this.executor = executor;
  47.     this.dirty = false;
  48.     this.autoCommit = autoCommit;
  49.   }

上面分析的是到拿到sqlSession为止，重点其实不是在上面这里，因为到上面为止，其实主要的功能只是将配置的信息解析成我们要的类，然后进行初始化赋值。

Mapper的实现原理

下面我们从SqlSession中拿到mapper，并执行方法其实才是，你感觉到mybatis框架开始帮我们做事的开始。

  1. public static void main(String[] args) {
  2.         //拿到SqlSession
  3.         SqlSession sqlsession = MybatisUtil.getSqlsession();
  4.         //拿mapper
  5.         TDemoMapper mapper = sqlsession.getMapper(TDemoMapper.class);
  6.         //调用mapper的方法
  7.         List<TDemo> all = mapper.getAll();
  8.         for (TDemo item : all)
  9.             System.out.println(item);
  11.     }

因为我们在项目中的TDemoMapper只是一个接口，并没有实现这个接口方法，但是为什么我们在调用这个接口方法的时候就可以得到返回结果呢？mybatis究竟做了什么？

首先我们回到之前解析Mapper的语句

  1. mapperElement(root.evalNode("mappers"));
  3.  private void mapperElement(XNode parent) throws Exception {
  4.     if (parent != null) {
  5.       for (XNode child : parent.getChildren()) {
  6.         if ("package".equals(child.getName())) {
  7.           String mapperPackage = child.getStringAttribute("name");
  8.           configuration.addMappers(mapperPackage);
  9.         } else {
  10.           String resource = child.getStringAttribute("resource");
  11.           String url = child.getStringAttribute("url");
  12.           String mapperClass = child.getStringAttribute("class");
  14.           if (resource != null && url == null && mapperClass == null) { //根据resource解析
  15.             ErrorContext.instance().resource(resource);
  16.             InputStream inputStream = Resources.getResourceAsStream(resource);
  17.             XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
  18.             mapperParser.parse();
  19.           } else if (resource == null && url != null && mapperClass == null) {//根据url 解析
  20.             ErrorContext.instance().resource(url);
  21.             InputStream inputStream = Resources.getUrlAsStream(url);
  22.             XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
  23.             mapperParser.parse();
  24.           } else if (resource == null && url == null && mapperClass != null) {//根据mapperClass解析
  25.           //首先通过mapperClass的路径，生成mapperClass的接口类
  26.             Class<?> mapperInterface = Resources.classForName(mapperClass);
  27.             //降mapperClass加入到configuration中去
  28.             configuration.addMapper(mapperInterface);
  29.           } else {
  30.             throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
  31.           }
  32.         }
  33.       }
  34.     }
  35.   }
  38. //Configuration类下
  39.   public <T> void addMapper(Class<T> type) {
  40.     mapperRegistry.addMapper(type);
  41.   }
  43. //MapperRegistry类下
  44. public class MapperRegistry {
  46.   private final Configuration config;
  47.   private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<Class<?>, MapperProxyFactory<?>>();
  49. //最终调用这个方法
  50.   public <T> void addMapper(Class<T> type) {
  51.     if (type.isInterface()) {
  52.       if (hasMapper(type)) {
  53.         throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
  54.       }
  55.       boolean loadCompleted = false;
  56.       try {
  57.       //将接口包装成MapperProxyFactory类放入knownMappers中（knownMappers就是存放我们的mapper接口的）
  58.         knownMappers.put(type, new MapperProxyFactory<T>(type));
  59.         // It's important that the type is added before the parser is run
  60.         // otherwise the binding may automatically be attempted by the
  61.         // mapper parser. If the type is already known, it won't try.
  62.         //通过这个builder来解析mapper的statement。（把mapper和mapper.xml文件相关联，方法名与xml中的id相关联，为了之后调用的时候能找到的语句）
  63.         MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
  64.         //开始解析
  65.         parser.parse();
  66.         loadCompleted = true;
  67.       } finally {
  68.         if (!loadCompleted) {
  69.           knownMappers.remove(type);
  70.         }
  71.       }
  72.     }
  73.   }
  74. }
  76. //MapperAnnotationBuilder类中
  77.   public void parse() {
  78.     String resource = type.toString();
  79.     if (!configuration.isResourceLoaded(resource)) {
  80.     //通过xml文件解析
  81.       loadXmlResource();
  82.       configuration.addLoadedResource(resource);
  83.       assistant.setCurrentNamespace(type.getName());
  84.       parseCache();
  85.       parseCacheRef();
  86.       //获得接口的方法（为了获取方法上的注解，通过注解的方式来让方法于sql语句相关联）
  87.       Method[] methods = type.getMethods();
  88.       for (Method method : methods) {
  89.         try {
  90.           // issue #237
  91.           if (!method.isBridge()) {
  92.           //具体的解析过程
  93.             parseStatement(method);
  94.           }
  95.         } catch (IncompleteElementException e) {
  96.           configuration.addIncompleteMethod(new MethodResolver(this, method));
  97.         }
  98.       }
  99.     }
  100.     parsePendingMethods();
  101.   }

具体的调用过程就不细跟了，无非就是获取节点，获取属性值，（或者是获取方法，然后获取注解信息），巴拉巴拉……然后设置到configuration中。
上面要注意的点是，若既配置xml又配置注解的情况下，注解会覆盖xml，原因非常简单，源码中注解解析在xml解析后面，然后覆盖的情况是，他们有相同的namespace+id。
然后我们继续我们的主线任务，就是mapper的设计架构。从上面我们可以知道，configuration中有一个MapperRegistry类型的字段mapperRegistry，其中有一个字段叫knownMappers，knownMappers里面存着key为接口类型，值为MapperProxyFactory的。

  1. //我们在调用TDemoMapper mapper = sqlsession.getMapper(TDemoMapper.class);的时候
  2. //先调用DefaultSqlSession类下的
  3.   @Override
  4.   public <T> T getMapper(Class<T> type) {
  5.     return configuration.<T>getMapper(type, this);
  6.   }
  7. //然后调用Configuration类下的
  9.   public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
  10.     return mapperRegistry.getMapper(type, sqlSession);
  11.   }
  12.   //最后调用MapperRegistry类下的
  14.   public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
  15.     final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
  16.     if (mapperProxyFactory == null) {
  17.       throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
  18.     }
  19.     try {
  20.         //实际生成是这段代码，通过mapperProxyFactory来生成实例对象
  21.       return mapperProxyFactory.newInstance(sqlSession);
  22.     } catch (Exception e) {
  23.       throw new BindingException("Error getting mapper instance. Cause: " + e, e);
  24.     }
  25.   }
  27. //实际调用类
  28. public class MapperProxyFactory<T> {
  30.   private final Class<T> mapperInterface;
  31.   private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();
  32.   public T newInstance(SqlSession sqlSession) {
  33.       //实例化一个代理类
  34.     final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
  35.     //通过这个函数实例化
  36.     return newInstance(mapperProxy);
  37.   }
  38.   protected T newInstance(MapperProxy<T> mapperProxy) {
  39.       //动态代理的基本操作（说明最终实现方式是动态代理）
  40.     return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  41.   }
  42. }
  44. public class MapperProxy<T> implements InvocationHandler, Serializable {
  46.   private static final long serialVersionUID = -6424540398559729838L;
  47.   private final SqlSession sqlSession;
  48.   private final Class<T> mapperInterface;
  49.   private final Map<Method, MapperMethod> methodCache;
  51.   public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
  52.     this.sqlSession = sqlSession;
  53.     this.mapperInterface = mapperInterface;
  54.     this.methodCache = methodCache;
  55.   }
  56.   //动态代理中最重要的方法invoke
  57.   @Override
  58.   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  59.     try {
  60.       if (Object.class.equals(method.getDeclaringClass())) {
  61.       //如果是Object中的方法就不走下面的代理了，直接执行（比如toString，hashCode）
  62.         return method.invoke(this, args);
  63.       } else if (isDefaultMethod(method)) {
  64.       //如果不是静态方法而且不是抽象方法，则不增强方法
  65.         return invokeDefaultMethod(proxy, method, args);
  66.       }
  67.     } catch (Throwable t) {
  68.       throw ExceptionUtil.unwrapThrowable(t);
  69.     }
  70.     //实际我们的mapper接口的方法走的逻辑就是下面这2条
  71.     final MapperMethod mapperMethod = cachedMapperMethod(method);
  72.     return mapperMethod.execute(sqlSession, args);
  73.   }
  74. }

总结

我们通过sqlSession获得mapper方法，而sqlSession从configuration中的mapperRegistry中获取MapperProxyFactory对象，在通过MapperProxyFactory对象的newInstance方法得到MapperProxy的动态代理实例对象。

我们使用的mapper其实是通过MapperProxy动态代理，在运行时候生成的一个新的对象进行方法增强的，里面的接口方法都会通过下面2个语句进行数据库的操作，以及后续对数据的处理

  1. final MapperMethod mapperMethod = cachedMapperMethod(method);
  2.     return mapperMethod.execute(sqlSession, args);12

这两条语句其实包含对访问数据库对象的创建，访问数据库到得到数据库返回数据后的处理等内容，非常复杂，本篇就到此为止。

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/qq_43842093/article/details/122422061

内容来源于网络，如有侵权，请联系作者删除！

JavamybatisDatabase数据库

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com