mybatis (一)参数解析

最新推荐文章于 2023-02-10 16:29:34 发布
最新推荐文章于 2023-02-10 16:29:34 发布
阅读量509 收藏
点赞数
分类专栏： mybatis分析实战 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44032502/article/details/113616389
版权

参数解析

简介

一 、参数解析规则

1.1 单个参数

    @Select("select * from tb_test where id=#{id}")
    Employee findOne(Long id);

1.2 单个引用类型参数

    /**
     * @param employee
     * @return
     */
    @Select("select * from tb_test where name=#{name} and age=#{age}")
    List<Employee> selectByEntity(Employee employee);

1.3 多个简单参数

  /**
     * 多个参数mybatis会做特殊处理 不能直接使用#{name} #{age}
     * @param name
     * @param age
     * @return
     */
    @Select("select * from tb_test where name=#{name} and age=#{age}")
    List<Employee> selectByNameAndAge(@Param("name") String name, @Param("age") Integer age);

1.4 多个引用类型参数

    /**
     * 复杂参数封装
     * @param employee
     * @return
     */
    @Select("select * from tb_test where name=#{name} and age=#{emp.age}")
    List<Employee> selectByExmaple(@Param("name")String name,@Param("emp") Employee employee);

1.5 map类型参数

    /**
     * 用map封装参数
     * @param employee
     * @return
     */
    @Select("select * from tb_test where name=#{name} and age=#{age}")
    List<Employee> selectByMap(Map<String,Object> employee);

1.6 Collection类型参数

     /**
     * 集合参数
     *  Collection的key是collection
     *  List的key是list
     *  数组的key是array
     * @param list
     * @return
     */
    @Select("select * from tb_test where name=#{list[0]} and age=#{list[1]}")
    List<Employee> selectByList(List<Object> l);

二、 参数解析原理

我们来debug进行分析mybatis的参数解析过程：
dubug这段代码：

 	/**
     * SqlSession非线程安全 测试可以这样使用  切记开发环境不可以这样
     * 开发环境必须从sqlSessionFactory获取
     */
    SqlSession sqlSession;

    @Before
    public void sqlSession() throws IOException {
        String resource = "mybatis/mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        sqlSession = sqlSessionFactory.openSession();
        //sqlSession = sqlSessionFactory.openSession(true); //自动提交

    }

    @After
    public void close() {
        sqlSession.close();
    }
    
    @Test
    public void selectByExmaple(){
        EmploeeMapper mapper = sqlSession.getMapper(EmploeeMapper.class);
        List<Employee> axiba = mapper.selectByNameAndAge("axiba", 20);
        System.out.println(axiba);
    }

public interface EmploeeMapper {

   /**
     * 多个参数mybatis会做特殊处理 不能直接使用#{name} #{age}
     * @param name
     * @param age
     * @return
     */
    @Select("select * from tb_test where name=#{name} and age=#{age}")
    List<Employee> selectByNameAndAge(@Param("name") String name, @Param("age") Integer age);
｝

断点打在 List<Employee> axiba = mapper.selectByNameAndAge("axiba", 20);

1.先判断当前的方法是不是在object中声明的方法，是的话直接放行，不是的话就将Method 包装成一个MapperMethodInvoker 在cachedInvoker中返回一个PlainMethodInvoker对象，最后在invoke方法中调用PlainMethodInvoker对象的invoke方法。invoke中去调用了this.mapperMethod.execute(sqlSession, args);

    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);
        }
    }

    private MapperProxy.MapperMethodInvoker cachedInvoker(Method method) throws Throwable {
        try {
            MapperProxy.MapperMethodInvoker invoker
             = (MapperProxy.MapperMethodInvoker)this.methodCache.get(method);
            return invoker != null ? invoker : 
            	(MapperProxy.MapperMethodInvoker)this.methodCache.computeIfAbsent(
	            	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);
        }
    }
    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);
        }
    }

2.根据sql类型进行分类处理，以本次debug来说，在select中先判断返回值类型，我们的返回值类型为返回对象所以走了method.returnsMany()。参数解析是param = this.method.convertArgsToSqlCommandParam(args);

 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;
        }
    }


    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);
        }

        if (!this.method.getReturnType().isAssignableFrom(result.getClass())) {
            return this.method.getReturnType().isArray() ? this.convertToArray(result) : this.convertToDeclaredCollection(sqlSession.getConfiguration(), result);
        } else {
            return result;
        }
    }

3.参数解析
核心代码
3.1 .获取每个标了@param注解的值，name、age
3.2.每次解析一个参数就给 SortedMap<Integer, String> map中保存消息，（key:参数索引，value:name值）如果标注了param注解value就是注解的值，如果没有标注注解先判断是不是使用了全局参数名配置如果使用就会name=参数名，如果没使用name=map.size()。

    public ParamNameResolver(Configuration config, Method method) {
        this.useActualParamName = config.isUseActualParamName();
        Class<?>[] paramTypes = method.getParameterTypes();
        Annotation[][] paramAnnotations = method.getParameterAnnotations();
        SortedMap<Integer, String> map = new TreeMap();
        int paramCount = paramAnnotations.length;
        for(int paramIndex = 0; paramIndex < paramCount; ++paramIndex) {
            if (!isSpecialParameter(paramTypes[paramIndex])) {
                String name = null;
                Annotation[] var9 = paramAnnotations[paramIndex];
                int var10 = var9.length;
                for(int var11 = 0; var11 < var10; ++var11) {
                    Annotation annotation = var9[var11];
                    if (annotation instanceof Param) {
                        this.hasParamAnnotation = true;
                        name = ((Param)annotation).value();
                        break;
                    }
                }
                if (name == null) {
                    if (this.useActualParamName) {
                        name = this.getActualParamName(method, paramIndex);
                    }
                    if (name == null) {
                        name = String.valueOf(map.size());
                    }
                }
                map.put(paramIndex, name);
            }
        }
        this.names = Collections.unmodifiableSortedMap(map);
    }

在这里插入图片描述
3.3.进入getNamedParams方法会先判断是否有参数，如果没有就返回null，如果有就再判断是单参数还是多参数。单参数如果配置useActualParamName 就返回names的value值。多参数就循环遍历names将names的key作为新的map的value，将names的value作为新的map的key。并添加param+元素索引作为key names的key作为value

   private final SortedMap<Integer, String> names;

   public Object getNamedParams(Object[] args) {
        int paramCount = this.names.size();
        if (args != null && paramCount != 0) {
            if (!this.hasParamAnnotation && paramCount == 1) {
                Object value = args[(Integer)this.names.firstKey()];
                return wrapToMapIfCollection(value, this.useActualParamName ? (String)this.names.get(0) : null);
            } else {
                Map<String, Object> param = new ParamMap();
                int i = 0;

                for(Iterator var5 = this.names.entrySet().iterator(); var5.hasNext(); ++i) {
                    Entry<Integer, String> entry = (Entry)var5.next();
                    param.put(entry.getValue(), args[(Integer)entry.getKey()]);
                    String genericParamName = "param" + (i + 1);
                    if (!this.names.containsValue(genericParamName)) {
                        param.put(genericParamName, args[(Integer)entry.getKey()]);
                    }
                }
                return param;
            }
        } else {
            return null;
        }
    }

在这里插入图片描述

三 、总结

mybatis在参数解析上会把所有参数都封装在一个map中，可以使用@param标记的名字获取也可以使用param+参数索引获取。

帅的唏哩哗啦
关注
专栏目录
MyBatis处理多参数及原理分析
点滴记录
03-11 2156
一、多参数处理方式 1.1使用@Param注解 MyBatis 允许在mapper 接口中使用@Param注解来处理多个参数。 mapper 接口： /** @Param 注解中的值可以是任意的 */ Employee getEmpByIdAndUsername(@Param("id") Integer id, @Param("username") String use...
DRF参数参考
weixin_50018285的博客
09-09 550
drf 参数说明
Mybatis参数解析分析
daliucheng的博客
09-14 347
分析了Mybatis@param是怎么解析的，Mybatis又给我们增加了那些可用的参数，从源码分析，快来看看吧
python add_argument() 方法详解
热门推荐
Vikill
06-22 2万+
首先我们来看一下官方文档的说明，了解一下有哪些参数，接下来的介绍中引用块都是所有官方文档的原文，对于每一个参数及其取值的说明会加上我的个人理解以及举例说明。 下面的官方介绍简单看一下即可，后面分别作详细解释在官方文档中，诸如 这种前面没有 “-” 的参数被称为名称（name），而 这种前面有 “-” 的参数被称为旗标（flags）所谓的位置参数（foo）指的是在命令行参数的顺序必须与name or flags字符串列表中的位置参数顺序一致。反之， 和 则可以在命令行里任意位置指定，前者一般为后者的缩..
parser.add_argument参数
weixin_35749545的博客
02-10 2099
parser.add_argument 是 Python 中的 argparse 库中的一个方法，它的作用是向命令行程序的参数解析器添加参数。 常用的参数有： dest：将该参数存储为命名属性。 type：该参数的数据类型。 default：该参数的默认值。 help：该参数的帮助信息。 required：该参数是否为必需参数。 choices：该参数的可选值列表。 metavar：在帮助信息中...
mybatis 动态sql及参数传递
12-14
目录 使用场景 动态标签 if标签 where标签 choose、when、otherwise 标签 ...if标签通常用那个胡where语句,update语句,insert语句中，通过判断参数值来决定是否使用某个查询条件，判断是否更新某一个字段或插入某个字段
Mybatis日志参数快速替换占位符工具的详细步骤
08-18
Mybatis日志参数快速替换占位符工具是一个实用的辅助工具，它可以帮助开发者在调试过程中更方便地查看和理解Mybatis执行的SQL语句。在默认的日志输出中，Mybatis使用占位符（?）表示传入的参数，这在某些情况下可能...
mybatis SQL日志解析
最新发布
08-07
mybatis SQL日志解析；查看日志时mybatis打印的日志查询条件以及参数不是拼接好的，想复制对应sql在本地执行时比较麻烦，通过前端编写页面进行日志解析，拼接sql中的问号以及参数变课轻松实现
mybatis查询语句揭秘之参数解析
08-26
MyBatis查询语句揭秘之参数解析 MyBatis是一种流行的Java持久层框架，它提供了强大的查询功能。其中，参数解析是MyBatis查询语句中不...了解MyBatis参数解析机制可以帮助我们更好地使用MyBatis框架，并提高开发效率。
Mybatis日志SQL解析工具
03-22
该工具可以将mybatis输出的sql日志提取出来，并将其格式化为可以直接执行的sql语句，节约开发人员时间
python关键字参数顺序无限制_Python新手进阶之路11：全局关键字、变量参数、关键子参数,菜鸟,11global,可变...
weixin_32441957的博客
01-29 398
1. global关键字函数体内部声明的变量通常是局部变量，也就是在函数体的外部是不能使用的。但是如果使用global来声明，则此变量就是全局变量了哈！！！2. 可变参数。*args：表示可变参数,也叫位置参数，需要放到其他参数的后面。如果想放到前面，则需要在实参进行指定。如：def fun1 (a,b,*args):print(a,b,args)fun1(1,2,345,678,90)3. ...
python关键字参数顺序无限制_编写高质量Python代码的59个有效方法 第21条：用只能以关键字形式指定的参数来确保代码明晰...
weixin_42510900的博客
02-09 152
按关键字传参很灵活，可以把函数的用法表达得更明确。例如，计算两数相除，有两种特殊情况。有时我们想忽略ZeroDivisionError异常并返回无穷。有时想忽略OverflowError异常返回0。def sate_division(a, b, ignore_overflow=False, ignore_zero_division=False):try:return a/bexcept Ovefl...
SpringBoot通过ApplicationArguments获取args
weixin_30783629的博客
11-01 729
如果你需要获取通过SpringApplication.run(…​)传输过来的arguments，可以直接注入一个ApplicationArguments即可实现，如下面这个例子： @Service public class ApplicationArgumentService { private final ApplicationArguments applicationA...
mysql 参数定义_MySQL参数学习（一）
weixin_39580748的博客
01-27 831
(1)MySQL参数文件my.cnfMySQL默认参数文件的位置有4个，如果有多个参数文件，则参数采用覆盖原则，后面文件的参数会将前面配置文件的参数覆盖掉。[root@mysqlserver bin]# mysqld --help -v| grep my.cnf /etc/my.cnf /etc/mysql/my.cnf /usr/local/mysql/etc/my.cnf ~/.my.cnfD...
MySQL 数据库 定义参数【连接查询】
君逍遥o
12-05 413
MySQL 数据库 定义参数【连接查询】
MyBatis—MyBatis参数详解
且将&的博客
12-21 2297
MyBatis参数详解
窥探-spring boot应用参数ApplciationArguments
HQ DevJ的专栏
08-11 363
窥探-spring boot应用参数ApplciationArguments简单使用探索ApplciationArgumentsDefaultApplicationArguments实现类CommandLineArgs类 在进行springboot开发的时候，我们启动的时候会使用run方法,代码如下： public static void main(String ... args){ SpringApplication springApplication = new SpringApplicati
运行源码分析：初始化ApplicationArguments
m0_63437643的博客
02-24 496
初始化ApplicationArguments 监 听 器 启 动 之 后 ， 紧接着便是执行ApplicationArguments对象的初始化 ，Application-Arguments 是用于提供访问运行 SpringApplication 时的参数。 ApplicationArguments 的 初 始 化 过 程 非 常 简 单 ， 只 是 调 用 了 它 的 实 现 类 Default-ApplicationArguments 并传入 main 方法中的 args 参数。 Appl.
mysql 参数定义_MySQL中自定义参数如何使用 MySQL中自定义参数使用实例
weixin_39886172的博客
01-18 286
本篇文章小编给大家分享一下MySQL中自定义参数使用实例，小编觉得挺不错的，现在分享给大家供大家参考，有需要的小伙伴们可以来看看。用户自定义变量的声明方法形如：@var_name，其中变量名称由字母、数字、“.”、“_”和“$”组成。当然，在以字符串或者标识符引用时也可以包含其他字符(例如：@'my-var'，@”my-var”，或者@my-var)。用户自定义变量是会话级别的变量。其变量的作用域...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值