2021-11-16学习记录 浅析mybatis中mapper代理类执行select的方式

最新推荐文章于 2024-02-28 14:54:19 发布
最新推荐文章于 2024-02-28 14:54:19 发布
阅读量1.4k 收藏 1
点赞数 3
分类专栏： 学习记录 文章标签： xml java spring mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48680790/article/details/121362339
版权

准备一个测试方法

 SqlSession sqlSession = sqlSessionFactory.openSession();
        testMapper mapper = sqlSession.getMapper(testMapper.class);
        List<User> admin = mapper.selectUserByName("test1");

进入selectUserByName()方法;

进入到了MapperProxy.class中

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
            return Object.class.equals(method.getDeclaringClass()) ? method.invoke(this, args) : this.cachedInvoker(method).invoke(proxy, method, args, this.sqlSession);
        } catch (Throwable var5) {
            throw ExceptionUtil.unwrapThrowable(var5);
        }
    }

执行invoke方法，先判断传入的代理对象中是否有与Object类相同的方法(比如clone()，toString()等)，若有则直接执行

若没有则调用cachedInvoker()方法

private MapperProxy.MapperMethodInvoker cachedInvoker(Method method) throws Throwable {
        try {
            return (MapperProxy.MapperMethodInvoker)MapUtil.computeIfAbsent(this.methodCache, method, (m) -> {
                if (m.isDefault()) {
                    try {
                        return privateLookupInMethod == null ? new MapperProxy.DefaultMethodInvoker(this.getMethodHandleJava8(method)) : new MapperProxy.DefaultMethodInvoker(this.getMethodHandleJava9(method));
                    } catch (InstantiationException | InvocationTargetException | NoSuchMethodException | IllegalAccessException var4) {
                        throw new RuntimeException(var4);
                    }
                } else {
                    return new MapperProxy.PlainMethodInvoker(new MapperMethod(this.mapperInterface, method, this.sqlSession.getConfiguration()));
                }
            });
        } catch (RuntimeException var4) {
            Throwable cause = var4.getCause();
            throw (Throwable)(cause == null ? var4 : cause);
        }
    }

可以看到cachedInvoker返回了一个MapperMethodInvoker，顾名思义，是mapper方法的执行器，即为我们自己写的方法的执行器。来到这个方法后，依旧先进行一个判断，若为JVM规定的默认方法，，则调用另一个执行器。显然咱们这里不是，直接return new MapperProxy.PlainMethodInvoker(new MapperMethod(this.mapperInterface, method, this.sqlSession.getConfiguration()));

在将传入的参数封装成了MapperMethod对象后调用了一个PlainMethodInvoker()方法

这个PlainMethodInvoker又是什么呢

    private static class PlainMethodInvoker implements MapperProxy.MapperMethodInvoker {
        private final MapperMethod mapperMethod;

        public PlainMethodInvoker(MapperMethod mapperMethod) {
            this.mapperMethod = mapperMethod;
        }

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

    interface MapperMethodInvoker {
        Object invoke(Object var1, Method var2, Object[] var3, SqlSession var4) throws Throwable;
    }

原来是一个实现了MapperMethodInvoker的一个内部静态类，调用了构造方法创建了一个PlainMethodInvoker 对象。现在再来看这行代码

            return Object.class.equals(method.getDeclaringClass()) ? method.invoke(this, args) : this.cachedInvoker(method).invoke(proxy, method, args, this.sqlSession);

本质就是经过一系列的判断，最后生成一个PlainMethodInvoker并执行他的invoke()方法

而PlainMethodInvoker的invoke方法最终是执行了mapperMethod的execute(）方法

现在进入该方法体探究一下：

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

  public Object execute(SqlSession sqlSession, Object[] args) {
        Object result;
        Object param;
        switch(this.command.getType()) {
        case INSERT:
            param = this.method.convertArgsToSqlCommandParam(args);
            result = this.rowCountResult(sqlSession.insert(this.command.getName(), param));
            break;
        case UPDATE:
            param = this.method.convertArgsToSqlCommandParam(args);
            result = this.rowCountResult(sqlSession.update(this.command.getName(), param));
            break;
        case DELETE:
            param = this.method.convertArgsToSqlCommandParam(args);
            result = this.rowCountResult(sqlSession.delete(this.command.getName(), param));
            break;
        case SELECT:
            if (this.method.returnsVoid() && this.method.hasResultHandler()) {
                this.executeWithResultHandler(sqlSession, args);
                result = null;
            } else if (this.method.returnsMany()) {
                result = this.executeForMany(sqlSession, args);
            } else if (this.method.returnsMap()) {
                result = this.executeForMap(sqlSession, args);
            } else if (this.method.returnsCursor()) {
                result = this.executeForCursor(sqlSession, args);
            } else {
                param = this.method.convertArgsToSqlCommandParam(args);
                result = sqlSession.selectOne(this.command.getName(), param);
                if (this.method.returnsOptional() && (result == null || !this.method.getReturnType().equals(result.getClass()))) {
                    result = Optional.ofNullable(result);
                }
            }
            break;
        case FLUSH:
            result = sqlSession.flushStatements();
            break;
        default:
            throw new BindingException("Unknown execution method for: " + this.command.getName());
        }

        if (result == null && this.method.getReturnType().isPrimitive() && !this.method.returnsVoid()) {
            throw new BindingException("Mapper method '" + this.command.getName() + " attempted to return null from a method with a primitive return type (" + this.method.getReturnType() + ").");
        } else {
            return result;
        }
    }

显示判断增删改查标签，这里我们是select所以进入select对应语句段，再判断返回值类型，我们这里是List类型，所以进入returnMany语句块，执行executeForMany()方法来获得结果。

private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
        Object param = this.method.convertArgsToSqlCommandParam(args);
        List result;
        if (this.method.hasRowBounds()) {
            RowBounds rowBounds = this.method.extractRowBounds(args);
            result = sqlSession.selectList(this.command.getName(), param, rowBounds);
        } else {
            result = sqlSession.selectList(this.command.getName(), param);
        }

在executeForMany方法中首先是对参数进行封装，这里我们先不讨论，接建立一个存放结果的list，先判断该方法是否与分页相关，若相关，则封装一个RowBounds对象再进行查询，若不相关，则直接进行查询，调用的是sqlSession的selectList()方法。

进入selectList()

    public <E> List<E> selectList(String statement, Object parameter) {
        return this.selectList(statement, parameter, RowBounds.DEFAULT);
    }

    public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
        return this.selectList(statement, parameter, rowBounds, Executor.NO_RESULT_HANDLER);
    }

    private <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
        List var6;
        try {
            MappedStatement ms = this.configuration.getMappedStatement(statement);
            var6 = this.executor.query(ms, this.wrapCollection(parameter), rowBounds, handler);
        } catch (Exception var10) {
            throw ExceptionFactory.wrapException("Error querying database.  Cause: " + var10, var10);
        } finally {
            ErrorContext.instance().reset();
        }

        return var6;
    }

经过层层调用，最终来到了含4个参数的selectList()方法，来看一看参数

1.statement：与查询相关

2.parameter: 顾名思义，应该是我们传入的参数

3.Rowbound: 与分页有关的类

4.ReslutHandler: 结果处理器

在方法中，先是获取了配置中的MappedStatement，它包含了所有的与查询相关的信息

 然后执行了executor的query方法，executor本实是一个接口，这里来到的是它的实现类

cacheExecutor中

public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        Cache cache = ms.getCache();
        if (cache != null) {
            this.flushCacheIfRequired(ms);
            if (ms.isUseCache() && resultHandler == null) {
                this.ensureNoOutParams(ms, boundSql);
                List<E> list = (List)this.tcm.getObject(cache, key);
                if (list == null) {
                    list = this.delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
                    this.tcm.putObject(cache, key, list);
                }

                return list;
            }
        }

        return this.delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    }

从类名我们不难猜测，这是一个从缓存中查找结果的类，首先从mapperstatement中获取一个缓存对象，若不为空，则继续进行，再判断是否开启了二级缓存且尚未获得结果，若都符合，则直接从二级缓存中获取，若获取不到，则从数据库中查询，并将查询的结果放入缓存中。

此时是第一次查询，必须从数据库中获取数据。

来到下一个query方法，此时进程从cacheExecutor中来到BaseExecutor中

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
        if (this.closed) {
            throw new ExecutorException("Executor was closed.");
        } else {
            if (this.queryStack == 0 && ms.isFlushCacheRequired()) {
                this.clearLocalCache();
            }

            List list;
            try {
                ++this.queryStack;
                list = resultHandler == null ? (List)this.localCache.getObject(key) : null;
                if (list != null) {
                    this.handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
                } else {
                    list = this.queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
                }
            } finally {
                --this.queryStack;
            }

            if (this.queryStack == 0) {
                Iterator var8 = this.deferredLoads.iterator();

                while(var8.hasNext()) {
                    BaseExecutor.DeferredLoad deferredLoad = (BaseExecutor.DeferredLoad)var8.next();
                    deferredLoad.load();
                }

                this.deferredLoads.clear();
                if (this.configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
                    this.clearLocalCache();
                }
            }

            return list;
        }
    }

首先从一级缓存中获取，若没获取到，则执行.queryFromDatabase()方法，从方法名可以看出，这是从数据库中查询的方法。

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        this.localCache.putObject(key, ExecutionPlaceholder.EXECUTION_PLACEHOLDER);

        List list;
        try {
            list = this.doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
        } finally {
            this.localCache.removeObject(key);
        }

        this.localCache.putObject(key, list);
        if (ms.getStatementType() == StatementType.CALLABLE) {
            this.localOutputParameterCache.putObject(key, parameter);
        }

        return list;
    }

首先将对应的key放入一级缓存，并放入一个常量占位。

再创建一个list来存贮结果。

之后执行查询，最后将查询结果放入缓存中一份。

来到simpleExecutor的doQuery方法

    public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
        Statement stmt = null;

        List var9;
        try {
            Configuration configuration = ms.getConfiguration();
            StatementHandler handler = configuration.newStatementHandler(this.wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
            stmt = this.prepareStatement(handler, ms.getStatementLog());
            var9 = handler.query(stmt, resultHandler);
        } finally {
            this.closeStatement(stmt);
        }

        return var9;
    }

方法中先创建了statement，再获取了配置对象，然后创建了StatementHandler对象，再将创建的statement对象进行预编译，最后用StatementHandler对象进行查询。

来到handler的query()方法

RoutingStatementHandler.class

  public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
        return this.delegate.query(statement, resultHandler);
    }

调用了query方法后来到PreparedStatementHandler.class

    public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
        PreparedStatement ps = (PreparedStatement)statement;
        ps.execute();
        return this.resultSetHandler.handleResultSets(ps);
    }

先把statement包装成PreparedStatement后，调用了熟悉的execute方法，

最后将PreparedStatement对象传进handleResultSets()中，进行结果的解析。

结果封装完成后再一层层的返回，这样就得到了查询的结果。

YOSHINO_Cream
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于Mybatis-plus使用
asa134124的博客
11-29 1792
目录 入门 配置日志 CRUD 主键生成策略 更新操作 自动填充 乐观锁 查询操作 分页查询 删除操作： 逻辑删除​ 性能分析插件 条件构造器 代码自动生成​器 入门 创建数据库 mybatis_plus 创建user表 DROP TABLE IF EXISTS user; CREATE TABLE user ( id BIGINT(20) NOT NULL COMMENT '主键ID', name VARCHAR(30) NULL DEFAULT
mybatis-3-mapper.rar
08-06
mybatis-3-mapper.dtd，解决eclipse使用mybatis时，无法自动提示标签信息的问题
MyBatisPlus条件构造器带条件查询selectList使用示例代码
04-22
MyBatisPlus条件构造器带条件查询selectList使用示例代码
关于MybatisPlus，通过mapper调用selectList方法时返回结果的问题
王大梦的博客
02-18 1616
关于MybatisPlus，通过mapper调用selectList方法时返回结果的问题
动态查询：将mybatis查询sql存在数据库里，执行查询时调用
最新发布
as18214965543的博客
02-28 749
题主经手一个中台系统，大部分需求为查询数据，发版频繁。因为公司使用k8s，一个服务从提交代码到maven docker k8s发版一个工作流下来，至少要十来分钟，效率十分低下。因为多数为查询需求，经常就是写好sql后还得从requestDto controller service mapper responseDto 写一遍，非常浪费时间。
java8 Stream流使用笔记
am的博客
08-31 384
1.使用Comparator 来排序一个list sorted(Comparator.comparingInt(SysDept::getSort)) // 查询全部部门 List<SysDept> deptAllList = deptMapper.selectList(Wrappers.emptyWrapper()); // 查询数据权限内部门 List<Integer> deptOwnIdList = deptMapper.selectListByS
MyBatis-Plus - 快速入门
牧码的博客
06-04 1690
1、数据库建表 # 创建用户表 CREATE TABLE user ( id BIGINT(20) PRIMARY KEY NOT NULL COMMENT '主键', name VARCHAR(30) DEFAULT NULL COMMENT '姓名', age INT(11) DEFAULT NULL COMMENT '年龄', email VARCHAR(50) DEFAULT NULL COMMENT '邮箱', manager...
Mybatis Plus语法+示例
诚的博客
04-12 2292
一、Mybatis plus环境搭建 创建数据库表： -- ---------------------------- -- Table structure for user -- ---------------------------- DROP TABLE IF EXISTS `user`; CREATE TABLE `user` ( `id` bigint(20) NOT NULL, `NAME` varchar(32) CHARACTER SET utf8 COLLATE utf8_gen...
MyBatis-Plus 快速入门
blblccc
02-22 833
MyBatis-Plus 快速入门
MyBatisPlus封装SQL语句
weixin_46704406的博客
12-01 1709
最近对MyBatisPlus的学习有推进了一些，打算对MyBatisPlus对SQL语句的封装进行一个大概的总结。 1.selectList(null) mapper.selectList(null); SQL运行结果： SELECT id,name AS title,age,create_time,update_time,version,status,deleted FROM user 这是从user数据表中查找全部数据，并且还有一个知识点就是name AS title这个其实用到了注解：
mybatis :mapper代理方法 selectOne selectList namespace
sinat_19673215的博客
07-02 1138
selectOne和selectList 动态代理对象调用sqlSession.selectOne()和sqlSession.selectList()是根据mapper接口方法的返回值决定，如果返回list则调用selectList方法，如果返回单个对象则调用selectOne方法。 2.namespace mybatis官方推荐使用mapper代理方法开发mapper接口，程...
mybatis-plus框架基础使用
weixin_46694813的博客
08-30 1977
依赖 1、mysql驱动 <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency> 2、mybatis-plus <d..
Mapper:Mybatis Common Mapper-易于使用
05-10
MyBatis 通用 Mapper4 通用Mapper都可以极大的方便开发人员。可以随意的按照自己的需要选择通用方法，还可以很方便的开发自己的通用方法。 极其方便的使用MyBatis单表的增删改查。 支持单表操作，不支持通用的多表...
mybatis-3-config.dtd mybatis-3-mapper.dtd
10-13
mybatis配置的重要文件包括mybatis-3-config.dtd mybatis-3-mapper.dtd
MyBatis中的mapper接口在查询时，SQL参数是list
PrimaryMe的博客
06-28 3032
Mapper接口中的方法，SQL参数为一个list集合 在使用mybatis进行select查询时，mapper接口中的方法为list，则在sql语句中可以使用 in关键字进行查询，所以，此时就需要遍历查询出mapper接口参数中的list集合中的每一个id对应的对象 可以使用foreach进行遍历，collection是list，在这个例子中，item是遍历出来的每一个id值，可以随意起名字，separator以逗号分隔， 这样就可以查询出sql参数为list的集合 ...
Spring Data JPA之Spring Data JPA快速入门（三）
积跬步，至千里。
10-17 433
Spring Data JPA之Spring Data JPA快速入门Spring Data JPA概述Spring Data JPA 、 JPA、hibernate三者的关系Spring Data JPA的快速入门1.添加依赖2.Spring Data JPA与Spring整合使用JPA注解配置映射关系创建Spring Data JPA规范的Dao层接口基本CRUD操作零零 Spring Data JPA概述 Spring Data JPA 是 Spring 基于 ORM 框架、JPA 规范的基础上封装
Mybatis Mapper XML文件-查询（select）
hay23455的博客
12-20 1789
MyBatis真正的力量在于映射语句（Mapped Statements）。这是魔力发生的地方。尽管拥有强大的功能，Mapper XML文件相对来说比较简单。如果将其与等效的JDBC代码进行比较，您会立即看到代码减少了95%。MyBatis专注于SQL的编写，并尽最大努力不干扰您的方式。
第三节：springboot整合Mybatis（mapper的@Select）
会走的鱼
07-04 1081
【代码】第三节：springboot整合Mybatis（mapper的@Select）
Java学习日报 — 问题记录 — 2021/12/14
来者无穷_
12-14 1536
1、出现问题：org.apache.ibatis.binding.BindingException: Invalid bound statement (not found) 分析：出现没有找到mapper及其selectList方法 原因：Mapper类继承的BaseMapper导入出错，原来的mapper使用的是mybatis plus下的BaseMapper 解决：改为继承base目录下的BaseMapper，该文件使用tk.mybatis，并将selectList方法改为selectByExam
mybatis.config-location=classpath:mybatis/mybatis-config.xml mybatis.mapper-locations=classpath:mybatis/mapper/*.xml
07-13
这是一个典型的MyBatis配置文件中的两个重要配置项：mybatis.config-location和mybatis.mapper-locations。 mybatis.config-location指定了MyBatis的配置文件位置。在这个例子中，配置文件名为mybatis-config.xml，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值