面试自用--Mybatis

喝咖啡的木

已于 2023-04-20 07:42:58 修改

阅读量165

点赞数

分类专栏：面试文章标签： mybatis 面试 java

于 2023-04-20 07:39:43 首次发布

本文链接：https://blog.csdn.net/David_FY/article/details/130066508

版权

面试专栏收录该内容

6 篇文章 0 订阅

订阅专栏

什么是Mybatis？

Mybatis是一个半ORM（对象关系映射）框架，它内部封装了JDBC，开发时只需要关注SQL语句本身，不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。程序员直接编写原生态sql，可以严格控制sql执行性能，灵活度高。
MyBatis可以使用XML或注解来配置和映射原生信息，将POJO映射成数据库中的记录，避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。
通过xml文件或注解的方式将要执行的各种statement配置起来，并通过java对象和statement中sql的动态参数进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射为java对象并返回。（从执行sql到返回result的过程）。

Mybaits的优点？

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

MyBatis框架的缺点？

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

MyBatis框架适用场合

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

MyBatis与Hibernate有哪些不同？

Mybatis和hibernate不同，它不完全是一个ORM框架，因为MyBatis需要程序员自己编写Sql语句。
Mybatis直接编写原生态sql，可以严格控制sql执行性能，灵活度高，非常适合对关系数据模型要求不高的软件开发，因为这类软件需求变化频繁，一但需求变化要求迅速输出成果。但是灵活的前提是mybatis无法做到数据库无关性，如果需要实现支持多种数据库的软件，则需要自定义多套sql映射文件，工作量大。
Hibernate对象/关系映射能力强，数据库无关性好，对于关系模型要求高的软件，如果用hibernate开发可以节省很多代码，提高效率。

#{} 和${}的区别是什么？

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

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

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

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

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

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

在Java代码中添加sql通配符。

  String wildcardname = “%smi%”;
  List<name> names = mapper.selectlike(value);

  <select id=”selectlike”>
   select * from foo where bar like #{value}
  </select>

在sql语句中拼接通配符，会引起sql注入

  string wildcardname = “smi”;
  list<name> names = mapper.selectlike(value);

  <select id=”selectlike”>
       select * from foo where bar like "%"${value}"%"
  </select>

使用Contact

  string wildcardname = “smi”;
  list<name> names = mapper.selectlike(value);

  <select id=”selectlike”>
       select * from foo where bar like CONCAT('%',#{value},'%')
  </select>

通常一个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。 Dao接口里的方法，是不能重载的，因为是全限名+方法名的保存和寻找策略。

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

Mybatis是如何进行分页的？分页插件的原理是什么？(PageHelper)

借助数组进行分页

原理：进行数据库查询操作时，获取到数据库中所有满足条件的记录，保存在应用的临时数组中，再通过List的subList方法，获取到满足条件的所有记录。
实现：
首先在dao层，创建StudentMapper接口，用于对数据库的操作。在接口中定义通过数组分页的查询方法，方法就是获取所有的数据，通过list接收后进行分页操作。如下所示：

 List<Student> queryStudentsByArray();
    
     <select id="queryStudentsByArray"  resultMap="studentmapper">
            select * from student
     </select>

接下来在service层获取数据并且进行分页实现：
定义IStuService接口，并且定义分页方法：
    List<Student> queryStudentsByArray(int currPage, int pageSize);
通过接收currPage参数表示显示第几页的数据，pageSize表示每页显示的数据条数。
创建IStuService接口实现类StuServiceIml对方法进行实现，对获取到的数组通过currPage和pageSize进行分页：

@Override
    public List<Student> queryStudentsByArray(int currPage, int pageSize) {
        List<Student> students = studentMapper.queryStudentsByArray();
        //        从第几条数据开始
        int firstIndex = (currPage - 1) * pageSize;
        //        到第几条数据结束
        int lastIndex = currPage * pageSize;
        return students.subList(firstIndex, lastIndex);
    }

通过subList方法，获取到两个索引间的所有数据。
最后在controller中创建测试方法：

@ResponseBody
    @RequestMapping("/student/array/{currPage}/{pageSize}")
    public List<Student> getStudentByArray(@PathVariable("currPage") int currPage, @PathVariable("pageSize") int pageSize) {
        List<Student> student = StuServiceIml.queryStudentsByArray(currPage, pageSize);
        return student;
    }

通过用户传入的currPage和pageSize获取指定数据。

借助SQL语句进行分页

在了解到通过数组分页的缺陷后，我们发现不能每次都对数据库中的所有数据都检索。然后在程序中对获取到的大量数据进行二次操作，这样对空间和性能都是极大的损耗。所以我们希望能直接在数据库语言中只检索符合条件的记录，不需要在通过程序对其作处理。这时，Sql语句分页技术横空出世。
实现：通过sql语句实现分页也是非常简单的，只是需要改变我们查询的语句就能实现了，即在sql语句后面添加limit分页语句，如下：

@Override
    public List<Student> queryStudentsBySql(int currPage, int pageSize) {
        Map<String, Object> data = new HashedMap();
        data.put("currIndex", (currPage-1)*pageSize);
        data.put("pageSize", pageSize);
        return studentMapper.queryStudentsBySql(data);
    }
    
    List<Student> queryStudentsBySql(Map<String,Object> data);
    
     <select id="queryStudentsBySql" parameterType="map" resultMap="studentmapper">
            select * from student limit #{currIndex} , #{pageSize}
    </select>

拦截器分页

上面提到的数组分页和sql语句分页都不是我们今天讲解的重点，今天需要实现的是利用拦截器达到分页的效果。自定义拦截器实现了拦截所有以ByPage结尾的查询语句，并且利用获取到的分页相关参数统一在sql语句后面加上limit分页的相关语句，一劳永逸。不再需要在每个语句中单独去配置分页相关的参数了。
首先我们看一下拦截器的具体实现，在这里我们需要拦截所有以ByPage结尾的所有查询语句，因此要使用该拦截器实现分页功能，那么再定义名称的时候需要满足它拦截的规则（以ByPage结尾），如下所示：

package com.cbg.interceptor;
    
    import org.apache.ibatis.executor.Executor;
    import org.apache.ibatis.executor.parameter.ParameterHandler;
    import org.apache.ibatis.executor.resultset.ResultSetHandler;
    import org.apache.ibatis.executor.statement.StatementHandler;
    import org.apache.ibatis.mapping.MappedStatement;
    import org.apache.ibatis.plugin.*;
    import org.apache.ibatis.reflection.MetaObject;
    import org.apache.ibatis.reflection.SystemMetaObject;
    import java.sql.Connection;
    import java.util.Map;
    import java.util.Properties;
    
    /**
     * @Intercepts 说明是一个拦截器
     * @Signature 拦截器的签名
     * type 拦截的类型 四大对象之一( Executor,ResultSetHandler,ParameterHandler,StatementHandler)
     * method 拦截的方法
     * args 参数
     */
    @Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})})
    public class MyPageInterceptor implements Interceptor {
    
        //每页显示的条目数
        private int pageSize;
        //当前现实的页数
        private int currPage;
    
        private String dbType;
    
        @Override
        public Object intercept(Invocation invocation) throws Throwable {
            //获取StatementHandler，默认是RoutingStatementHandler
            StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
            //获取statementHandler包装类
            MetaObject MetaObjectHandler = SystemMetaObject.forObject(statementHandler);
    
            //分离代理对象链
            while (MetaObjectHandler.hasGetter("h")) {
                Object obj = MetaObjectHandler.getValue("h");
                MetaObjectHandler = SystemMetaObject.forObject(obj);
            }
    
            while (MetaObjectHandler.hasGetter("target")) {
                Object obj = MetaObjectHandler.getValue("target");
                MetaObjectHandler = SystemMetaObject.forObject(obj);
            }
    
            //获取连接对象
            //Connection connection = (Connection) invocation.getArgs()[0];
    
            //object.getValue("delegate");  获取StatementHandler的实现类
    
            //获取查询接口映射的相关信息
            MappedStatement mappedStatement = (MappedStatement) MetaObjectHandler.getValue("delegate.mappedStatement");
            String mapId = mappedStatement.getId();
    
            //statementHandler.getBoundSql().getParameterObject();
    
            //拦截以.ByPage结尾的请求，分页功能的统一实现
            if (mapId.matches(".+ByPage$")) {
                //获取进行数据库操作时管理参数的handler
                ParameterHandler parameterHandler = (ParameterHandler) MetaObjectHandler.getValue("delegate.parameterHandler");
                //获取请求时的参数
                Map<String, Object> paraObject = (Map<String, Object>) parameterHandler.getParameterObject();
                //也可以这样获取
                //paraObject = (Map<String, Object>) statementHandler.getBoundSql().getParameterObject();
    
                //参数名称和在service中设置到map中的名称一致
                currPage = (int) paraObject.get("currPage");
                pageSize = (int) paraObject.get("pageSize");
    
                String sql = (String) MetaObjectHandler.getValue("delegate.boundSql.sql");
                //也可以通过statementHandler直接获取
                //sql = statementHandler.getBoundSql().getSql();
    
                //构建分页功能的sql语句
                String limitSql;
                sql = sql.trim();
                limitSql = sql + " limit " + (currPage - 1) * pageSize + "," + pageSize;
    
                //将构建完成的分页sql语句赋值个体'delegate.boundSql.sql'，偷天换日
                MetaObjectHandler.setValue("delegate.boundSql.sql", limitSql);
            }
            //调用原对象的方法，进入责任链的下一级
            return invocation.proceed();
        }
    
    
        //获取代理对象
        @Override
        public Object plugin(Object o) {
            //生成object对象的动态代理对象
            return Plugin.wrap(o, this);
        }
    
        //设置代理对象的参数
        @Override
        public void setProperties(Properties properties) {
            //如果项目中分页的pageSize是统一的，也可以在这里统一配置和获取，这样就不用每次请求都传递pageSize参数了。参数是在配置拦截器时配置的。
            String limit1 = properties.getProperty("limit", "10");
            this.pageSize = Integer.valueOf(limit1);
            this.dbType = properties.getProperty("dbType", "mysql");
        }
    }

上面即是拦截器功能的实现，在intercept方法中获取到select标签和sql语句的相关信息，拦截所有以ByPage结尾的select查询，并且统一在查询语句后面添加limit分页的相关语句，统一实现分页功能。
重点详解：
StatementHandler是一个接口，而我们在代码中通过StatementHandler statementHandler = (StatementHandler) invocation.getTarget();获取到的是StatementHandler默认的实现类RoutingStatementHandler。而RoutingStatementHandler只是一个中间代理，他不会提供具体的方法。那你可能会纳闷了，拦截器中基本上是依赖statementHandler获取各种对象和属性的，没有具体属性和方法怎么行？？接着看下面代码：

 private final StatementHandler delegate;
    
    public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
        switch(RoutingStatementHandler.SyntheticClass_1.$SwitchMap$org$apache$ibatis$mapping$StatementType[ms.getStatementType().ordinal()]) {
            case 1:
                this.delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
                break;
            case 2:
                this.delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
                break;
            case 3:
                this.delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
                break;
            default:
                throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
        }
    }

原来它是通过不同的MappedStatement创建不同的StatementHandler实现类对象处理不同的情况。这里的到的StatementHandler实现类才是真正服务的。看到这里，你可能就会明白MappedStatement mappedStatement = (MappedStatement) MetaObjectHandler.getValue(“delegate.mappedStatement”);中delegate的来源了吧。至于为什么要这么去获取，后面我们会说道。
拿到statementHandler后，我们会通过MetaObject MetaObjectHandler = SystemMetaObject.forObject(statementHandler);去获取它的包装对象，通过包装对象去获取各种服务。
MetaObject：mybatis的一个工具类，方便我们有效的读取或修改一些重要对象的属性。四大对象（ResultSetHandler，ParameterHandler，Executor和statementHandler）提供的公共方法很少，要想直接获取里面属性的值很困难，但是可以通过MetaObject利用一些技术（内部反射实现）很轻松的读取或修改里面的数据。
接下来说说：MappedStatement mappedStatement = (MappedStatement) MetaObjectHandler.getValue(“delegate.mappedStatement”);
上面提到为什么要这么去获取MappedStatement对象？？在RoutingStatementHandler中delegate是私有的（private final StatementHandler delegate;），有没有共有的方法去获取。所以这里只有通过反射来获取啦。
MappedStatement是保存了xxMapper.xml中一个sql语句节点的所有信息的包装类，可以通过它获取到节点中的所有信息。在示例中我们拿到了id值，也就是方法的名称，通过名称区拦截所有需要分页的请求。
通过StatementHandler的包装类，不光能拿到MappedStatement，还可以拿到下面的数据：

public abstract class BaseStatementHandler implements StatementHandler {
        protected final Configuration configuration;
        protected final ObjectFactory objectFactory;
        protected final TypeHandlerRegistry typeHandlerRegistry;
        protected final ResultSetHandler resultSetHandler;
        protected final ParameterHandler parameterHandler;
        protected final Executor executor;
        protected final MappedStatement mappedStatement;
        protected final RowBounds rowBounds;
        protected BoundSql boundSql;
    
        protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
            this.configuration = mappedStatement.getConfiguration();
            this.executor = executor;
            this.mappedStatement = mappedStatement;
            this.rowBounds = rowBounds;
            this.typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();
            this.objectFactory = this.configuration.getObjectFactory();
            if(boundSql == null) {
                this.generateKeys(parameterObject);
                boundSql = mappedStatement.getBoundSql(parameterObject);
            }
    
            this.boundSql = boundSql;
            this.parameterHandler = this.configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
            this.resultSetHandler = this.configuration.newResultSetHandler(executor, mappedStatement, rowBounds, this.parameterHandler, resultHandler, boundSql);
    }

上面的所有数据都可以通过反射拿到。
几个重要的参数：
Configuration：所有配置的相关信息。
ResultSetHandler：用于拦截执行结果的组装。
ParameterHandler：拦截执行Sql的参数的组装。
Executor：执行Sql的全过程，包括组装参数、组装结果和执行Sql的过程。
BoundSql：执行的Sql的相关信息。
接下来我们通过如下代码拿到请求时的map对象（反射）。

 //获取进行数据库操作时管理参数的handler
    ParameterHandler parameterHandler = (ParameterHandler) MetaObjectHandler.getValue("delegate.parameterHandler");
    //获取请求时的参数
    Map<String, Object> paraObject = (Map<String, Object>) parameterHandler.getParameterObject();
    //也可以这样获取
    //paraObject = (Map<String, Object>) statementHandler.getBoundSql().getParameterObject();

拿到我们需要的currPage和pageSize参数后，就是组装分页查询的sql语句’limitSql‘了。
最后通过MetaObjectHandler.setValue(“delegate.boundSql.sql”, limitSql);将原始的sql语句替换成我们新的分页语句，完成偷天换日的功能，接下来让代码继续执行。
编写好拦截器后，需要注册到项目中，才能发挥它的作用。在mybatis的配置文件中，添加如下代码：

 <plugins>
        <plugin interceptor="com.cbg.interceptor.MyPageInterceptor">
            <property name="limit" value="10"/>
            <property name="dbType" value="mysql"/>
        </plugin>
    </plugins>

如上所示，还能在里面配置一些属性，在拦截器的setProperties方法中可以获取配置好的属性值。如项目分页的pageSize参数的值固定，我们就可以配置在这里了，以后就不需要每次传入pageSize了，读取方式如下：

//读取配置的代理对象的参数
    @Override
    public void setProperties(Properties properties) {
        String limit1 = properties.getProperty("limit", "10");
        this.pageSize = Integer.valueOf(limit1);
        this.dbType = properties.getProperty("dbType", "mysql");
    }

到这里，有关拦截器的相关知识就讲解的差不多了，接下来就需要测试，是否我们这样写真的有效？ 示例如下：

@ResponseBody
    @RequestMapping("/student/page/{currPage}/{pageSize}")
    public List<Student> getStudentByPage(@PathVariable("currPage") int currPage, @PathVariable("pageSize") int pageSize) {
        List<Student> student = StuServiceIml.queryStudentsByPage(currPage, pageSize);
        return student;
    }
    //方法：
    List<Student> queryStudentsByPage(int currPage,int pageSize);
    //实现：
    @Override
    public List<Student> queryStudentsByPage(int currPage, int pageSize) {
        Map<String, Object> data = new HashedMap();
        data.put("currPage", currPage);
        data.put("pageSize", pageSize);
        return studentMapper.queryStudentsByPage(data);
    }
    //方法
    List<Student> queryStudentsByPage(Map<String,Object> data);
    <!--xml文件的select语句-->
    <select id="queryStudentsByPage" parameterType="map" resultMap="studentmapper">
        select * from student limit #{currIndex} , #{pageSize}
    </select>

RowBounds实现分页

原理：通过RowBounds实现分页和通过数组方式分页原理差不多，都是一次获取所有符合条件的数据，然后在内存中对大数据进行操作，实现分页效果。只是数组分页需要我们自己去实现分页逻辑，这里更加简化而已。
存在问题：一次性从数据库获取的数据可能会很多，对内存的消耗很大，可能导师性能变差，甚至引发内存溢出。
适用场景：在数据量很大的情况下，建议还是适用拦截器实现分页效果。RowBounds建议在数据量相对较小的情况下使用。
简单介绍：这是代码实现上最简单的一种分页方式，只需要在dao层接口中要实现分页的方法中加入RowBounds参数，然后在service层通过offset（从第几行开始读取数据，默认值为0）和limit（要显示的记录条数，默认为java允许的最大整数：2147483647）两个参数构建出RowBounds对象，在调用dao层方法的时，将构造好的RowBounds传进去就能轻松实现分页效果了。示例如下：

@Override
    @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.SUPPORTS)
    public List<RoleBean> queryRolesByPage(String roleName, int start, int limit) {
        return roleDao.queryRolesByPage(roleName, new RowBounds(start, limit));
    }
    
    //加入RowBounds参数
    public List<UserBean> queryUsersByPage(String userName, RowBounds rowBounds);
    
    public class RowBounds {
        public static final int NO_ROW_OFFSET = 0;
        public static final int NO_ROW_LIMIT = 2147483647;
        public static final RowBounds DEFAULT = new RowBounds();
        private int offset;
        private int limit;
    
        public RowBounds() {
            this.offset = 0;
            this.limit = 2147483647;
        }
        public RowBounds(int offset, int limit) {
            this.offset = offset;
            this.limit = limit;
        }
        public int getOffset() {
            return this.offset;
        }
        public int getLimit() {
            return this.limit;
        }
    }

RowBounds分页原理

实现原理

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

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

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

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

Mybatis如何执行批量操作

使用foreach标签

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

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

在使用foreach的时候最关键的也是最容易出错的就是collection属性，该属性是必须指定的，但是

在不同情况下，该属性的值是不一样的，主要有一下3种情况：

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

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

insert方法总是返回一个int值，这个值代表的是插入的行数。如果采用自增长策略，自动生成的键值在insert方法执行完后可以被设置到传入的参数对象中。

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

Mybatis动态sql有什么用？执行原理？有哪些动态 sql？

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

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

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

一对一、一对多的关联查询？

 <mapper namespace="com.lcb.mapping.userMapper">  
        <!--association  一对一关联查询 -->  
        <select id="getClass" parameterType="int" resultMap="ClassesResultMap">  
            select * from class c,teacher t where c.teacher_id=t.t_id and c.c_id=#{id}  
        </select>  
     
        <resultMap type="com.lcb.user.Classes" id="ClassesResultMap">  
            <!-- 实体类的字段名和数据表的字段名映射 -->  
            <id property="id" column="c_id"/>  
            <result property="name" column="c_name"/>  
            <association property="teacher" javaType="com.lcb.user.Teacher">  
                <id property="id" column="t_id"/>  
                <result property="name" column="t_name"/>  
            </association>  
        </resultMap>  
     
        <!--collection  一对多关联查询 -->  
        <select id="getClass2" parameterType="int" resultMap="ClassesResultMap2">  
            select * from class c,teacher t,student s where c.teacher_id=t.t_id and c.c_id=s.class_id and c.c_id=#{id}  
        </select>  
     
        <resultMap type="com.lcb.user.Classes" id="ClassesResultMap2">  
            <id property="id" column="c_id"/>  
            <result property="name" column="c_name"/>  
            <association property="teacher" javaType="com.lcb.user.Teacher">  
                <id property="id" column="t_id"/>  
                <result property="name" column="t_name"/>  
            </association>  
     		<!--下边的这个collection是对应的外边的类中的成员变量是一个数组-->
            <collection property="student" ofType="com.lcb.user.Student">  
                <id property="id" column="s_id"/>  
                <result property="name" column="s_name"/>  
            </collection>  
        </resultMap>  
    </mapper>

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

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

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

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

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

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

azyLoadingEnabled=true|false。

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

Mybatis的一级、二级缓存

一级缓存：基于PerpetualCache的HashMap本地缓存，其存储作用域为Session，当Session flush或close之后，该 Session中的所有Cache就将清空，默认打开一级缓存。
二级缓存与一级缓存其机制相同，默认也是采用PerpetualCache，HashMap存储，不同在于其存储作用域为Mapper(Namespace)，并且可自定义存储源，如cache。默认不打开二级缓存，要开启二级缓存，使用二级缓存属性类需要实现Serializable序列化接口(可用来保存对象的状态),可在它的映射文件中配置；
对于缓存数据更新机制，当某一个作用域(一级缓存Session/二级缓存Namespaces)的进行了CRUD操作后，默认该作用域下所有select中的缓存将被清除。

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

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

接口绑定有两种实现方式：

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

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

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

Mapper编写有哪几种方式？ .

接口实现类继承SqlSessionDaoSupport：使用此种方法需要编写mapper接口，mapper接口实现类、mapper.xml文件。
- 在sqlMapConfig xml中配置mapper xml的位置

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

- 定义mapper接口
- 实现类集成SqlSessionDaoSupport mapper方法中可以this getSqlSession()进行数据增删改查。
- spring配置

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

使用org.mybatis.spring.mapper.MapperFactoryBean：
- 在 sqlMapConfig.xml中配置mapper.xml的位置，如果mapper.xml 和mappre接口的名称相同且在同一个目录，这里可以不用配置

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

- 定义mapper接口：
- - mapper.xml中的namespace为mapper接口的地址
  - mapper接口中的方法名和mapper.xml中的定义的statement的id保持一致
- Spring中定义
使用mapper扫描器：
- mapper.xml文件编写：
- - mapper.xml中的namespace为mapper接口的地址；
  - mapper接口中的方法名和mapper.xml中的定义的statement的id保持一致；
  - 如果将mapper.xml和mapper接口的名称保持一致则不用在sqlMapConfig.xml中进行配置。
定义mapper接口：
- 注意mapper.xml的文件名和mapper的接口名称保持一致，且放在同一个目录
配置mapper扫描器：
使用扫描器后从spring 容器中获取mapper的实现对象。

常见Mybatis插件

分页插件(PageHelper)、逆向工程插件(Generator)、MybatisX、MybatisLog

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

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

编写插件：

Mybatis自定义插件必须实现Interceptor接口并复写intercept()方法

public interface Interceptor {
    Object intercept(Invocation invocation) throws Throwable; //intercept方法：拦截器具体处理逻辑方法 
    Object plugin(Object target); //plugin方法：根据签名signatureMap生成动态代理对象
    void setProperties(Properties properties); //setProperties方法：设置Properties属性
}

自定义demo

  // ExamplePlugin.java
    @Intercepts({@Signature(
      type= Executor.class,  //表示拦截的类，这里是Executor的实现类
      method = "update",  //表示拦截的方法，这里是拦截Executor的update方法
      args = {MappedStatement.class,Object.class})}) //表示方法参数
    public class ExamplePlugin implements Interceptor {
      public Object intercept(Invocation invocation) throws Throwable {
      Object target = invocation.getTarget(); //被代理对象
      Method method = invocation.getMethod(); //代理方法
      Object[] args = invocation.getArgs(); //方法参数
      // do something ...... 方法拦截前执行代码块
      Object result = invocation.proceed();
      // do something .......方法拦截后执行代码块
      return result;
      }
      public Object plugin(Object target) {
        return Plugin.wrap(target, this);
      }
      public void setProperties(Properties properties) {
      }
    }

MyBatis编程步骤是什么样的？

创建SqlSessionFactory
通过SqlSessionFactory创建SqlSession
通过sqlsession执行数据库操作
调用session.commit()提交事务
调用session.close()关闭会话

请说说MyBatis的工作原理？

读取MyBatis配置文件：mybatis-config.xml为MyBatis的全局配置文件，配置了MyBatis的运行环境等信息，例如数据库连接信息。
加载映射文件。映射文件即SQL映射文件，该文件中配置了操作数据库的SQL语句，需要在MyBatis配置文件mybatis-config.xml中加载。mybatis-config.xml文件可以加载多个映射文件，每个文件对应数据库中的一张表。
构造会话工厂：通过MyBatis的环境等配置信息构建会话工厂SqlSessionFactory。
创建会话对象：由会话工厂创建SqlSession对象，该对象中包含了执行SQL语句的所有方法。
Executor执行器：MyBatis底层定义了一个Executor 接口来操作数据库，它将根据SqlSession传递的参数动态地生成需要执行的SQL语句，同时负责查询缓存的维护。
MappedStatement 对象：在Executor接口的执行方法中有一个MappedStatement类型的参数，该参数是对映射信息的封装，用于存储要映射的SQL语句的id、参数等信息。
输入参数映射：输入参数类型可以是Map、List等集合类型，也可以是基本数据类型和POJO类型。输入参数映射过程类似于 JDBC对preparedStatement对象设置参数的过程。
输出结果映射：输出结果类型可以是Map、List等集合类型，也可以是基本数据类型和POJO类型。输出结果映射过程类似于 JDBC对结果集的解析过程。

MyBatis的功能架构是怎样的？

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

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

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

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

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

MyBatis的初始化：会从mybatis-config.xml配置文件，解析构造成Configuration这个类。

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

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

SQL执行：将最终得到的SQL和参数拿到数据库进行执行，得到操作数据库的结果。

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

什么是DBMS？

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

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

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

为什么需要预编译？

定义

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

为什么需要预编译

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

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

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

Mybatis有三种基本的Executor执行器：

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批处理相同。

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

在Mybatis配置文件中，在设置（settings）可以指定默认的ExecutorType执行器类型，也可以手动DefaultSqlSessionFactory的创建SqlSession的方法传递ExecutorType类型参数，如SqlSession openSession(ExecutorType execType)。
配置默认的执行器。SIMPLE就是普通的执行器；REUSE执行器会重用预处理语句（preparedstatements）； BATCH 执行器将重用语句并执行批量更新。

JDBC有什么不足之处，mybatis如何避免

不足：

    1.频繁创建销毁数据库连接，导致资源消耗，影响性能；

    2.jdbc中java代码与sql语句放在一起，不易与解耦；

    3.由于sql语句条件参数不确定，占位符和参数需要一一对应

    4.解析sql的结果集比较麻烦

解决：

    1.mybatis在config.xml文件中配置数据库连接池，来管理数据库连接；

    2.mybatis在mapper文件中编写sql，将java代码与sql解耦；

    3.自动将java对象映射到sql语句；

    4.mybatis自动将sql语句查询的结果映射至java对象；