精华内容
下载资源
问答
  • 压缩包内含三个word文件,分别有Spring、SpringMVC、Mybatis面试题!!!!!!!!!!!!!!!!!
  • 目录: 1. #{}和${}的区别是什么? 2. 通常一个 Xml 映射文件,都会写一个 Dao 接口与之对应, 请问,这个 Dao 接口的工作原理是什么?...10. 简述 Mybatis 的 Xml 映射文件和 Mybatis 内部数据结构之间的映射关系
  • 【BAT必备】mybatis面试题【BAT必备】mybatis面试题【BAT必备】mybatis面试题【BAT必备】mybatis面试题【BAT必备】mybatis面试题【BAT必备】mybatis面试题【BAT必备】mybatis面试题【BAT必备】mybatis面试题【BAT...
  • day66-mybatis面试题

    2018-06-21 13:02:14
    传智播客2015年JavaEE第33期笔记,mybatis面试题,JVM的内存结构(必问)?
  • MyBatis面试题(2020最新版)

    万次阅读 多人点赞 2019-09-24 16:40:33
    整理好的MyBatis面试题库,史上最全的MyBatis面试题,MyBatis面试宝典,特此分享给大家 MyBatis 介绍 MyBatis 是一款优秀的持久层框架,它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC ...

    Java面试总结(2021优化版)已发布在个人微信公众号【技术人成长之路】,优化版首先修正了读者反馈的部分答案存在的错误,同时根据最新面试总结,删除了低频问题,添加了一些常见面试题,对文章进行了精简优化,欢迎大家关注!😊😊

    【技术人成长之路】,助力技术人成长!更多精彩文章第一时间在公众号发布哦!

    文章目录

    Java面试总结汇总,整理了包括Java基础知识,集合容器,并发编程,JVM,常用开源框架Spring,MyBatis,数据库,中间件等,包含了作为一个Java工程师在面试中需要用到或者可能用到的绝大部分知识。欢迎大家阅读,本人见识有限,写的博客难免有错误或者疏忽的地方,还望各位大佬指点,在此表示感激不尽。文章持续更新中…

    序号内容链接地址
    1Java基础知识面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104390612
    2Java集合容器面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104588551
    3Java异常面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104390689
    4并发编程面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104863992
    5JVM面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104390752
    6Spring面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104397516
    7Spring MVC面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104397427
    8Spring Boot面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104397299
    9Spring Cloud面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104397367
    10MyBatis面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/101292950
    11Redis面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/103522351
    12MySQL数据库面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104778621
    13消息中间件MQ与RabbitMQ面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104588612
    14Dubbo面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104390006
    15Linux面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104588679
    16Tomcat面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104397665
    17ZooKeeper面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104397719
    18Netty面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/104391081
    19架构设计&分布式&数据结构与算法面试题(2020最新版)https://thinkwon.blog.csdn.net/article/details/105870730

    整理好的MyBatis面试题库,史上最全的MyBatis面试题,MyBatis面试宝典,特此分享给大家

    MyBatis简介

    MyBatis是什么?

    MyBatis 是一款优秀的持久层框架,一个半 ORM(对象关系映射)框架,它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。

    ORM是什么

    ORM(Object Relational Mapping),对象关系映射,是一种为了解决关系型数据库数据与简单Java对象(POJO)的映射关系的技术。简单的说,ORM是通过使用描述对象和数据库之间映射的元数据,将程序中的对象自动持久化到关系型数据库中。

    为什么说Mybatis是半自动ORM映射工具?它与全自动的区别在哪里?

    Hibernate属于全自动ORM映射工具,使用Hibernate查询关联对象或者关联集合对象时,可以根据对象关系模型直接获取,所以它是全自动的。

    而Mybatis在查询关联对象或关联集合对象时,需要手动编写sql来完成,所以,称之为半自动ORM映射工具。

    传统JDBC开发存在的问题

    • 频繁创建数据库连接对象、释放,容易造成系统资源浪费,影响系统性能。可以使用连接池解决这个问题。但是使用jdbc需要自己实现连接池。
    • sql语句定义、参数设置、结果集处理存在硬编码。实际项目中sql语句变化的可能性较大,一旦发生变化,需要修改java代码,系统需要重新编译,重新发布。不好维护。
    • 使用preparedStatement向占有位符号传参数存在硬编码,因为sql语句的where条件不一定,可能多也可能少,修改sql还要修改代码,系统不易维护。
    • 结果集处理存在重复代码,处理麻烦。如果可以映射成Java对象会比较方便。

    JDBC编程有哪些不足之处,MyBatis是如何解决这些问题的?

    1、数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能,如果使用数据库连接池可解决此问题。

    解决:在mybatis-config.xml中配置数据链接池,使用连接池管理数据库连接。

    2、Sql语句写在代码中造成代码不易维护,实际应用sql变化的可能较大,sql变动需要改变java代码。

    解决:将Sql语句配置在XXXXmapper.xml文件中与java代码分离。

    3、向sql语句传参数麻烦,因为sql语句的where条件不一定,可能多也可能少,占位符需要和参数一一对应。

    解决: Mybatis自动将java对象映射至sql语句。

    4、对结果集解析麻烦,sql变化导致解析代码变化,且解析前需要遍历,如果能将数据库记录封装成pojo对象解析比较方便。

    解决:Mybatis自动将sql执行结果映射至java对象。

    Mybatis优缺点

    优点

    与传统的数据库访问技术相比,ORM有以下优点:

    • 基于SQL语句编程,相当灵活,不会对应用程序或者数据库的现有设计造成任何影响,SQL写在XML里,解除sql与程序代码的耦合,便于统一管理;提供XML标签,支持编写动态SQL语句,并可重用
    • 与JDBC相比,减少了50%以上的代码量,消除了JDBC大量冗余的代码,不需要手动开关连接
    • 很好的与各种数据库兼容(因为MyBatis使用JDBC来连接数据库,所以只要JDBC支持的数据库MyBatis都支持)
    • 提供映射标签,支持对象与数据库的ORM字段关系映射;提供对象关系映射标签,支持对象关系组件维护
    • 能够与Spring很好的集成

    缺点

    • SQL语句的编写工作量较大,尤其当字段多、关联表多时,对开发人员编写SQL语句的功底有一定要求
    • SQL语句依赖于数据库,导致数据库移植性差,不能随意更换数据库

    MyBatis框架适用场景

    • MyBatis专注于SQL本身,是一个足够灵活的DAO层解决方案。
    • 对性能的要求很高,或者需求变化较多的项目,如互联网项目,MyBatis将是不错的选择。

    Hibernate 和 MyBatis 的区别

    相同点

    都是对jdbc的封装,都是持久层的框架,都用于dao层的开发。

    不同点

    映射关系

    • MyBatis 是一个半自动映射的框架,配置Java对象与sql语句执行结果的对应关系,多表关联关系配置简单
    • Hibernate 是一个全表映射的框架,配置Java对象与数据库表的对应关系,多表关联关系配置复杂

    SQL优化和移植性

    • Hibernate 对SQL语句封装,提供了日志、缓存、级联(级联比 MyBatis 强大)等特性,此外还提供 HQL(Hibernate Query Language)操作数据库,数据库无关性支持好,但会多消耗性能。如果项目需要支持多种数据库,代码开发量少,但SQL语句优化困难。
    • MyBatis 需要手动编写 SQL,支持动态 SQL、处理列表、动态生成表名、支持存储过程。开发工作量相对大些。直接使用SQL语句操作数据库,不支持数据库无关性,但sql语句优化容易。

    开发难易程度和学习成本

    • Hibernate 是重量级框架,学习使用门槛高,适合于需求相对稳定,中小型的项目,比如:办公自动化系统

    • MyBatis 是轻量级框架,学习使用门槛低,适合于需求变化频繁,大型的项目,比如:互联网电子商务系统

    总结

    MyBatis 是一个小巧、方便、高效、简单、直接、半自动化的持久层框架,

    Hibernate 是一个强大、方便、高效、复杂、间接、全自动化的持久层框架。

    MyBatis的解析和运行原理

    MyBatis编程步骤是什么样的?

    1、 创建SqlSessionFactory

    2、 通过SqlSessionFactory创建SqlSession

    3、 通过sqlsession执行数据库操作

    4、 调用session.commit()提交事务

    5、 调用session.close()关闭会话

    请说说MyBatis的工作原理

    在学习 MyBatis 程序之前,需要了解一下 MyBatis 工作原理,以便于理解程序。MyBatis 的工作原理如下图

    MyBatis工作原理

    1)读取 MyBatis 配置文件:mybatis-config.xml 为 MyBatis 的全局配置文件,配置了 MyBatis 的运行环境等信息,例如数据库连接信息。

    2)加载映射文件。映射文件即 SQL 映射文件,该文件中配置了操作数据库的 SQL 语句,需要在 MyBatis 配置文件 mybatis-config.xml 中加载。mybatis-config.xml 文件可以加载多个映射文件,每个文件对应数据库中的一张表。

    3)构造会话工厂:通过 MyBatis 的环境等配置信息构建会话工厂 SqlSessionFactory。

    4)创建会话对象:由会话工厂创建 SqlSession 对象,该对象中包含了执行 SQL 语句的所有方法。

    5)Executor 执行器:MyBatis 底层定义了一个 Executor 接口来操作数据库,它将根据 SqlSession 传递的参数动态地生成需要执行的 SQL 语句,同时负责查询缓存的维护。

    6)MappedStatement 对象:在 Executor 接口的执行方法中有一个 MappedStatement 类型的参数,该参数是对映射信息的封装,用于存储要映射的 SQL 语句的 id、参数等信息。

    7)输入参数映射:输入参数类型可以是 Map、List 等集合类型,也可以是基本数据类型和 POJO 类型。输入参数映射过程类似于 JDBC 对 preparedStatement 对象设置参数的过程。

    8)输出结果映射:输出结果类型可以是 Map、 List 等集合类型,也可以是基本数据类型和 POJO 类型。输出结果映射过程类似于 JDBC 对结果集的解析过程。

    MyBatis的功能架构是怎样的

    Mybatis功能框架
    我们把Mybatis的功能架构分为三层:

    • API接口层:提供给外部使用的接口API,开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。
    • 数据处理层:负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。
    • 基础支撑层:负责最基础的功能支撑,包括连接管理、事务管理、配置加载和缓存处理,这些都是共用的东西,将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。

    MyBatis的框架架构设计是怎么样的

    Mybatis框架架构

    这张图从上往下看。MyBatis的初始化,会从mybatis-config.xml配置文件,解析构造成Configuration这个类,就是图中的红框。

    (1)加载配置:配置来源于两个地方,一处是配置文件,一处是Java代码的注解,将SQL的配置信息加载成为一个个MappedStatement对象(包括了传入参数映射配置、执行的SQL语句、结果映射配置),存储在内存中。

    (2)SQL解析:当API接口层接收到调用请求时,会接收到传入SQL的ID和传入对象(可以是Map、JavaBean或者基本数据类型),Mybatis会根据SQL的ID找到对应的MappedStatement,然后根据传入参数对象对MappedStatement进行解析,解析后可以得到最终要执行的SQL语句和参数。

    (3)SQL执行:将最终得到的SQL和参数拿到数据库进行执行,得到操作数据库的结果。

    (4)结果映射:将操作数据库的结果按照映射的配置进行转换,可以转换成HashMap、JavaBean或者基本数据类型,并将最终结果返回。

    为什么需要预编译

    1. 定义:
      SQL 预编译指的是数据库驱动在发送 SQL 语句和参数给 DBMS 之前对 SQL 语句进行编译,这样 DBMS 执行 SQL 时,就不需要重新编译。

    2. 为什么需要预编译
      JDBC 中使用对象 PreparedStatement 来抽象预编译语句,使用预编译。预编译阶段可以优化 SQL 的执行。预编译之后的 SQL 多数情况下可以直接执行,DBMS 不需要再次编译,越复杂的SQL,编译的复杂度将越大,预编译阶段可以合并多次操作为一个操作。同时预编译语句对象可以重复利用。把一个 SQL 预编译后产生的 PreparedStatement 对象缓存下来,下次对于同一个SQL,可以直接使用这个缓存的 PreparedState 对象。Mybatis默认情况下,将对所有的 SQL 进行预编译。

    Mybatis都有哪些Executor执行器?它们之间的区别是什么?

    Mybatis有三种基本的Executor执行器,SimpleExecutor、ReuseExecutor、BatchExecutor。

    SimpleExecutor:每执行一次update或select,就开启一个Statement对象,用完立刻关闭Statement对象。

    ReuseExecutor:执行update或select,以sql作为key查找Statement对象,存在就使用,不存在就创建,用完后,不关闭Statement对象,而是放置于Map<String, Statement>内,供下一次使用。简言之,就是重复使用Statement对象。

    BatchExecutor:执行update(没有select,JDBC批处理不支持select),将所有sql都添加到批处理中(addBatch()),等待统一执行(executeBatch()),它缓存了多个Statement对象,每个Statement对象都是addBatch()完毕后,等待逐一执行executeBatch()批处理。与JDBC批处理相同。

    作用范围:Executor的这些特点,都严格限制在SqlSession生命周期范围内。

    Mybatis中如何指定使用哪一种Executor执行器?

    在Mybatis配置文件中,在设置(settings)可以指定默认的ExecutorType执行器类型,也可以手动给DefaultSqlSessionFactory的创建SqlSession的方法传递ExecutorType类型参数,如SqlSession openSession(ExecutorType execType)。

    配置默认的执行器。SIMPLE 就是普通的执行器;REUSE 执行器会重用预处理语句(prepared statements); BATCH 执行器将重用语句并执行批量更新。

    Mybatis是否支持延迟加载?如果支持,它的实现原理是什么?

    Mybatis仅支持association关联对象和collection关联集合对象的延迟加载,association指的就是一对一,collection指的就是一对多查询。在Mybatis配置文件中,可以配置是否启用延迟加载lazyLoadingEnabled=true|false。

    它的原理是,使用CGLIB创建目标对象的代理对象,当调用目标方法时,进入拦截器方法,比如调用a.getB().getName(),拦截器invoke()方法发现a.getB()是null值,那么就会单独发送事先保存好的查询关联B对象的sql,把B查询上来,然后调用a.setB(b),于是a的对象b属性就有值了,接着完成a.getB().getName()方法的调用。这就是延迟加载的基本原理。

    当然了,不光是Mybatis,几乎所有的包括Hibernate,支持延迟加载的原理都是一样的。

    映射器

    #{}和${}的区别

    • #{}是占位符,预编译处理;${}是拼接符,字符串替换,没有预编译处理。

    • Mybatis在处理#{}时,#{}传入参数是以字符串传入,会将SQL中的#{}替换为?号,调用PreparedStatement的set方法来赋值。

    • Mybatis在处理 时 , 是 原 值 传 入 , 就 是 把 {}时,是原值传入,就是把 {}替换成变量的值,相当于JDBC中的Statement编译

    • 变量替换后,#{} 对应的变量自动加上单引号 ‘’;变量替换后,${} 对应的变量不会加上单引号 ‘’

    • #{} 可以有效的防止SQL注入,提高系统安全性;${} 不能防止SQL 注入

    • #{} 的变量替换是在DBMS 中;${} 的变量替换是在 DBMS 外

    模糊查询like语句该怎么写

    (1)’%${question}%’ 可能引起SQL注入,不推荐

    (2)"%"#{question}"%" 注意:因为#{…}解析成sql语句时候,会在变量外侧自动加单引号’ ',所以这里 % 需要使用双引号" ",不能使用单引号 ’ ',不然会查不到任何结果。

    (3)CONCAT(’%’,#{question},’%’) 使用CONCAT()函数,推荐

    (4)使用bind标签

    <select id="listUserLikeUsername" resultType="com.jourwon.pojo.User">
      <bind name="pattern" value="'%' + username + '%'" />
      select id,sex,age,username,password from person where username LIKE #{pattern}
    </select>
    

    在mapper中如何传递多个参数

    方法1:顺序传参法

    public User selectUser(String name, int deptId);
    
    <select id="selectUser" resultMap="UserResultMap">
        select * from user
        where user_name = #{0} and dept_id = #{1}
    </select>
    

    #{}里面的数字代表传入参数的顺序。

    这种方法不建议使用,sql层表达不直观,且一旦顺序调整容易出错。

    方法2:@Param注解传参法

    public User selectUser(@Param("userName") String name, int @Param("deptId") deptId);
    
    <select id="selectUser" resultMap="UserResultMap">
        select * from user
        where user_name = #{userName} and dept_id = #{deptId}
    </select>
    

    #{}里面的名称对应的是注解@Param括号里面修饰的名称。

    这种方法在参数不多的情况还是比较直观的,推荐使用。

    方法3:Map传参法

    public User selectUser(Map<String, Object> params);
    
    <select id="selectUser" parameterType="java.util.Map" resultMap="UserResultMap">
        select * from user
        where user_name = #{userName} and dept_id = #{deptId}
    </select>
    

    #{}里面的名称对应的是Map里面的key名称。

    这种方法适合传递多个参数,且参数易变能灵活传递的情况。

    方法4:Java Bean传参法

    public User selectUser(User user);
    
    <select id="selectUser" parameterType="com.jourwon.pojo.User" resultMap="UserResultMap">
        select * from user
        where user_name = #{userName} and dept_id = #{deptId}
    </select>
    

    #{}里面的名称对应的是User类里面的成员属性。

    这种方法直观,需要建一个实体类,扩展不容易,需要加属性,但代码可读性强,业务逻辑处理方便,推荐使用。

    Mybatis如何执行批量操作

    使用foreach标签

    foreach的主要用在构建in条件中,它可以在SQL语句中进行迭代一个集合。foreach标签的属性主要有item,index,collection,open,separator,close。

    • item  表示集合中每一个元素进行迭代时的别名,随便起的变量名;
    • index  指定一个名字,用于表示在迭代过程中,每次迭代到的位置,不常用;
    • open  表示该语句以什么开始,常用“(”;
    • separator表示在每次进行迭代之间以什么符号作为分隔符,常用“,”;
    • close  表示以什么结束,常用“)”。

    在使用foreach的时候最关键的也是最容易出错的就是collection属性,该属性是必须指定的,但是在不同情况下,该属性的值是不一样的,主要有一下3种情况:

    1. 如果传入的是单参数且参数类型是一个List的时候,collection属性值为list
    2. 如果传入的是单参数且参数类型是一个array数组的时候,collection的属性值为array
    3. 如果传入的参数是多个的时候,我们就需要把它们封装成一个Map了,当然单参数也可以封装成map,实际上如果你在传入参数的时候,在MyBatis里面也是会把它封装成一个Map的,
      map的key就是参数名,所以这个时候collection属性值就是传入的List或array对象在自己封装的map里面的key

    具体用法如下:

    <!-- 批量保存(foreach插入多条数据两种方法)
           int addEmpsBatch(@Param("emps") List<Employee> emps); -->
    <!-- MySQL下批量保存,可以foreach遍历 mysql支持values(),(),()语法 --> //推荐使用
    <insert id="addEmpsBatch">
        INSERT INTO emp(ename,gender,email,did)
        VALUES
        <foreach collection="emps" item="emp" separator=",">
            (#{emp.eName},#{emp.gender},#{emp.email},#{emp.dept.id})
        </foreach>
    </insert>
    
    <!-- 这种方式需要数据库连接属性allowMutiQueries=true的支持
     如jdbc.url=jdbc:mysql://localhost:3306/mybatis?allowMultiQueries=true -->  
    <insert id="addEmpsBatch">
        <foreach collection="emps" item="emp" separator=";">                                 
            INSERT INTO emp(ename,gender,email,did)
            VALUES(#{emp.eName},#{emp.gender},#{emp.email},#{emp.dept.id})
        </foreach>
    </insert>
    

    使用ExecutorType.BATCH

    Mybatis内置的ExecutorType有3种,默认为simple,该模式下它为每个语句的执行创建一个新的预处理语句,单条提交sql;而batch模式重复使用已经预处理的语句,并且批量执行所有更新语句,显然batch性能将更优; 但batch模式也有自己的问题,比如在Insert操作时,在事务没有提交之前,是没有办法获取到自增的id,这在某型情形下是不符合业务要求的

    具体用法如下

    //批量保存方法测试
    @Test  
    public void testBatch() throws IOException{
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        //可以执行批量操作的sqlSession
        SqlSession openSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
    
        //批量保存执行前时间
        long start = System.currentTimeMillis();
        try {
            EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
            for (int i = 0; i < 1000; i++) {
                mapper.addEmp(new Employee(UUID.randomUUID().toString().substring(0, 5), "b", "1"));
            }
    
            openSession.commit();
            long end = System.currentTimeMillis();
            //批量保存执行后的时间
            System.out.println("执行时长" + (end - start));
            //批量 预编译sql一次==》设置参数==》10000次==》执行1次   677
            //非批量  (预编译=设置参数=执行 )==》10000次   1121
    
        } finally {
            openSession.close();
        }
    }
    

    mapper和mapper.xml如下

    public interface EmployeeMapper {   
        //批量保存员工
        Long addEmp(Employee employee);
    }
    
    <mapper namespace="com.jourwon.mapper.EmployeeMapper"
         <!--批量保存员工 -->
        <insert id="addEmp">
            insert into employee(lastName,email,gender)
            values(#{lastName},#{email},#{gender})
        </insert>
    </mapper>
    

    如何获取生成的主键

    对于支持主键自增的数据库(MySQL)

    <insert id="insertUser" useGeneratedKeys="true" keyProperty="userId" >
        insert into user( 
        user_name, user_password, create_time) 
        values(#{userName}, #{userPassword} , #{createTime, jdbcType= TIMESTAMP})
    </insert>
    

    parameterType 可以不写,Mybatis可以推断出传入的数据类型。如果想要访问主键,那么应当parameterType 应当是java实体或者Map。这样数据在插入之后 可以通过ava实体或者Map 来获取主键值。通过 getUserId获取主键

    不支持主键自增的数据库(Oracle)

    对于像Oracle这样的数据,没有提供主键自增的功能,而是使用序列的方式获取自增主键。
    可以使用<selectKey>标签来获取主键的值,这种方式不仅适用于不提供主键自增功能的数据库,也适用于提供主键自增功能的数据库
    <selectKey>一般的用法

    <selectKey keyColumn="id" resultType="long" keyProperty="id" order="BEFORE">
    </selectKey> 
    
    属性描述
    keyPropertyselectKey 语句结果应该被设置的目标属性。如果希望得到多个生成的列,也可以是逗号分隔的属性名称列表。
    keyColumn匹配属性的返回结果集中的列名称。如果希望得到多个生成的列,也可以是逗号分隔的属性名称列表。
    resultType结果的类型,MyBatis 通常可以推算出来。MyBatis 允许任何简单类型用作主键的类型,包括字符串。如果希望作用于多个生成的列,则可以使用一个包含期望属性的 Object 或一个 Map。
    order值可为BEFORE 或 AFTER。如果是 BEFORE,那么它会先执行selectKey设置 keyProperty 然后执行插入语句。如果为AFTER则相反。
    statementType使用何种语句类型,默认PREPARED。 有STATEMENT,PREPARED 和 CALLABLE 语句的映射类型。
    <insert id="insertUser" >
    	<selectKey keyColumn="id" resultType="long" keyProperty="userId" order="BEFORE">
    		SELECT USER_ID.nextval as id from dual 
    	</selectKey> 
    	insert into user( 
    	user_id,user_name, user_password, create_time) 
    	values(#{userId},#{userName}, #{userPassword} , #{createTime, jdbcType= TIMESTAMP})
    </insert>
    

    此时会将Oracle生成的主键值赋予userId变量。这个userId 就是USER对象的属性,这样就可以将生成的主键值返回了。如果仅仅是在insert语句中使用但是不返回,此时keyProperty=“任意自定义变量名”,resultType 可以不写。
    Oracle 数据库中的值要设置为 BEFORE ,这是因为 Oracle中需要先从序列获取值,然后将值作为主键插入到数据库中。

    扩展
    如果Mysql 使用selectKey的方式获取主键,需要注意下面两点:

    order : AFTER
    获取递增主键值 :SELECT LAST_INSERT_ID()

    当实体类中的属性名和表中的字段名不一样 ,怎么办

    第1种: 通过在查询的SQL语句中定义字段名的别名,让字段名的别名和实体类的属性名一致。

    <select id="getOrder" parameterType="int" resultType="com.jourwon.pojo.Order">
           select order_id id, order_no orderno ,order_price price form orders where order_id=#{id};
    </select>
    

    第2种: 通过<resultMap>来映射字段名和实体类属性名的一一对应的关系。

    <select id="getOrder" parameterType="int" resultMap="orderResultMap">
    	select * from orders where order_id=#{id}
    </select>
    
    <resultMap type="com.jourwon.pojo.Order" id="orderResultMap">
        <!–用id属性来映射主键字段–>
        <id property="id" column="order_id">
    
        <!–用result属性来映射非主键字段,property为实体类属性名,column为数据库表中的属性–>
        <result property ="orderno" column ="order_no"/>
        <result property="price" column="order_price" />
    </reslutMap>
    

    Mapper 编写有哪几种方式?

    第一种:接口实现类继承 SqlSessionDaoSupport:使用此种方法需要编写mapper 接口,mapper 接口实现类、mapper.xml 文件。

    (1)在 sqlMapConfig.xml 中配置 mapper.xml 的位置

    <mappers>
        <mapper resource="mapper.xml 文件的地址" />
        <mapper resource="mapper.xml 文件的地址" />
    </mappers>
    

    (2)定义 mapper 接口

    (3)实现类集成 SqlSessionDaoSupport

    mapper 方法中可以 this.getSqlSession()进行数据增删改查。

    (4)spring 配置

    <bean id=" " class="mapper 接口的实现">
        <property name="sqlSessionFactory"
        ref="sqlSessionFactory"></property>
    </bean>
    

    第二种:使用 org.mybatis.spring.mapper.MapperFactoryBean:

    (1)在 sqlMapConfig.xml 中配置 mapper.xml 的位置,如果 mapper.xml 和mappre 接口的名称相同且在同一个目录,这里可以不用配置

    <mappers>
        <mapper resource="mapper.xml 文件的地址" />
        <mapper resource="mapper.xml 文件的地址" />
    </mappers>
    

    (2)定义 mapper 接口:

    (3)mapper.xml 中的 namespace 为 mapper 接口的地址

    (4)mapper 接口中的方法名和 mapper.xml 中的定义的 statement 的 id 保持一致

    (5)Spring 中定义

    <bean id="" class="org.mybatis.spring.mapper.MapperFactoryBean">
        <property name="mapperInterface" value="mapper 接口地址" />
        <property name="sqlSessionFactory" ref="sqlSessionFactory" />
    </bean>
    

    第三种:使用 mapper 扫描器:

    (1)mapper.xml 文件编写:

    mapper.xml 中的 namespace 为 mapper 接口的地址;

    mapper 接口中的方法名和 mapper.xml 中的定义的 statement 的 id 保持一致;

    如果将 mapper.xml 和 mapper 接口的名称保持一致则不用在 sqlMapConfig.xml中进行配置。

    (2)定义 mapper 接口:

    注意 mapper.xml 的文件名和 mapper 的接口名称保持一致,且放在同一个目录

    (3)配置 mapper 扫描器:

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="mapper 接口包地址
        "></property>
        <property name="sqlSessionFactoryBeanName"
        value="sqlSessionFactory"/>
    </bean>
    

    (4)使用扫描器后从 spring 容器中获取 mapper 的实现对象。

    什么是MyBatis的接口绑定?有哪些实现方式?

    接口绑定,就是在MyBatis中任意定义接口,然后把接口里面的方法和SQL语句绑定,我们直接调用接口方法就可以,这样比起原来了SqlSession提供的方法我们可以有更加灵活的选择和设置。

    接口绑定有两种实现方式

    通过注解绑定,就是在接口的方法上面加上 @Select、@Update等注解,里面包含Sql语句来绑定;

    通过xml里面写SQL来绑定, 在这种情况下,要指定xml映射文件里面的namespace必须为接口的全路径名。当Sql语句比较简单时候,用注解绑定, 当SQL语句比较复杂时候,用xml绑定,一般用xml绑定的比较多。

    使用MyBatis的mapper接口调用时有哪些要求?

    1、Mapper接口方法名和mapper.xml中定义的每个sql的id相同。

    2、Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql 的parameterType的类型相同。

    3、Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同。

    4、Mapper.xml文件中的namespace即是mapper接口的类路径。

    最佳实践中,通常一个Xml映射文件,都会写一个Dao接口与之对应,请问,这个Dao接口的工作原理是什么?Dao接口里的方法,参数不同时,方法能重载吗

    Dao接口,就是人们常说的Mapper接口,接口的全限名,就是映射文件中的namespace的值,接口的方法名,就是映射文件中MappedStatement的id值,接口方法内的参数,就是传递给sql的参数。Mapper接口是没有实现类的,当调用接口方法时,接口全限名+方法名拼接字符串作为key值,可唯一定位一个MappedStatement,举例:com.mybatis3.mappers.StudentDao.findStudentById,可以唯一找到namespace为com.mybatis3.mappers.StudentDao下面id = findStudentById的MappedStatement。在Mybatis中,每一个<select><insert><update><delete>标签,都会被解析为一个MappedStatement对象。

    Dao接口里的方法,是不能重载的,因为是全限名+方法名的保存和寻找策略。

    Dao接口的工作原理是JDK动态代理,Mybatis运行时会使用JDK动态代理为Dao接口生成代理proxy对象,代理对象proxy会拦截接口方法,转而执行MappedStatement所代表的sql,然后将sql执行结果返回。

    Mybatis的Xml映射文件中,不同的Xml映射文件,id是否可以重复?

    不同的Xml映射文件,如果配置了namespace,那么id可以重复;如果没有配置namespace,那么id不能重复;毕竟namespace不是必须的,只是最佳实践而已。

    原因就是namespace+id是作为Map<String, MappedStatement>的key使用的,如果没有namespace,就剩下id,那么,id重复会导致数据互相覆盖。有了namespace,自然id就可以重复,namespace不同,namespace+id自然也就不同。

    简述Mybatis的Xml映射文件和Mybatis内部数据结构之间的映射关系?

    答:Mybatis将所有Xml配置信息都封装到All-In-One重量级对象Configuration内部。在Xml映射文件中,<parameterMap>标签会被解析为ParameterMap对象,其每个子元素会被解析为ParameterMapping对象。<resultMap>标签会被解析为ResultMap对象,其每个子元素会被解析为ResultMapping对象。每一个<select><insert><update><delete>标签均会被解析为MappedStatement对象,标签内的sql会被解析为BoundSql对象。

    Mybatis是如何将sql执行结果封装为目标对象并返回的?都有哪些映射形式?

    第一种是使用<resultMap>标签,逐一定义列名和对象属性名之间的映射关系。

    第二种是使用sql列的别名功能,将列别名书写为对象属性名,比如T_NAME AS NAME,对象属性名一般是name,小写,但是列名不区分大小写,Mybatis会忽略列名大小写,智能找到与之对应对象属性名,你甚至可以写成T_NAME AS NaMe,Mybatis一样可以正常工作。

    有了列名与属性名的映射关系后,Mybatis通过反射创建对象,同时使用反射给对象的属性逐一赋值并返回,那些找不到映射关系的属性,是无法完成赋值的。

    Xml映射文件中,除了常见的select|insert|updae|delete标签之外,还有哪些标签?

    还有很多其他的标签,<resultMap><parameterMap><sql><include><selectKey>,加上动态sql的9个标签,trim|where|set|foreach|if|choose|when|otherwise|bind等,其中<sql>为sql片段标签,通过<include>标签引入sql片段,<selectKey>为不支持自增的主键生成策略标签。

    Mybatis映射文件中,如果A标签通过include引用了B标签的内容,请问,B标签能否定义在A标签的后面,还是说必须定义在A标签的前面?

    虽然Mybatis解析Xml映射文件是按照顺序解析的,但是,被引用的B标签依然可以定义在任何地方,Mybatis都可以正确识别。

    原理是,Mybatis解析A标签,发现A标签引用了B标签,但是B标签尚未解析到,尚不存在,此时,Mybatis会将A标签标记为未解析状态,然后继续解析余下的标签,包含B标签,待所有标签解析完毕,Mybatis会重新解析那些被标记为未解析的标签,此时再解析A标签时,B标签已经存在,A标签也就可以正常解析完成了。

    高级查询

    MyBatis实现一对一,一对多有几种方式,怎么操作的?

    有联合查询和嵌套查询。联合查询是几个表联合查询,只查询一次,通过在resultMap里面的association,collection节点配置一对一,一对多的类就可以完成

    嵌套查询是先查一个表,根据这个表里面的结果的外键id,去再另外一个表里面查询数据,也是通过配置association,collection,但另外一个表的查询通过select节点配置。

    Mybatis是否可以映射Enum枚举类?

    Mybatis可以映射枚举类,不单可以映射枚举类,Mybatis可以映射任何对象到表的一列上。映射方式为自定义一个TypeHandler,实现TypeHandler的setParameter()和getResult()接口方法。

    TypeHandler有两个作用,一是完成从javaType至jdbcType的转换,二是完成jdbcType至javaType的转换,体现为setParameter()和getResult()两个方法,分别代表设置sql问号占位符参数和获取列查询结果。

    动态SQL

    Mybatis动态sql是做什么的?都有哪些动态sql?能简述一下动态sql的执行原理不?

    Mybatis动态sql可以让我们在Xml映射文件内,以标签的形式编写动态sql,完成逻辑判断和动态拼接sql的功能,Mybatis提供了9种动态sql标签trim|where|set|foreach|if|choose|when|otherwise|bind。

    其执行原理为,使用OGNL从sql参数对象中计算表达式的值,根据表达式的值动态拼接sql,以此来完成动态sql的功能。

    插件模块

    Mybatis是如何进行分页的?分页插件的原理是什么?

    Mybatis使用RowBounds对象进行分页,它是针对ResultSet结果集执行的内存分页,而非物理分页,可以在sql内直接书写带有物理分页的参数来完成物理分页功能,也可以使用分页插件来完成物理分页。

    分页插件的基本原理是使用Mybatis提供的插件接口,实现自定义插件,在插件的拦截方法内拦截待执行的sql,然后重写sql,根据dialect方言,添加对应的物理分页语句和物理分页参数。

    举例:select * from student,拦截sql后重写为:select t.* from (select * from student) t limit 0, 10

    简述Mybatis的插件运行原理,以及如何编写一个插件。

    Mybatis仅可以编写针对ParameterHandler、ResultSetHandler、StatementHandler、Executor这4种接口的插件,Mybatis使用JDK的动态代理,为需要拦截的接口生成代理对象以实现接口方法拦截功能,每当执行这4种接口对象的方法时,就会进入拦截方法,具体就是InvocationHandler的invoke()方法,当然,只会拦截那些你指定需要拦截的方法。

    实现Mybatis的Interceptor接口并复写intercept()方法,然后在给插件编写注解,指定要拦截哪一个接口的哪些方法即可,记住,别忘了在配置文件中配置你编写的插件。

    缓存

    Mybatis的一级、二级缓存

    1)一级缓存: 基于 PerpetualCache 的 HashMap 本地缓存,其存储作用域为 Session,当 Session flush 或 close 之后,该 Session 中的所有 Cache 就将清空,默认打开一级缓存。

    2)二级缓存与一级缓存其机制相同,默认也是采用 PerpetualCache,HashMap 存储,不同在于其存储作用域为 Mapper(Namespace),并且可自定义存储源,如 Ehcache。默认不打开二级缓存,要开启二级缓存,使用二级缓存属性类需要实现Serializable序列化接口(可用来保存对象的状态),可在它的映射文件中配置<cache/>

    3)对于缓存数据更新机制,当某一个作用域(一级缓存 Session/二级缓存Namespaces)的进行了C/U/D 操作后,默认该作用域下所有 select 中的缓存将被 clear。

    展开全文
  • 2021年MyBatis面试题30道

    千次阅读 多人点赞 2021-03-25 18:25:25
    文章目录前言面试题系列文章传送门MyBatis面试题内容1. 模糊查询like语句该怎么写?2. MyBatis 框架适用场合?3. MyBatis是如何进行分页的?分页插件的原理是什么?4. Dao 接口里的方法,参数不同时,方法能重载吗?5...

    文章目录


    前言

    作为应届生,处于找工作中ing。今年2月份刚刚整理出来的面试题,时间比较赶就没有按照模块分类排序了。总而言之,顺序比较乱,希望大家耐着性子 看。如果实在介意,评论告知,我会视情况作修改的。另外如果大家觉得我找的答案不够清晰,欢迎私信或者评论只出,我看到都会去修改的!


    面试题系列文章传送门

    2021年后端开发面试题整理合集


    MyBatis面试题内容

    1. 模糊查询like语句该怎么写?

    在Java代码中添加sql通配符。
    在sql语句中拼接通配符,但是会引起sql注入

    2. MyBatis 框架适用场合?

    MyBatis专注于SQL本身,是一个足够灵活的DAO层解决方案。
    对性能的要求很高,或者需求变化较多的项目,如互联网项目,MyBatis将是不错的选择。

    3. MyBatis是如何进行分页的?分页插件的原理是什么?

    Mybatis使用RowBounds对象进行分页,它是针对ResultSet结果集执行的内存分页,而非物理分页。也可以直接编写SQL实现分页或者使用分页插件。
    分页插件的原理:实现MyBatis提供的接口来实现自定义插件,然后在插件的拦截方法内拦截待执行的SQL,最后重写SQL。

    4. Dao 接口里的方法,参数不同时,方法能重载吗?

    Mapper 接口里的方法,是不能重载的,因为是使用全限名+方法名的保存和寻找策略。Mapper 接口的工作原理是 JDK 动态代理,Mybatis 运行时会使用 JDK动态代理为 Mapper 接口生成代理对象 proxy,代理对象会拦截接口方法,转而执行 MapperStatement 所代表的 sql,然后将 sql 执行结果返回。

    5. MyBatis是如何将sql执行结果封装为目标对象并返回的?都有哪些映射形式?

    使用resultMap标签,定义数据库列名和对象属性名之间的映射关系。
    使用sql列的别名功能,将列的别名书写为对象属性名。
    有了列名与属性名的映射关系后,MyBatis通过反射创建对象,同时使用反射给对象的属性逐一赋值并返回。

    6. Mybaits 的优缺点?

    优点:
    基于SQL语句编程,相当灵活,不会对应用程序或者数据库的现有设计造成任何影响,SQL写在XML里,解除sql与程序代码的耦合,便于统一管理;提供XML标签,支持编写动态SQL语句,并可重用。
    与JDBC相比,减少了50%以上的代码量,消除了JDBC大量冗余的代码,不需要手动开关连接;
    很好的与各种数据库兼容,能够与 Spring 很好的集成;
    提供映射标签,支持对象与数据库的ORM字段关系映射;提供对象关系映射标签,支持对象关系组件维护。
    缺点:
    SQL语句的编写工作量较大,尤其当字段多、关联表多时,对开发人员编写SQL语句的功底有一定要求。
    QL语句依赖于数据库,导致数据库移植性差,不能随意更换数据库。

    7. 谈谈你对MyBatis的理解?

    MyBatis是一个可以自定义SQL、存储过程和高级映射的持久层框架,它内部封装了JDBC,开发时只需要关注SQL语句本身。程序员直接编写原生态SQL,可以严格控制sql执行性能,灵活度高。

    8. MyBatis的Xml映射文件中,不同的Xml映射文件,id是否可以重复?

    不同的Xml映射文件,如果配置了namespace,id可以重复。如果没有配置namespace,id不能重复。原因是namespace+id是作为Map<String,MapperStatement>的key使用的,如果没有namespace,id重复会导致数据互相覆盖。有了namespace,id就可以重复,namespace不同,namespace+id自然也就不同。

    9. #{}和${}的区别是什么?

    #是预编译处理,KaTeX parse error: Expected 'EOF', got '#' at position 19: …串替换。 Mybatis在处理#̲时,会将sql中的#{}替换为…时,就是把$替换成变量的值。
    使用#可以有效的防止SQL注入,提高系统安全性。

    10. 当实体类中的属性名和表中的字段名不一样 ,怎么办?

    通过在查询的sql语句中定义字段名的别名。
    通过resultMap标签来映射字段名和实体类属性名的一一对应的关系。

    11. Mybatis映射文件中,如果A标签通过include引用了B标签的内容,请问B标签能否定义在A标签的后面,还是说必须定义在A标签的前面?

    Mybatis解析Xml映射文件是按照顺序解析的,但是被引用的B标签定义在任何地方Mybatis都可以正确识别。原理是Mybatis解析A标签,发现A标签引用了B标签,但是B标签尚未解析到,此时会将A标签标记为未解析状态,然后继续解析余下的标签,包含B标签。待所有标签解析完毕,Mybatis会重新解析那些被标记为未解析的标签,此时再解析A标签时,B标签已经存在,A标签也就可以正常解析完成了。

    12. MyBats中的 一对一、一对多的关联查询 ?

    定义一个resultMap,使用association属性实现一对一的关联查询;使用collection属性实现一对多的关联查询。

    13. MyBatis实现一对一有几种方式?具体怎么操作的?

    联合查询是几个表联合查询,只查询一次, 通过在resultMap里面配置association节点配置一对一的类就可以完成;
    嵌套查询先查一个表,根据这个表里面的结果的外键id,去再另外一个表里面查询数据,也是通过association配置,但另外一个表的查询通过select属性配置。

    14. MyBatis 的好处是什么?

    把sql语句从 Java 源程序中独立出来,放在单独的XML文件中编写,给程序的维护带来了很大便利。
    能自动将结果集转换成Java Bean对象,大大简化了Java数据库编程的重复工作。
    程序员可以结合数据库自身的特点灵活控制sql语句,能够完成复杂查询。

    15. 讲一下MyBatis的一级、二级缓存(说说MyBatis的缓存)?

    MyBatis的缓存分为一级缓存和二级缓存,一级缓存放在session里面,默认就有。二级缓存放在它的命名空间里,默认是不打开的,使用二级缓存属性类需要实现Serializable序列化接口,可在它的映射文件中配置cache标签

    16. Mapper 编写有哪几种方式?

    接口实现类继承 SqlSessionDaoSupport,需要编写mapper 接口,mapper 接口实现类、mapper.xml 文件。
    在 sqlMapConfig.xml 中配置 mapper.xml 的位置
    定义 mapper 接口
    实现类集成 SqlSessionDaoSupportmapper 方法中可以 this.getSqlSession()进行数据增删改查。
    spring 配置
    使用 org.mybatis.spring.mapper.MapperFactoryBean,在 sqlMapConfig.xml 中配置 mapper.xml 的位置,定义 mapper 接口:
    mapper.xml 中的 namespace 为 mapper 接口的地址
    mapper 接口中的方法名和 mapper.xml 中的定义的 statement 的 id 保持一致
    Spring 中定义
    第三种:使用mapper扫描器:
    mapper.xml 文件编写:
    定义 mapper 接口,注意 mapper.xml 的文件名和 mapper 的接口名称保持一致,且放在同一个目录
    配置 mapper 扫描器:
    使用扫描器后从 spring 容器中获取 mapper 的实现对象。

    17. MyBatis在mapper中如何传递多个参数?

    直接在方法中传递参数,xml文件用#符号来获取
    使用@param注解或者多个参数封装成 map

    18. MyBatis 是否支持延迟加载?如果支持,它的实现原理是什么?

    MyBatis仅支持association关联对象和collection关联集合对象的延迟加载,association指的就是一对一,collection指的就是一对多查询。在 MyBatis配置文件中,可以通过 lazyLoadingEnabled=true/false 配置是否启用延迟加载。
    原理是:使用CGLIB创建目标对象的代理对象,当调用目标方法时会进入拦截器方法,比如调用a.getB().getName(),拦截器invoke()方法发现a.getB()是null值,那么就会单独发送事先保存好的查询关联B对象的sql,把B查询上来,然后调用a.setB(),于是a的对象b属性就有值了,接着完成a.getB().getName()方法的调用。

    19. Xml 映射文件中,除了常见的 select、insert、updae、delete标签之外,还有哪些标签?

    resultMap、parameterMap、sql、include、selectKey,加上动态sql的9个标签,其中sql为sql片段标签,通过include标签标签引入sql片段,selectKey标签为不支持自增的主键生成策略标签。

    20. 通常一个Xml映射文件,都会写一个Dao接口与之对应,请问这个 Dao 接口的工作原理是什么,是否可以重载?

    不能重载,因为通过Dao寻找Xml对应sql的时候,使用全限名+方法名的保存和寻找策略。Dao接口工作原理为jdk动态代理原理,运行时会为dao生成proxy,代理对象会拦截接口方法,去执行对应的sql返回数据。

    21. 什么是MyBatis的接口绑定?有哪些实现方式?

    接口绑定是在MyBatis中任意定义接口,然后把接口里面的方法和SQL语句绑定。
    接口绑定有两种实现方式:
    通过注解绑定,在接口的方法上面加上@Select、@Update等注解,里面包含Sql语句来绑定;
    通过xml里面写SQL来绑定,要指定xml映射文件里面的namespace必须为接口的全路径名。
    当Sql语句比较简单时候,用注解绑定;当SQL语句比较复杂时候,用xml绑定,一般用 xml 绑定的比较多。

    22. MyBatis如何获取自动生成的(主)键值?

    在insert标签中使用useGeneratedKeys和keyProperty两个属性来获取自动生成的主键值。

    23. 使用MyBatis的mapper接口调用时有哪些要求?

    Mapper 接口方法名和 mapper.xml 中定义的每个 sql 的 id 相同;
    Mapper 接口方法的输入参数类型和 mapper.xml 中定义的每个 sql 的parameterType 的类型相同;
    Mapper 接口方法的输出参数类型和 mapper.xml 中定义的每个 sql 的resultType 的类型相同;
    Mapper.xml 文件中的 namespace 即是 mapper 接口的类路径。

    24. MyBatis 动态sql有什么用?执行原理?有哪些动态sql?

    MyBatis动态sql可以在Xml映射文件内,以标签的形式编写动态sql。
    执行原理是根据表达式的值完成逻辑判断并动态拼接 sql 的功能。
    MyBatis提供了9种动态sql标签:trim、where、set、foreach、if、choose、when、otherwise、bind。

    25. MyBatis是否可以映射 Enum 枚举类?

    MyBatis不单可以映射枚举类,还可以映射任何对象到表的一列上。映射方式为自定义一个TypeHandler,实现TypeHandler的setParameter()和getResult()接口方法。TypeHandler有两个作用,一是完成从javaType至jdbcType的转换,二是完成jdbcType至javaType的转换,体现为setParameter()和getResult()两个方法,分别代表设置sql问号占位符参数和获取列查询结果。

    26. Mybatis能执行一对一、一对多的关联查询吗?都有哪些实现方式,以及它们之间的区别?

    Mybatis不仅可以执行一对一、一对多的关联查询,还可以执行多对一,多对多的关联查询。多对一查询,其实就是一对一查询,只需要把selectOne()修改为selectList()即可;多对多查询,其实就是一对多查询,只需要把selectOne()修改为selectList()即可。
    关联对象查询有两种实现方式,一种是单独发送一个sql去查询关联对象,赋给主对象,然后返回主对象。另一种是使用嵌套查询,嵌套查询的含义为使用join查询,一部分列是A对象的属性值,另外一部分列是关联对象B的属性值,好处是只发一个sql查询,就可以把主对象和其关联对象查出来。

    27. MyBatis里面的动态Sql是怎么设定的?用什么语法?

    MyBatis里面的动态Sql一般是通过if节点来实现,通过OGNL语法来实现,但是如果要写的完整,必须配合where,trim节点,where节点是判断包含节点有内容就插入where,否则不插入,trim节点是用来判断如果动态语句是以and或or开始,那么会自动把这个and或者or取掉。

    28. 简述MyBatis的插件运行原理,以及如何编写一个插件?

    运行原理:MyBatis只能编写针对ParameterHandler、ResultSetHandler、StatementHandler、Executor四种接口的插件,MyBatis通过动态代理,为需要拦截的接口生成代理对象以实现接口方法拦截功能,每当执行这四种接口对象的方法时,就会进入拦截方法。具体就是调用InvocationHandler的invoke()方法,只会拦截指定需要拦截的方法。
    编写插件:实现MyBatis的Interceptor接口并复写 ntercept()方法,然后给插件编写注解,指定要拦截哪一个接口的哪些方法,最后在配置文件中配置编写的插件。

    29. 为什么说Mybatis是半自动 ORM 映射工具?它与全自动的区别在哪里?

    Mybatis在查询关联对象或关联集合对象时,需要手动编写sql来完成,所以称之为半自动ORM映射工具。

    30. resultType和resultMap的区别?

    类的名字和数据库相同时,可以直接设置resultType参数为Pojo类。若不同,需要设置resultMap将结果名字和Pojo名字进行转换。


    有问题欢迎私信/评论指出,谢谢您的观看,希望对您有帮助哦!
    https://lianghongbin.blog.csdn.net/

    展开全文
  • 文章目录1、什么是Mybatis?2、Mybaits的优点?3、MyBatis框架的缺点?4、MyBatis框架适用场合5、MyBatis与Hibernate有哪些不同?6、#{} 和${}的区别是什么?7、当实体类中的属性名和表中的字段名不一样,怎么办?8...

    文章目录

    最近面试的小伙伴很多,对此我整理了一份Java面试题手册:基础知识、JavaOOP、Java集合/泛型面试题、Java异常面试题、Java中的IO与NIO面试题、Java反射、Java序列化、Java注解、多线程&并发、JVM、Mysql、Redis、Memcached、MongoDB、Spring、SpringBoot、SpringCloud、RabbitMQ、Dubbo、MyBatis、ZooKeeper、数据结构、算法、Elasticsearch、Kafka、微服务、Linux等等。可以分享给大家学习。【持续更新中】

    完整版Java面试题地址:【2021最新版】Java面试真题汇总

    序号内容地址链接
    1【2021最新版】JavaOOP面试题总结https://blog.csdn.net/m0_48795607/article/details/115288673
    2【2021最新版】Java基础面试题总结https://blog.csdn.net/m0_48795607/article/details/115485109
    3【2021最新版】多线程&并发面试题总结https://blog.csdn.net/m0_48795607/article/details/115489616
    4【2021最新版】JVM面试题总结https://blog.csdn.net/m0_48795607/article/details/115555086
    5【2021最新版】Mysql面试题总结https://blog.csdn.net/m0_48795607/article/details/115561030
    6【2021最新版】Redis面试题总结https://blog.csdn.net/m0_48795607/article/details/115642129
    7【2021最新版】Memcached面试题总结https://blog.csdn.net/m0_48795607/article/details/115664662
    8【2021最新版】MongoDB面试题总结https://blog.csdn.net/m0_48795607/article/details/115672336
    9【2021最新版】Spring面试题总结https://blog.csdn.net/m0_48795607/article/details/115738909
    10【2021最新版】Spring Boot面试题总结https://blog.csdn.net/m0_48795607/article/details/115771307
    11【2021最新版】Spring Cloud面试题总结https://blog.csdn.net/m0_48795607/article/details/115917190
    12【2021最新版】RabbitMQ面试题总结https://blog.csdn.net/m0_48795607/article/details/116064045
    13【2021最新版】Dubbo面试题总结https://blog.csdn.net/m0_48795607/article/details/116237861
    14【2021最新版】ZooKeeper面试题总结https://blog.csdn.net/m0_48795607/article/details/116458096
    15【2021最新版】数据结构面试题总结https://blog.csdn.net/m0_48795607/article/details/116461620
    16【2021最新版】算法面试题总结https://blog.csdn.net/m0_48795607/article/details/116461620
    17【2021最新版】Elasticsearch面试题总结https://blog.csdn.net/m0_48795607/article/details/116656094
    18【2021最新版】Kafka面试题总结https://blog.csdn.net/m0_48795607/article/details/116659584
    19【2021最新版】微服务面试题总结https://blog.csdn.net/m0_48795607/article/details/116662109
    20【2021最新版】Linux面试题总结https://blog.csdn.net/m0_48795607/article/details/116798880

    1、什么是Mybatis?

    答:

    1、Mybatis是一个半ORM(对象关系映射)框架,它内部封装了JDBC,开发时只需要关注SQL语句本身,不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。程序员直接编写原生态sql,可以严格控制sql执行性能,灵活度高。

    2、MyBatis可以使用XML或注解来配置和映射原生信息,将POJO映射成数据库中的记录,避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。

    3、通过xml文件或注解的方式将要执行的各种statement配置起来,并通过java对象和statement中sql的动态参数进行映射生成最终执行的sql语句,最后由mybatis框架执行sql并将结果映射为java对象并返回。(从执行sql到返回result的过程)。

    2、Mybaits的优点?

    答:

    1、基于SQL语句编程,相当灵活,不会对应用程序或者数据库的现有设计造成任何影响,SQL写在XML里,解除sql与程序代码的耦合,便于统一管理;提供XML标签,支持编写动态SQL语句,并可重用。

    2、与JDBC相比,减少了50%以上的代码量,消除了JDBC大量冗余的代码,不需要手动开关连接;

    3、很好的与各种数据库兼容(因为 MyBatis 使用 JDBC 来连接数据库,所以只要JDBC支持的数据库MyBatis都支持)。

    4、能够与Spring很好的集成;

    5、提供映射标签,支持对象与数据库的ORM字段关系映射;提供对象关系映射标签,支持对象关系组件维护。

    3、MyBatis框架的缺点?

    答:

    1、SQL语句的编写工作量较大,尤其当字段多、关联表多时,对开发人员编写SQL语句的功底有一定要求。

    2、SQL语句依赖于数据库,导致数据库移植性差,不能随意更换数据库。

    4、MyBatis框架适用场合

    答:

    1、MyBatis专注于SQL本身,是一个足够灵活的DAO层解决方案。

    2、对性能的要求很高,或者需求变化较多的项目,如互联网项目,MyBatis将是不错的选择。

    5、MyBatis与Hibernate有哪些不同?

    答:

    1、Mybatis和hibernate不同,它不完全是一个ORM框架,因为MyBatis需要程序员自己编写Sql语句。

    2、Mybatis直接编写原生态sql,可以严格控制sql执行性能,灵活度高,非常适合对关系数据模型要求不高的软件开发,因为这类软件需求变化频繁,一但需求变化要求迅速输出成果。但是灵活的前提是mybatis无法做到数据库无关性,如果需要实现支持多种数据库的软件,则需要自定义多套sql映射文件,工作量大。

    3、Hibernate对象/关系映射能力强,数据库无关性好,对于关系模型要求高的软件,如果用hibernate开发可以节省很多代码,提高效率。

    6、#{} 和${}的区别是什么?

    答:

    #{}是预编译处理,${}是字符串替换。

    Mybatis在处理#{}时,会将sql中的#{}替换为?号,调用PreparedStatement的set方法来赋值;

    Mybatis在处理 时 , 就 是 把 {}时,就是把 {}替换成变量的值。

    使用#{}可以有效的防止SQL注入,提高系统安全性

    7、当实体类中的属性名和表中的字段名不一样,怎么办?

    答:

    第1种: 通过在查询的sql语句中定义字段名的别名,让字段名的别名和实体类的属性名一致。

    第2种: 通过来映射字段名和实体类属性名的一一对应的关系。

    8、 模糊查询like语句该怎么写?

    答:
    第1种:在Java代码中添加sql通配符。

    第2种:在sql语句中拼接通配符,会引起sql注入

    9、通常一个Xml映射文件,都会写一个Dao接口与之对应, 请问,这个Dao接口的工作原理是什么?Dao接口里的方法, 参数不同时,方法能重载吗?

    答:

    Dao接口,就是人们常说的Mapper接口,接口的全限名,就是映射文件中的namespace的值,接口的方法名,就是映射文件中MappedStatement的id值,接口方法内的参数,就是传递给sql的参数。Mapper接口是没有实现类的,当调用接口方法时,接口全限名+方法名拼接字符串作为key值,可唯一定位一个MappedStatement,举例:

    com.mybatis3.mappers.StudentDao.findStudentById,可以唯一找到namespace为 com.mybatis3.mappers.StudentDao下面id = findStudentById的MappedStatement。在Mybatis中,每一个、、、 标签,都会被解析为一个MappedStatement对象。 Dao接口里的方法,是不能重载的,因为是全限名+方法名的保存和寻找策略。

    Dao接口的工作原理是JDK动态代理,Mybatis运行时会使用JDK动态代理为Dao接口生成代理proxy对象,代理对象proxy会拦 截接口方法,转而执行MappedStatement所代表的sql,然后将sql执行结果返回。

    10、Mybatis是如何进行分页的?分页插件的原理是什么?

    答:

    Mybatis使用RowBounds对象进行分页,它是针对ResultSet结果集执行的内存分页,而非物理分页,可以在sql内直接书写带有物理分页的参数来完成物理分页功能,也可以使用分页插件来完成物理分页。 分页插件的基本原理是使用Mybatis提供的插件接口,实现自定义插件,在插件的拦截方法内拦截待执行的sql,然后重写sql,根据dialect方言,添加对应的物理分页语句和物理分页参数。

    11、Mybatis是如何将sql执行结果封装为目标对象并返回的?都有哪些映射形式?

    答:

    第一种是使用标签,逐一定义列名和对象属性名之间的映射关系。第二 种是使用sql列的别名功能,将列别名书写为对象属性名,比如T_NAME AS NAME,对象属性名一般是name,小写,但是列名不区分大小写,Mybatis会忽略列名大小 写,智能找到与之对应对象属性名,你甚至可以写成T_NAME AS NaMe,Mybatis一样可以正常工作。

    有了列名与属性名的映射关系后,Mybatis通过反射创建对象,同时使用反射给对象的属性逐一赋值并返回,那些找不到映射关系的属性,是无法完成赋值的。

    12、 Mybatis如何执行批量操作

    答:

    使用foreach标签

    foreach的主要用在构建in条件中,它可以在SQL语句中进行迭代一个集合。foreach标签的属性主要有item,index,collection,open,separator,close。

    1.item   表示集合中每一个元素进行迭代时的别名,随便起的变量名;
    2.index   指定一个名字,用于表示在迭代过程中,每次迭代到的位置,不常用;
    3.open   表示该语句以什么开始,常用“(”;
    4.separator 表示在每次进行迭代之间以什么符号作为分隔符,常用“,”;
    5.close   表示以什么结束,常用“)”。

    在使用foreach的时候最关键的也是最容易出错的就是collection属性,该属性是必须指定的,但是
    在不同情况下,该属性的值是不一样的,主要有一下3种情况:

    1. 如果传入的是单参数且参数类型是一个List的时候,collection属性值为list
    2. 如果传入的是单参数且参数类型是一个array数组的时候,collection的属性值为array
    3. 如果传入的参数是多个的时候,我们就需要把它们封装成一个Map了,当然单参数也可以封装成map,实际上如果你在传入参数的时候,在MyBatis里面也是会把它封装成一个Map的,map的key就是参数名,所以这个时候collection属性值就是传入的List或array对象在自己封装的map里面的key

    具体用法如下:


    使用ExecutorType.BATCH

    1.Mybatis内置的ExecutorType有3种,默认为simple,该模式下它为每个语句的执行创建一个新的预处理语句,单条提交sql;而batch模式重复使用已经预处理的语句,并且批量执行所有更新语句,显然batch性能将更优; 但batch模式也有自己的问题,比如在Insert操作时,在事务没有提交之前,是没有办法获取到自增的id,这在某型情形下是不符合业务要求的

    2.具体用法如下:


    在这里插入图片描述
    3.mapper和mapper.xml如下
    在这里插入图片描述
    在这里插入图片描述

    13、如何获取自动生成的(主)键值?

    答:

    insert方法总是返回一个int值 ,这个值代表的是插入的行数。

    如果采用自增长策略,自动生成的键 值在insert方法执行完后可以被设置到传入的参数对象中 。

    示例 :

    14、在mapper中如何传递多个参数?

    答:

    1、第一种:

    DAO 层的函数

    .public UserselectUser(String name,String area);
    

    对应的 xml,#{0}代表接收的是 dao 层中的第一个参数,#{1}代表 dao 层中第二
    参数,更多参数一致往后加即可。

    <select id="selectUser"resultMap="BaseResultMap"> select * fromuser_user_t whereuser_name = #{0} anduser_area=#{1} </select>
    

    2、第二种: 使用 @param 注解

    public interface usermapper { user selectuser(@param(“username”) string username,@param(“hashedpassword”) string hashedpassword); }
    

    然后,就可以在 xml 像下面这样使用(推荐封装为一个 map,作为单个参数传递给mapper

    <select id=”selectuser” resulttype=”user”> select id, username, hashedpassword from some_table where username = #{username} and hashedpassword = #{hashedpassword} </select>
    

    3、第三种:多个参数封装成 map

    try {//映射文件的命名空间.SQL 片段的 ID,就可以调用对应的映射文件中的SQL //由于我们的参数超过了两个,而方法中只有一个 Object 参数收集,因此我们使用 Map 集合来装载我们的参数 Map < String, Object > map = new HashMap(); map.put("start", start); map.put("end", end); return sqlSession.selectList("StudentID.pagination", map); } catch (Exception e) { e.printStackTrace(); sqlSession.rollback(); throw e; }finally { MybatisUtil.closeSqlSession(); }
    

    15、Mybatis动态sql有什么用?执行原理?有哪些动态 sql?

    答:

    Mybatis动态sq可以在Xml映射文件内,以标签的形式编写动态sql,执行原理是根 据表达式的值完成逻辑判断并动态拼接sql的功能。

    Mybatis提供了9种动态sql标签 :trim | where | set | foreach | if | choose| when | otherwise | bind。

    16、Xml映射文件中,除了常见的select|insert|updae|delete 标签之外,还有哪些标签?

    答:

    注:这道题出自京东面试官。 还有很多其他的标签 , 加上动态sql的9个标签 。

    trim|where|set|foreach|if|choose|when|otherwise|bind 等,其中为sql片段标签,通过标签引sql片段,为不支持自增的主键生成策略标签。

    18、为什么说Mybatis是半自动ORM映射工具?它与全动的区别在哪里?

    答:

    Hibernate属于全自动ORM映射工具,使用Hibernate查询关联对象或者关联集合对象时,可以根据对象关系模型直接获取,所以它是全自动的。而Mybatis在查询关联对象或关联集合对象时,需要手动编写sql来完成,所以,称之为半自动ORM映射工具。

    19、 一对一、一对多的关联查询 ?

    答:

    20、MyBatis实现一对一有几种方式?具体怎么操作的?

    答:

    有联合查询和嵌套查询,联合查询是几个表联合查询,只查询一次, 通过在resultMap里面配置association节点配置一对一的类就可以完成;嵌套查询是先查一个表,根据这个表里面的结果的 外键id,去再另外一个表里面查询数据,也是通过association配置,但另外一个表的查询通过select属性配置。

    21、MyBatis实现一对多有几种方式,怎么操作的?

    答:

    有联合查询和嵌套查询。联合查询是几个表联合查询,只查询一次,通过在resultMap 里面的collection节点配置一对多的类就可以完成;嵌套查询是先查一个表,根据这个表里面的结果的外键id,去再另外一个表里面查询数据,也是通过配置collection,但另外一个表的查询通过select节点配置。

    22、Mybatis是否支持延迟加载?如果支持,它的实现原理是什么?

    答:

    Mybatis仅支持association关联对象和collection关联集合对象的延迟加载,association指的就是一对一,collection指的就是一对多查询。在Mybatis配置文件中,可以配置是否启用延迟加载lazyLoadingEnabled=true|false。

    它的原理是,使用CGLIB创建目标对象的代理对象,当调用目标方法时,进入拦截器方法,比如调用a.getB().getName(),拦截器invoke()方法发现a.getB()是null 值,那么就会单独发送事先保存好的查询关联B对象的sql,把B查询上来,然后调用a.setB(b),于是a的对象b属性就有值了,接着完成a.getB().getName()方法的调用。这就是延迟加载的基本原理。

    当然了,不光是Mybatis,几乎所有的包括Hibernate,支持延迟加载的原理都是一样的。

    23、Mybatis的一级、二级缓存:

    答:
    1)一级缓存:基于PerpetualCache的HashMap本地缓存,其存储作用域为Session,当Session flush或close之后,该 Session中的所有Cache就将清空,默认打开一级缓存。

    2)二级缓存与一级缓存其机制相同,默认也是采用PerpetualCache,HashMap存储,不同在于其存储作用域为Mapper(Namespace),并且可自定义存储源,如Ehcache。默认不打开二级缓存,要开启二级缓存,使用二级缓存属性类需要实现Serializable序列化接口(可用来保存对象的状态),可在它的映射文件中配置 ;

    3)对于缓存数据更新机制,当某一个作用域(一级缓存Session/二级缓存Namespaces)的进行了C/U/D操作后,默认该作用域下所有select中的缓存将被clear。

    24、什么是MyBatis的接口绑定?有哪些实现方式?

    答:
    接口绑定,就是在MyBatis中任意定义接口,然后把接口里面的方法和SQL语句绑定, 我们直接调用接口方法就可以,这样比起原来了SqlSession提供的方法我们可以有更加灵活的选择和设置。

    接口绑定有两种实现方式,一种是通过注解绑定,就是在接口的方法上面加上@Select、@Update等注解,里面包含Sql语句来绑定;另外一种就是通过xml里面写SQL来绑定,在这种情况下,要指定xml 映射文件里面的namespace必须为接口的全路径名。当Sql语句比较简单时候,用注解绑定, 当SQL语句比较复杂时候,用xml绑定,一般用xml绑定的比较多。

    25、使用MyBatis的mapper接口调用时有哪些要求?

    答:

    1、Mapper接口方法名和mapper.xml中定义的每个sql的id相同;

    2、Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql的parameterType的类型相同;

    3、Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同;

    4、Mapper.xml文件中的namespace即是mapper接口的类路径。

    26、Mapper编写有哪几种方式?

    答: .

    第一种:接口实现类继承SqlSessionDaoSupport:使用此种方法需要编写mapper接口,mapper接口实现类、mapper.xml文件。

    1、在sqlMapConfig xml中配置mapper xml的位置

    <mappers>
    <mapper resource="mapper.xml 文件的地址" />
    <mapper resource="mapper.xml 文件的地址" />
    </mappers>
    

    2、定义mapper接口

    3、实现类集成SqlSessionDaoSupport mapper方法中可以this getSqlSession()进行数据增删改查。

    4、spring配置

    <bean id=" " class="mapper 接口的实现">
    <property name="sqlSessionFactory"
    ref="sqlSessionFactory"></property>
    </bean>
    

    第二种:使用org.mybatis.spring.mapper.MapperFactoryBean:

    1、在 sqlMapConfig.xml中配置mapper.xml的位置,如果mapper.xml 和mappre接口的名称相同且在同一个目录,这里可以不用配置

    <mappers>
    <mapper resource="mapper.xml 文件的地址" />
    <mapper resource="mapper.xml 文件的地址" />
    </mappers>
    

    2、定义mapper接口:

    1、mapper.xml中的namespace为mapper接口的地址

    2、mapper接口中的方法名和mapper.xml中的定义的statement的id保持一致

    3、Spring中定义

    <bean id="" class="org.mybatis.spring.mapper.MapperFactoryBean">
    <property name="mapperInterface" value="mapper 接口地址" />
    <property name="sqlSessionFactory" ref="sqlSessionFactory" />
    </bean>
    

    第三种:使用mapper扫描器:

    1、mapper.xml文件编写:

    mapper.xml中的namespace为mapper接口的地址;

    mapper接口中的方法名和mapper.xml中的定义的statement的id保持一致;

    如果将mapper.xml和mapper接口的名称保持一致则不用在sqlMapConfig.xml中进行配置。

    2、定义mapper接口:

    注意mapper.xml的文件名和mapper的接口名称保持一致,且放在同一个目录

    3、配置mapper扫描器:

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="mapper 接口包地址"></property>
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>
    

    4、使用扫描器后从spring 容器中获取mapper的实现对象。

    27、简述Mybatis的插件运行原理,以及如何编写一个插件?

    答:
    Mybatis仅可以编写针对 ParameterHandler、ResultSetHandler、StatementHandler、Executor这4种接口的插件,Mybatis使用JDK的动态代理,为需要拦截的接口生成代理对象以实现接口方法拦截功能,每当执行这4种接口对象的方法时,就会进入拦截方法,具体就是InvocationHandler的invoke()方法,当然,只会拦截那些你指定需要拦截的方法。

    编写插件:实现Mybatis的Interceptor接口并复写intercept()方法,然后在给插件编写注解,指定要拦截哪一个接口的哪些方法即可,记住,别忘了在配置文件中配置你编写的插件。

    28、传统JDBC开发存在什么问题?

    29、JDBC编程有哪些不足之处,MyBatis是如何解决的?

    30、MyBatis编程步骤是什么样的?

    答:

    1、 创建SqlSessionFactory

    2、 通过SqlSessionFactory创建SqlSession

    3、 通过sqlsession执行数据库操作

    4、 调用session.commit()提交事务

    5、 调用session.close()关闭会话

    31、请说说MyBatis的工作原理?

    答:

    在学习MyBatis程序之前,需要了解一下MyBatis工作原理,以便于理解程序。MyBatis的工作原理如下图:

    1. 读取MyBatis配置文件:mybatis-config.xml为MyBatis的全局配置文件,配置了MyBatis的运行环境等信息,例如数据库连接信息。

    2. 加载映射文件。映射文件即SQL映射文件,该文件中配置了操作数据库的SQL语句,需要在MyBatis配置文件mybatis-config.xml中加载。mybatis-config.xml文件可以加载多个映射文件,每个文件对应数据库中的一张表。

    3. 构造会话工厂:通过MyBatis的环境等配置信息构建会话工厂SqlSessionFactory。

    4. 创建会话对象:由会话工厂创建SqlSession对象,该对象中包含了执行SQL语句的所有方法。

    5. Executor执行器:MyBatis底层定义了一个Executor 接口来操作数据库,它将根据SqlSession传递的参数动态地生成需要执行的SQL语句,同时负责查询缓存的维护。

    6. MappedStatement 对象:在Executor接口的执行方法中有一个MappedStatement类型的参数,该参数是对映射信息的封装,用于存储要映射的SQL语句的id、参数等信息。

    7. 输入参数映射:输入参数类型可以是Map、List等集合类型,也可以是基本数据类型和POJO类型。输入参数映射过程类似于 JDBC对preparedStatement对象设置参数的过程。

    8. 输出结果映射:输出结果类型可以是Map、List等集合类型,也可以是基本数据类型和POJO类型。输出结果映射过程类似于 JDBC对结果集的解析过程。

    32、MyBatis的功能架构是怎样的?

    答:

    我们把Mybatis的功能架构分为三层:

    API接口层:提供给外部使用的接口API,开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。

    数据处理层:负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。

    基础支撑层:负责最基础的功能支撑,包括连接管理、事务管理、配置加载和缓存处理,这些都是共用的东西,将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。

    33、MyBatis的框架架构设计是怎么样的?

    答:

    这张图从上往下看。MyBatis的初始化,会从mybatis-config.xml配置文件,解析构造成Configuration这个类,就是图中的红框。

    1. 加载配置:配置来源于两个地方,一处是配置文件,一处是Java代码的注解,将SQL的配置信息加载成为一个个MappedStatement对象(包括了传入参数映射配置、执行的SQL语句、结果映射配置),存储在内存中。

    2. SQL解析:当API接口层接收到调用请求时,会接收到传入SQL的ID和传入对象(可以是Map、JavaBean或者基本数据类型),Mybatis会根据SQL的ID找到对应的MappedStatement,然后根据传入参数对象对MappedStatement进行解析,解析后可以得到最终要执行的SQL语句和参数。

    3. SQL执行:将最终得到的SQL和参数拿到数据库进行执行,得到操作数据库的结果。

    4. 结果映射:将操作数据库的结果按照映射的配置进行转换,可以转换成HashMap、JavaBean或者基本数据类型,并将最终结果返回。

    34、什么是DBMS?

    答:

    DBMS:数据库管理系统(database management system)是一种操纵和管理数据库的大型软件,用于建立、使用和维护数zd据库,简称dbms。它对数据库进行统一的管理和控制,以保证数据库的安全性和完整性。

    用户通过dbms访问数据库中的数据,数据库管理员也通过dbms进行数据库的维护工作。它可使多个应用程序和用户用不同的方法在同时版或不同时刻去建立,修改和询问数据库。

    DBMS提供数据定义语言DDL(Data Definition Language)与数据操作语言DML(DataManipulation Language),供用户定义数据库的模式结构与权限约束,实现对数据的追加权、删除等操作。

    35、为什么需要预编译?

    答:

    定义:

    SQL预编译指的是数据库驱动在发送SQL语句和参数给DBMS之前对SQL语句进行编译,这样DBMS执行SQL时,就不需要重新编译。

    为什么需要预编译

    JDBC中使用对象 PreparedStatement 来抽象预编译语句,使用预编译。预编译阶段可以优化SQL的执行。预编译之后的SQL多数情况下可以直接执行,DBMS不需要再次编译,越复杂的SQL,编译的复杂度将越大,预编译阶段可以合并多次操作为一个操作。同时预编译语句对象可以重复利用。

    把一个SQL预编译后产生的 PreparedStatement 对象缓存下来,下次对于同一个SQL,可以直接使用这个缓存的PreparedState对象。Mybatis默认情况下,将对所有的SQL进行预编译。还有一个重要的原因,复制SQL注入

    36、Mybatis都有哪些Executor执行器?它们之间的区别是什么?

    答:

    Mybatis有三种基本的Executor执行器,SimpleExecutor、ReuseExecutor、BatchExecutor。

    SimpleExecutor:每执行一次update或select,就开启一个Statement对象,用完立刻关闭Statement对象。

    ReuseExecutor:执行update或select,以sql作为key查找Statement对象,存在就使用,不存在就创建,用完后,不关闭Statement对象,而是放置于Map<String, Statement>内,供下一次使用。简言之,就是重复使用Statement对象。

    BatchExecutor:执行update(没有select,JDBC批处理不支持select),将所有sql都添加到批处理中(addBatch()),等待统一执行(executeBatch()),它缓存了多个Statement对象,每个Statement对象都是addBatch()完毕后,等待逐一执行executeBatch()批处理。与JDBC批处理相同。

    作用范围:Executor的这些特点,都严格限制在SqlSession生命周期范围内。

    37、Mybatis中如何指定使用哪一种Executor执行器?

    答:

    1.在Mybatis配置文件中,在设置(settings)可以指定默认的ExecutorType执行器类型,也可以手动DefaultSqlSessionFactory的创建SqlSession的方法传递ExecutorType类型参数,如SqlSession openSession(ExecutorType execType)。

    2.配置默认的执行器。SIMPLE就是普通的执行器;REUSE执行器会重用预处理语句(preparedstatements); BATCH 执行器将重用语句并执行批量更新。

    38、Mybatis是否支持延迟加载?如果支持,它的实现原理是什么?

    答:

    1.Mybatis仅支持association关联对象和collection关联集合对象的延迟加载,association指的就是一对一,collection指的就是一对多查询。在Mybatis配置文件中,可以配置是否启用延迟加载lazyLoadingEnabled=true|false。

    2.它的原理是,使用CGLIB创建目标对象的代理对象,当调用目标方法时,进入拦截器方法,比如调用a.getB().getName(),拦截器invoke()方法发现a.getB()是null值,那么就会单独发送事先保存好的查询关联B对象的sql,把B查询上来,然后调用a.setB(b),于是a的对象b属性就有值了,接着完成a.getB().getName()方法的调用。这就是延迟加载的基本原理。

    3.当然了,不光是Mybatis,几乎所有的包括Hibernate,支持延迟加载的原理都是一样的。

    总结

    该面试题答案解析完整文档获取方式:MyBatis面试题总结

    展开全文
  • MyBatis面试题

    2021-06-01 23:37:51
    MyBatis简介 MyBatis是什么? ORM是什么 为什么说Mybatis是半自动ORM映射工具?它与全自动的区别在哪里? 传统JDBC开发存在的问题 JDBC编程有哪些不足之处,MyBatis是如何解决这些问题的? Mybatis优缺点 ...

    目录

    MyBatis简介

    MyBatis是什么?

    ORM是什么

    为什么说Mybatis是半自动ORM映射工具?它与全自动的区别在哪里?

    传统JDBC开发存在的问题

    JDBC编程有哪些不足之处,MyBatis是如何解决这些问题的?

    Mybatis优缺点

    MyBatis框架适用场景

    Hibernate 和 MyBatis 的区别

    MyBatis的解析和运行原理

    MyBatis编程步骤是什么样的?

    请说说MyBatis的工作原理

    MyBatis的功能架构是怎样的

    MyBatis的框架架构设计是怎么样的

    为什么需要预编译

    Mybatis都有哪些Executor执行器?它们之间的区别是什么?

    Mybatis中如何指定使用哪一种Executor执行器?

    Mybatis是否支持延迟加载?如果支持,它的实现原理是什么?

    映射器

    #{}和${}的区别

    模糊查询like语句该怎么写

    在mapper中如何传递多个参数

    Mybatis如何执行批量操作

    如何获取生成的主键

    当实体类中的属性名和表中的字段名不一样 ,怎么办

    Mapper 编写有哪几种方式?

    什么是MyBatis的接口绑定?有哪些实现方式?

    使用MyBatis的mapper接口调用时有哪些要求?

    最佳实践中,通常一个Xml映射文件,都会写一个Dao接口与之对应,请问,这个Dao接口的工作原理是什么?Dao接口里的方法,参数不同时,方法能重载吗

    Mybatis的Xml映射文件中,不同的Xml映射文件,id是否可以重复?

    简述Mybatis的Xml映射文件和Mybatis内部数据结构之间的映射关系?

    Mybatis是如何将sql执行结果封装为目标对象并返回的?都有哪些映射形式?

    Xml映射文件中,除了常见的select|insert|updae|delete标签之外,还有哪些标签?

    Mybatis映射文件中,如果A标签通过include引用了B标签的内容,请问,B标签能否定义在A标签的后面,还是说必须定义在A标签的前面?

    高级查询

    MyBatis实现一对一,一对多有几种方式,怎么操作的?

    Mybatis是否可以映射Enum枚举类?

    动态SQL

    Mybatis动态sql是做什么的?都有哪些动态sql?能简述一下动态sql的执行原理不?

    插件模块

    Mybatis是如何进行分页的?分页插件的原理是什么?

    简述Mybatis的插件运行原理,以及如何编写一个插件。

    缓存

    Mybatis的一级、二级缓存


    MyBatis简介

    MyBatis是什么?

    ORM是什么

    为什么说Mybatis是半自动ORM映射工具?它与全自动的区别在哪里?

    传统JDBC开发存在的问题

    JDBC编程有哪些不足之处,MyBatis是如何解决这些问题的?

    Mybatis优缺点

    MyBatis框架适用场景

    Hibernate 和 MyBatis 的区别

     

    MyBatis的解析和运行原理

    MyBatis编程步骤是什么样的?

    请说说MyBatis的工作原理

    MyBatis的功能架构是怎样的

    JDBC API 允许用户访问任何形式的表格数据,尤其是存储在关系数据库中的数据。

    MyBatis的框架架构设计是怎么样的

    为什么需要预编译

    数据库管理系统(Database Management System)

    Mybatis都有哪些Executor执行器?它们之间的区别是什么?

    Mybatis中如何指定使用哪一种Executor执行器?

    Mybatis是否支持延迟加载?如果支持,它的实现原理是什么?

     

    映射器

    #{}和${}的区别

    模糊查询like语句该怎么写

    在mapper中如何传递多个参数

    Mybatis如何执行批量操作

    如何获取生成的主键

    当实体类中的属性名和表中的字段名不一样 ,怎么办

    Mapper 编写有哪几种方式?

    什么是MyBatis的接口绑定?有哪些实现方式?

    使用MyBatis的mapper接口调用时有哪些要求?

    最佳实践中,通常一个Xml映射文件,都会写一个Dao接口与之对应,请问,这个Dao接口的工作原理是什么?Dao接口里的方法,参数不同时,方法能重载吗

    Mybatis的Xml映射文件中,不同的Xml映射文件,id是否可以重复?

    简述Mybatis的Xml映射文件和Mybatis内部数据结构之间的映射关系?

    Mybatis是如何将sql执行结果封装为目标对象并返回的?都有哪些映射形式?

    Xml映射文件中,除了常见的select|insert|updae|delete标签之外,还有哪些标签?

    Mybatis映射文件中,如果A标签通过include引用了B标签的内容,请问,B标签能否定义在A标签的后面,还是说必须定义在A标签的前面?

     

    高级查询

    MyBatis实现一对一,一对多有几种方式,怎么操作的?

    Mybatis是否可以映射Enum枚举类?

     

    动态SQL

    Mybatis动态sql是做什么的?都有哪些动态sql?能简述一下动态sql的执行原理不?

     

    插件模块

    Mybatis是如何进行分页的?分页插件的原理是什么?

    简述Mybatis的插件运行原理,以及如何编写一个插件。

     

    缓存

    Mybatis的一级、二级缓存

    crud是指在做计算处理时的增加(Create)、读取(Retrieve)、更新(Update)和删除(Delete)

    展开全文
  • Mybatis面试题

    2019-11-09 08:43:24
    Mybatis面试题mybatis 中 #{}和 ${}的区别是什么?mybatis 有几种分页方式?mybatis 逻辑分页和物理分页的区别是什么?mybatis 是否支持延迟加载?延迟加载的原理是什么?说一下 mybatis 的一级缓存和二级缓存?...
  • Mybatis面试题(含答案)_20190220222608.pdf
  • 2021Mybatis面试题(持续更新中)

    千次阅读 2021-07-15 09:25:42
    1.什么是mybatis mybatis是一个半orm的框架,他底层封装了jdbc.在使用的过程中,我们只需要关注sql本身,我们不需要关系数据库的加载驱动,创建连接和创建statement,极大的缩减了我们的代码量. mybats可以使用注解或...
  • mybatis面试题

    2021-04-09 16:48:24
    mybatis面试题 1.mybatis一级缓存和二级缓存 1.一级缓存 一级缓存是默认开启的,它只相对于同一个SqlSession有效,所以也称之为SqlSession缓存。当参数和SQL完全相同的情况下,使用同一个SqlSession对象调用同一个...
  • springmvc+mybatis面试题

    2018-05-25 10:51:57
    这是关于springmvc 、 mybatis面试题
  • Mybatis面试题(2021)

    2021-10-29 19:49:57
    MyBatis是什么? Mybatis 是一个半 ORM(对象关系映射)框架,它内部封装了 JDBC,开发时只需要关注 SQL 语 句本身,不需要花费精力去处理加载驱动、创建连接、创建statement 等繁杂的过程。程序员直 接编写原生态 ...
  • mybatis 面试题

    千次阅读 多人点赞 2017-08-08 16:08:19
    mybatis 面试题
  • 什么是数据持久化? 数据持久化是将内存中的数据模型转换为存储模型,以及将存储模型转换为内存中的数据模型的统称。例如,文件的存储、数据的读取等都...MyBatis框架是一个开源的数据持久层框架。 它的内部封装了...
  • MyBatis面试题总结

    万次阅读 多人点赞 2020-09-21 21:46:52
    啃下MyBatis源码 - MyBatis面试题总结 1.概念/使用方法向的问题 1.1 什么是Mybatis? 1.2为什么说Mybatis是半ORM框架?/与Hibernate有哪些不同? 1.3Mybaits的优点? 1.4MyBatis框架的缺点? 1.5#{}和${}的...
  • 文档饱含spring面试试题及答案、mybatis面试试题及答案以及springboot面试试题及答案,试题全面,答案详细。涵盖了最近面试中的格式问题类型。
  • 关于mybatis面试题总结

    千次阅读 2020-04-06 09:23:15
    关于mybatis面试题总结 **1. 在 MyBatis 中,操作数据库的核心类是(SqlSession) 2. MyBatis操作数据库时的接口方法中,如果传入的参数名和动态sql中使用时不一致,则需要使用( @Param)注解修饰 3. MyBatis 中,...
  • 1、什么是MyBatis? 答:MyBatis是一个可以自定义SQL、存储过程和高级映射的持久层框架。 2、讲下MyBatis的缓存 答:MyBatis的缓存分为一级缓存和二级缓存,一级缓存放在session里面,默认就有,二级缓存放在它的...
  • 25个最常见的MyBatis面试题

    千次阅读 多人点赞 2020-05-25 11:18:20
    1、什么是 MybatisMybatis 是一个半 ORM(对象关系映射)框架,它内部封装了 JDBC,开发时只需要关注 SQL 语句本身,不需要花费精力去处理加载驱动、创建连接、创建statement 等繁杂的过程。程序员直接编写原...
  • Mybatis面试题汇总

    千次阅读 多人点赞 2019-02-13 18:24:25
    Mybatis面试题总结 1. #{}和${}的区别是什么? #{}是预编译处理,${}是字符串替换。 Mybatis在处理#{}时,会将sql中的#{}替换为?号,调用PreparedStatement的set方法来赋值; Mybatis在处理${}时,就是把${}替换...
  • 涵盖各大公司会问到的面试点,同时随着版本的升级,可能也会有一些面试题更新,也会同步保持更新,因为篇幅原因(其实是我懒,哈哈)所以列了一部分答案,所有的答案见下文,总共485页合计20个技术点,文末自取pdf。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,742
精华内容 14,696
关键字:

mybatis面试题