MyBatis是如何为Dao接口创建实现类的

已于 2022-11-28 21:49:17 修改
阅读量824 收藏 3
点赞数 2
分类专栏： 源码级知识 Java 文章标签： mybatis java 开发语言
于 2022-11-28 21:37:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ares___/article/details/128087886
版权

本文是我的MyBatis源码分析专栏中第三节的一小部分，作为试读部分，详细讲述了MyBatis是如何通过动态代理创建Dao接口的实现类的。
专栏地址：MyBatis源码分析

专栏字数:14w+
专栏目录：在这里插入图片描述

文章目录

SqlSession.getMapper如何设计的？

 UserDAO userDAO =  SqlSession.getMapper(UserDAO.class);
    //UserDAO接口的实现类的对象 
    //疑问？ UserDAO接口实现类 在哪里？ 我们写的是xml文件呀？ --> 这是因为动态字节码技术（Spring 的 AOP 也是用了动态字节码技术）
    //动态字节码技术 ---> 类 在JVM 运行时创建 ，JVM运行结束后，消失了

image-20221119115140118

动态自己码技术如何创建的实现类呢？
1. 如何 创建 UserDAO XXXDAO接口的实现类 
             代理 （动态代理）应用场景:
             a. 为原始对象（目标）增加【额外功能】 
             b. 远程代理 1.网络通信 2.输出传输 （RPC）Dubbo 
             c. 接口实现类，我们看不见实实在在的类文件，但是运行时却能体现出来。无中生有
            
Proxy.newProxyIntance(ClassLoader,Interface,InvocationHandler)

SqlSession.getMapper应用了代理模式:

debugSqlSession.getMappe方法可以发现雀氏是个代理对象：

image-20221119113858499

实现类的逻辑
interface UserDAO{
        List<User> queryAllUsers();         
        save(User user);
 }
             

UserDAOImpl implements UserDAO{
 queryAllUsers(){
      sqlSession.select("namespace.id",参数)
                        |-Excutor
                            |-StatementHandler
                                 |- ParameterHandler , ResultSetHandler
                                              TypeHandler 
 }
 save(){
    sqlSession.insert("namespace.id",参数)
  }
}
手写Mapper接口的实现类代理

来回顾一下动态代理设计模式：

image-20221119114310496

核心逻辑需要SqlSession来实现，SqlSession操作JDBC又需要statement，namespace.id: 可以通过接口class和方法名拿到。（接口的方法名不就是mapper标签中的id吗？）

所以代理类的构造方法如下设计：

public class MyMapperProxy implements InvocationHandler {

    private SqlSession sqlSession;

    private Class daoClass;

    public MyMapperProxy(SqlSession sqlSession,Class daoClass){
        this.sqlSession = sqlSession;
        this.daoClass = daoClass;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("namespace:"+daoClass.getName()+"."+method.getName());
        return sqlSession.selectList(daoClass.getName()+"."+method.getName());
    }
}

测试方法如下：

@Test
    public void testPorxy() throws IOException {
        InputStream inputStream = Resources.getResourceAsStream("MyBatis/MyBatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(inputStream);

        SqlSession sqlSession = factory.openSession();
        Class[] interfaces = new Class[]{UserDao.class};
        //创建代理
        UserDao userDao = (UserDao) Proxy.newProxyInstance(
                MybatisTest.class.getClassLoader(),
                interfaces,
                new MyMapperProxy(sqlSession,UserDao.class));

        List<User> users = userDao.queryAll();
        users.forEach(System.out::println);
    }

image-20221119141053617

那如果我们userDao中接口如果有参数呢？Dao中还会有很多方法，上面的例子只有一个方法。

源码探究
  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);
    }
  }
  • mapperProxyFactory.newInstance(sqlSession); 就相当于上面例子中 Proxy.newProxyInstance
MapperProxyFactory核心代码分析：
public class MapperProxyFactory<T> {

  //各种xxxDao的class文件
  private final Class<T> mapperInterface;
  //方法缓存
  private final Map<Method, MapperMethodInvoker> methodCache = new ConcurrentHashMap<>();

  public MapperProxyFactory(Class<T> mapperInterface) {
    this.mapperInterface = mapperInterface;
  }

  public Class<T> getMapperInterface() {
    return mapperInterface;
  }

  public Map<Method, MapperMethodInvoker> getMethodCache() {
    return methodCache;
  }

  @SuppressWarnings("unchecked")
  protected T newInstance(MapperProxy<T> mapperProxy) {
     //核心代码，创建代理，mapperProxy就是具体的代理实现
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }


  public T newInstance(SqlSession sqlSession) {
    //相当于上面简单例子中的MyMapperProxy中的构造方法
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }

}
MapperProxy

看完了创建代理的工厂源码，下面该去看看添加的额外方法了：这里是关键代码，我们结合debug来看。

MapperProxy的构造方法如下：

  public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethodInvoker> methodCache) {
    this.sqlSession = sqlSession;
    this.mapperInterface = mapperInterface;
    //方法缓存
    this.methodCache = methodCache;
  }

最开始的方法缓存是空的：

image-20221119151501346

MapperProxy实现了InvocationHandler,所以我们核心看invoke方法的实现：

public class MapperProxy<T> implements InvocationHandler, Serializable {
    
  // ....
  
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
       //如果是Object中的方法直接执行，例如toString、equals、wait...
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, args);
      } else {
         //核心代码，对dao接口中的方法做了封装，然后再invoke
        return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  }
    // ....
}

这里通过debug来看一下cachedInvoker(method)的作用：

  private MapperMethodInvoker cachedInvoker(Method method) throws Throwable {
    try {
        //computeIfAbsent() 方法对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hashMap 中。
      return MapUtil.computeIfAbsent(methodCache, method, m -> {
        //判断是不是默认方法
        if (m.isDefault()) {
          try {
            if (privateLookupInMethod == null) {
              return new DefaultMethodInvoker(getMethodHandleJava8(method));
            } else {
              return new DefaultMethodInvoker(getMethodHandleJava9(method));
            }
          } catch (IllegalAccessException | InstantiationException | InvocationTargetException
              | NoSuchMethodException e) {
            throw new RuntimeException(e);
          }
        } else {
          //不是默认方法
          return new PlainMethodInvoker(new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
        }
      });
    } catch (RuntimeException re) {
      Throwable cause = re.getCause();
      throw cause == null ? re : cause;
    }
  }

debug发现执行完这个方法，methodCache中有了我们正在调用的userDao中的方法：

image-20221119152920893

那么这个mapperMethod又是什么呢？

MapperMethod
public class MapperMethod {

  private final SqlCommand command;
  private final MethodSignature method;

  public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
    this.command = new SqlCommand(config, mapperInterface, method);
    this.method = new MethodSignature(config, mapperInterface, method);
  }
}

image-20221119153853184

实际上MapperMethod就是封装了两个非常核心的成员变量：

  • SqlCommand ：sql命令

        private final String name; //标签id（namespace.id）
    private final SqlCommandType type;   //Sql命令类型：这条sql是查询还是插入？

public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) {
      final String methodName = method.getName();
      final Class<?> declaringClass = method.getDeclaringClass();
      MappedStatement ms = resolveMappedStatement(mapperInterface, methodName, declaringClass,
          configuration);
      if (ms == null) {
        if (method.getAnnotation(Flush.class) != null) {
          name = null;
          type = SqlCommandType.FLUSH;
        } else {
          throw new BindingException("Invalid bound statement (not found): "
              + mapperInterface.getName() + "." + methodName);
        }
      } else {
        //核心代码
        name = ms.getId();
        type = ms.getSqlCommandType();
        if (type == SqlCommandType.UNKNOWN) {
          throw new BindingException("Unknown execution method for: " + name);
        }
      }
    }

    image-20221119154607485

  • MethodSignature 方法签名（返回值、分页、参数…）

    public static class MethodSignature {

    private final boolean returnsMany;
    private final boolean returnsMap;
    private final boolean returnsVoid;
    private final boolean returnsCursor;
    private final boolean returnsOptional;
    private final Class<?> returnType;
    private final String mapKey;
    private final Integer resultHandlerIndex;
    private final Integer rowBoundsIndex;
    private final ParamNameResolver paramNameResolver;

    public MethodSignature(Configuration configuration, Class<?> mapperInterface, Method method) {
      Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, mapperInterface);
      if (resolvedReturnType instanceof Class<?>) {
        this.returnType = (Class<?>) resolvedReturnType;
      } else if (resolvedReturnType instanceof ParameterizedType) {
        this.returnType = (Class<?>) ((ParameterizedType) resolvedReturnType).getRawType();
      } else {
        this.returnType = method.getReturnType();
      }
      this.returnsVoid = void.class.equals(this.returnType);
      this.returnsMany = configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray();
      this.returnsCursor = Cursor.class.equals(this.returnType);
      this.returnsOptional = Optional.class.equals(this.returnType);
      this.mapKey = getMapKey(method);
      this.returnsMap = this.mapKey != null;
      this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
      this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);
      //@param 中的参数名是如何解析的，在这一步
      this.paramNameResolver = new ParamNameResolver(configuration, method);
    }

    image-20221119155325082

ParamNameResolver方法：处理@Param

public ParamNameResolver(Configuration config, Method method) {
    this.useActualParamName = config.isUseActualParamName();
    final Class<?>[] paramTypes = method.getParameterTypes();
    final Annotation[][] paramAnnotations = method.getParameterAnnotations();
    final SortedMap<Integer, String> map = new TreeMap<>();
    int paramCount = paramAnnotations.length;
    // get names from @Param annotations
    for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {
      if (isSpecialParameter(paramTypes[paramIndex])) {
        // skip special parameters
        continue;
      }
      String name = null;
      for (Annotation annotation : paramAnnotations[paramIndex]) {
        if (annotation instanceof Param) {
          hasParamAnnotation = true;
          name = ((Param) annotation).value();
          break;
        }
      }
      if (name == null) {
        // @Param was not specified.
        if (useActualParamName) {
          name = getActualParamName(method, paramIndex);
        }
        if (name == null) {
          // use the parameter index as the name ("0", "1", ...)
          // gcode issue #71
          name = String.valueOf(map.size());
        }
      }
      map.put(paramIndex, name);
    }
    names = Collections.unmodifiableSortedMap(map);
  }

分析到这里，我们已经将mapper.xml中的各种参数返回值都封装到了MapperMethod中，下面也就该找真正执行sqlSession的地方：

invoke

在MapperProxy类中，真正执行SqlSession相关操作的代码在mapperMethod.execute中

    @Override
    public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {
      return mapperMethod.execute(sqlSession, args);
    }

image-20221119160631450

进入到execute方法中：这里就是我们熟悉的sqlSession方法：

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);
          if (method.returnsOptional()
              && (result == null || !method.getReturnType().equals(result.getClass()))) {
            result = Optional.ofNullable(result);
          }
        }
        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;
  }
结构化思维wz
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
MyBatis-03 (Dao 代理)
小北呱的博客
06-06 194
第3章 MyBatis 框架 Dao 代理 内容列表 Dao 接口动态代理 参数传递 处理查询结果 like 和主键 Dao 代理实现 CURD 步骤 去掉 Dao 接口实现类 getMapper 获取代理对象 只需调用 SqlSession 的getMapper()方法，即可获取指定接口的实现类对象。该方法的参数为指定 Dao 接口类的 class 值。 ...
Mybatis注解开发和编写dao实现类的方式
『愚』的博客
02-08 5730
目录注解开发目录结构一：不需要映射配置文件 IUserDao.xml二：在IUserDao中使用@Select注解三：SqlMapConfig.xml中用注解，此处应该用class属性指定被注解的dao全限定类名测试类不变，运行结果相同编写dao实现类目录结构一：增加一个UserDaoImpl实现类二：测试类有所改变运行结果相同 注解开发 mybatis基于注解的入门案例： 1、把IUserDao.xml移除，在dao接口的方法上使用@Select注解，并且指定SQL语句。 2、同时需要在SqlMapCo
Mybatis编写dao接口实现类
weixin_43157935的博客
03-11 685
使用 Mybatis 开发 Dao，通常有两个方法，即原始 Dao开发方式和 Mapper 接口代理开发方式。而现在主流 的开发方式是接口代理开发方式，这种方式总体上更加简便。现在给大家介绍一下基于传统编写 Dao 实现类的开发方式。 dao接口： package ypy.dao; import ypy.domain.User; import java.util.List; public...
mybatis实现类的方式
不以人人的意志为转义乃天道
01-30 995
尽管你的mybatis实现类的方式是写在实现类中的。但是实现类调用的api中操作的方法还是去xml文件中操作的。 此时的xml其实就是对接口的xml。就是真实的实现类。也就是好比在dao层以后又一次封装了一层。 也就是真实的实现类。让dao去调用然后操作数据库。 接口的方式消除了这个调用的dao层而将xml直接作为了实际dao层调用。实现了接口与类的直接实现直接结合。不在依靠dao中间的ap
mybaits 创建dao的两种实现方式
健康平安的活着的专栏
01-31 822
一.传统的实现dao 1.1 工程结构 1.2 创建dao层 1.dao层接口 package com.mybaits.demo.dao; import com.mybaits.demo.bean.User; import java.io.IOException; import java.util.List; public interface UserMapper { List<User> findAll() throws IOException; } 2.da
MyBatis在webApp中的使用，此种使用方式是实现dao层接口，并未让mybatis自动生成dao接口的实现类
最新发布
01-17
这种方式下，MyBatis并不会自动生成DAO接口的实现类，而是由我们自己实现。这给了我们更大的灵活性，可以自由地控制业务逻辑，同时利用MyBatis的便利性来处理SQL。在大型项目中，这种方式也更有利于代码的组织和维护...
MyBatis的xml+接口方式实现crud功能
12-22
在实际开发中，我们通常会创建一个实现了IUserDao接口的 Dao类，然后在其中注入SqlSession，通过SqlSession调用UserMapper.xml中的SQL语句。 总结起来，MyBatis通过XML映射文件和接口的方式实现CRUD功能，主要涉及...
spring和mybatis整合(原始dao方式实现
04-08
这需要我们在DAO实现类中注入SqlSessionFactory，然后创建SqlSession实例，调用其`openSession()`、`selectOne()`、`insert()`、`update()`、`delete()`等方法来执行SQL。 - 虽然这种方式灵活性较高，但会丢失...
mybatis自动生成dao接口、pojo、mapper.xml
01-10
在MyBatis中，我们通常会为每一个数据库表创建一个对应的DAO接口，接口中的方法对应着SQL操作，如查询、插入、更新和删除。 POJO，即普通的Java对象，它是MyBatis用来映射数据库表记录的Java类。每个属性通常对应表...
Mybatis自动生成dao与model类的工具
04-28
- `<javaModelGenerator>`、`<sqlMapGenerator>`和`<javaClientGenerator>`分别配置Model类、XML映射文件和DAO接口的生成选项。 5. **自定义模板**： - Mybatis Generator允许自定义生成的Java类模板，通过修改或...
java-mybatis逆向工程生成实体类接口
海的那边，还是海吗
12-07 3736
导入对应的依赖包 <plugins> <!--mybatis逆向工程工具--> <plugin> <groupId>org.mybatis.generator</groupId> <artifactId>mybatis-generator-maven-plugin</artifactId> .
接口代理方式实现Dao层
Major_S的博客
12-10 614
对角化和A的幂
Mybatis创建Mapper接口实现类
kandroid的博客
05-21 1310
在Mybatis的开发过程中，程序员更加关注Mapper接口中的方法以及文件的编写。但是我们仅仅只是写了一个方法名和Sql语句，并且接口是不能被实例化的，那么Mybatis是如何通过Mapper接口来执行对应的Sql语句呢？其实是在运行过程中Mybatis通过动态代理的方式创建了Mapper接口的实现类。
Mybatis中编写dao实现类的使用
weixin_65449886的博客
02-22 174
SqlMapConfig.xml配置文件。持久层 Dao 实现类。持久层 Dao 接口。
MyBatis框架（2） —— 自定义MyBatis相关的类和接口
阿水的博客
02-06 350
简介 我们知道创建Maven项目后，在项目中的pom.xml配置文件中引入MyBatis依赖之后，我们就可以使用MyBatis相关的类和接口和相应的功能。 但为了对MyBatis的体系结构和功能有更加深刻的理解和全面的认识，本文Maven项目中的pom.xml配置文件将不再引入MyBatis依赖，转而通过自定义编写MyBatis相关的类和接口来实现同样的功能。 MyBatis相关类和接口的介绍流...
Mybatis为啥要编写实体类？
weixin_52536274的博客
05-20 221
通常来说resultType填写的是你写的实体类 ，通过执行对应的sql从数据库中拿到数据 ， 理论上这个拿到的数据是和你编写的实体类是可以对应上的 后台为你new一个实体类的对象把数据库中拿到的数据封装在这个对象里 最终返回给你看到的数据就是这个对象里面的属性。实体类怎么和数据库中的数据对应上的？能不能不写这个实体类？首先Java万物皆对象，我们编写这个实体类可以将拿到的数据封装成一个对象，有了对象我们就可以更好的去操作它修改它，其次在小的项目中编写实体类更加的方便、代码可读性高。
(5)MyBatis使用javassist动态⽣成DAO接口实现类原理
欢迎阅读我的博客
02-26 559
【代码】(5)MyBatis使用javassist动态⽣成DAO接口实现类原理。
mybatis之DAO层自动实现接口
weixin_30834019的博客
01-15 101
* 使用mybatis举例，使用DAO接口方式实现* 不需要针对接口去编写具体的实现类代码，编写映射XML文件，直接拿来使用即可。* 1、导入jar包：mybatis和mysql-connector* 2、mybatis配置文件：mybatis-config.xml，加载映射XML文件* 3、编写JavaBean类，如UserBean* 4、编写DAO接口和映射XML文件（namespace=DA...
Mybatis-Mapper代理开发
qq_43643867的博客
04-05 352
目的：1、解决原生硬编码的问题 2、便于后期执行sql 好处：首先他不依赖于字符串字面值，会更安全一点；其次，你的IDE有代码补全功能，那么代码补全可以帮你快速选择到映射好的sql语句 步骤： 1、定义与SQL映射文件同名的Mapper接口，并且将Mapper接口与SQL映射文件放置同一目录下 在包下创建接口UserMapper;在resources下创建目录和UserMapper的目录一致 注意：在resources下创建包的层次结构用“/"作为分割符号 2、设置SQL映射文件namespa
mybatis dao接口与mapper多数据源怎么映射
04-04
9. 在 DAO 实现类中使用 @Autowired 注解注入 AbstractRoutingDataSource bean，并在需要访问不同数据源的方法中使用 DataSourceUtils.getConnection() 获取正确的数据源连接。 10. 在需要访问不同数据源的方法中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

结构化思维wz

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值