MyBatis技术总结

1. MyBatis面试题汇总

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

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

解决：在SqlMapConfig.xml中配置数据链接池，使用连接池管理数据库链接。

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

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

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

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

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

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

1.2 MyBatis编程步骤是什么样的？

① 创建SqlSessionFactory

② 通过SqlSessionFactory创建SqlSession

③ 通过sqlsession执行数据库操作

④ 调用session.commit()提交事务

⑤ 调用session.close()关闭会话

1.3 MyBatis与Hibernate有哪些不同？

1.Mybatis和hibernate不同，它不完全是一个ORM框架，因为MyBatis需要程序员自己编写Sql语句。mybatis可以通过XML或注解方式 灵活配置要运行的sql语句，并将java对象和sql语句映射生成最终执行的sql，最后将sql执行的结果再映射生成java对象。

2.Mybatis学习门槛低，简单易学，程序员直接编写原生态sql，可严格控制sql执行性能，灵活度高，非常适合对关系数据模型要求不高的软件开发，例如互联网软件、企业运营类软件等，因为这类软件需求变化频繁，一但需求变化要求成果输出迅速。但是灵活的前提是 mybatis无法做到数据库无关性， 如果需要实现支持多种数据库的软件则需要自定义多套sql映射文件，工作量大。

3.Hibernate对象/关系映射能力强， 数据库无关性好，对于关系模型要求高的软件（例如需求固定的定制化软件）如果用hibernate开发可以节省很多代码，提高效率。但是Hibernate的学习门槛高，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡，以及怎样用好Hibernate需要具有很强的经验和能力才行。

总之，按照用户的需求在有限的资源环境下只要能做出维护性、扩展性良好的软件架构都是好架构，所以框架只有适合才是最好。 

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

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

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

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

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

1.5 SqlMapConfig.xml中配置有哪些内容？

SqlMapConfig.xml中配置的内容和顺序如下： 

properties（属性）

settings（配置）

typeAliases（类型别名）

typeHandlers（类型处理器）

objectFactory（对象工厂）

plugins（插件）

environments（环境集合属性对象）

environment（环境子属性对象）

transactionManager（事务管理）

dataSource（数据源）

mappers（映射器）

1.6简单的说一下MyBatis的一级缓存和二级缓存？

Mybatis首先去缓存中查询结果集，如果没有则查询数据库，如果有则从缓存取出返回结果集就不走数据库。Mybatis内部存储缓存使用一个HashMap，key为hashCode+sqlId+Sql语句。value为从查询出来映射生成的java对象

Mybatis的二级缓存即查询缓存，它的作用域是一个mapper的namespace，即在同一个namespace中查询sql可以从缓存中获取数据。二级缓存是可以跨SqlSession的。

1.7Mapper编写有哪几种方式？

①接口实现类继承SqlSessionDaoSupport

使用此种方法需要编写mapper接口，mapper接口实现类、mapper.xml文件

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

1 2 3 4

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

2、定义mapper接口

3、实现类集成SqlSessionDaoSupport

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

4、spring 配置

1 2 3

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

②使用org.mybatis.spring.mapper.MapperFactoryBean

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

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

1 2 3 4

< 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中定义

1 2 3 4

< 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扫描器

1 2 3 4

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

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

扫描器将接口通过代理方法生成实现对象，要spring容器中自动注册，名称为mapper 接口的名称。

---

2. 建立工程时选择建立java工程还是web工程？

当建立的工程,需要用到request/response时,需要建立web工程,否则Java工程即可。

3. MyBatis介绍

MyBatis本是apache公司一个名叫iBatis的开源项目,在2010年Apache将其转移给了Google公司,从apache software foundation 迁移到了google code,并且改名为MyBatis,后来在2013年11月又被Google将其放到了Github上。

MyBatis是一个优秀的持久层框架,它对jdbc操作数据库的过程进行了封装,开发者只需要关注SQL本身,而不需要浪费精力去处理,例如:注册驱动,创建connection,创建statement,手动设置参数,结果集检索等Jdbc繁杂的过程代码。

MyBatis通过xml或注解的方式将要执行的各种statement（statement、preparedStatemnt、CallableStatement）配置起来，并通过java对象和statement中的sql进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射成java对象并返回。

4. jdbc编程步骤回顾

1. 注册数据库驱动 
2. 创建并获取数据库链接 
3. 创建jdbc statement对象 
4. 设置sql语句 
5. 设置sql语句中的参数(使用preparedStatement) 
6. 通过statement执行sql并获取结果 
7. 对sql执行结果进行解析处理, while(resultSet.next) 
8. 释放资源(resultSet,preparedStatement,connection)

5. jdbc问题总结

1. 数据库连接创建、释放频繁造成系统资源浪费,从而影响系统性能。如果使用数据库连接池可解决此问题。
2. Sql语句在代码中硬编码，造成代码不易维护，实际应用中sql变化的可能较大，sql变动需要改变java代码。
3. 使用preparedStatement向占位符号传参数存在硬编码，因为sql语句的where条件不一定，可能多也可能少，修改sql还要修改代码，系统不易维护。
4. 对结果集解析存在硬编码（查询列名），sql变化导致解析代码变化，系统不易维护，如果能将数据库记录封装成pojo(POJO是指简单的Java对象，实际就是普通JavaBeans，是为了避免和EJB混淆所创造的简称。POJO通指没有使用Entity Beans的普通java对象，可以把POJO作为支持业务逻辑的协助类。)对象解析比较方便。

6. MyBatis架构

7. MyBatis配置

1. SqlMapConfig.xml，此文件作为mybatis的全局(核心)配置文件， 配置了mybatis的运行环境等信息。 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

xml  version = "1.0"  encoding = "utf-8" ?>    < configuration >           < environments  default = "development" >       < environment  id = "development" >                   < transactionManager  type = "JDBC" />                    < dataSource  type = "POOLED" >           < property  name = "driver"  value = "com.mysql.jdbc.Driver" />            < property  name = "url"  value = "jdbc:mysql://localhost:3306/mybatis45?characterEncoding=utf-8" />            < property  name = "username"  value = "root" />            < property  name = "password"  value = "root" />         dataSource >       environment >     environments >            < mappers >       < mapper  resource = "sqlmap/User.xml" />     mappers >  configuration >

mapper.xml  文件即 sql映射文件 ，文件中配置了操作数据库的sql语句。此文件需要在SqlMapConfig.xml中加载。 例如：User.xml

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

xml  version = "1.0"  encoding = "UTF-8"  ?> PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">    < mapper  namespace = "user" >            < select  id = "findUserById"  parameterType = "Integer"  resultType = "com.github.pojo.User" >select * from user where id = #{id} select >                        < insert  id = "addUser"  parameterType = "com.github.pojo.User" >          insert into user           (username, birthday,sex,address)          values(#{username},#{birthday},#{sex},#{address})      insert >              < delete  id = "deleteUser"  parameterType = "Integer" >          delete  from user where id = #{id}      delete >         < update  id = "updateUser"  parameterType = "com.github.pojo.User" >          update user set           username = #{username},          birthday = #{birthday},          sex = #{sex},          address = #{address}          where id = #{id}      update >              < select  id = "likeQuery"  parameterType = "String"  resultType = "com.github.pojo.User" >          select * from user where username like '%${value}%'      select >    mapper >

2.通过mybatis环境等配置信息 构造SqlSessionFactory即会话工厂 

例如：通过流的形式构造sqlSessionFactory会话工厂

①InputStream inputStream  = Resources.getResourceAsStream(sqlMapConfig.xml路径位置);

②SqlSessionFactory sqlSessionFactory = new sqlSessionFactoryBuilder().build(inputStream);

3.由会话工厂创建sqlSession即会话，操作数据库需要通过sqlSession进行。  sqlSession是线程不安全的，每个线程都应该有它独自的sqlSession，使用完就关闭。

4.mybatis底层自定义了Executor执行器接口操作数据库，Executor接口有两个实现，一个是基本执行器、一个是缓存执行器。  (Executor才是真正操作数据库的,不过是底层 所以我们认为是sqlSession在进行操作)

5.Mapped Statement也是mybatis一个底层封装对象，它包装了mybatis配置信息及sql映射信息等。mapper.xml文件中一个sql对应一个Mapped Statement对象， sql的id即是Mapped statement的id。 

6.Mapped Statement对sql执行输入参数进行定义，包括HashMap、基本类型、pojo，Executor通过Mapped Statement在执行sql前将输入的java对象映射至sql中，输入参数映射就是jdbc编程中对preparedStatement设置参数。 

7.Mapped Statement对sql执行输出结果进行定义，包括HashMap、基本类型、pojo，Executor通过Mapped Statement在执行sql后将输出结果映射至java对象中，输出结果映射过程相当于jdbc编程中对结果的解析处理过程。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

/**   * @Title MybatisFirstTest.java   * @Description 查增删改   *   * @author Charles7c   */ public  class  MybatisFirstTest {        private  SqlSessionFactory sqlsessionFactory;        @Before      public  void  before()  throws  Exception {          // 根据流创建sqlSessionFactory          String resource =  "sqlMapConfig.xml" ;          // Resources 是mybatis工具          InputStream inputStream = Resources.getResourceAsStream(resource);            sqlsessionFactory =  new  SqlSessionFactoryBuilder().build(inputStream);      }        // 查询测试      @Test      public  void  selectTest() {          // 工厂开启session          SqlSession openSession = sqlsessionFactory.openSession();          // 查询结果为一个所以用selectOne          User user = openSession.selectOne( "user.findUserById" ,  10 );          System.out.println(user);          // 释放资源          openSession.close();      }        // 添加测试      @Test      public  void  addTest() {          SqlSession openSession = sqlsessionFactory.openSession();          // 创建user对象 填充对象          User user =  new  User();          user.setUsername( "秋香" );          user.setSex( "1" );          user.setBirthday( new  Date());          user.setAddress( "华府" );          // rows : 影响行数          int  rows = openSession.insert( "addUser" , user);          // 增删改必须提交事务          openSession.commit();          // 释放资源          openSession.close();      }        // 删除测试      @Test      public  void  deleteTest() {          SqlSession openSession = sqlsessionFactory.openSession();          openSession.delete( "user.deleteUser" ,  28 );          openSession.commit();          // 释放资源          openSession.close();      }        // 修改测试      @Test      public  void  updateTest() {            SqlSession openSession = sqlsessionFactory.openSession();          User user =  new  User();          user.setId( 27 );          user.setUsername( "白风" );          user.setBirthday( new  Date());          user.setSex( "2" );          user.setAddress( "苟且" );          openSession.delete( "user.updateUser" , user);          // 提交          openSession.commit();          // 释放资源          openSession.close();      }        // 模糊查询测试      @Test      public  void  likeTest() {            SqlSession openSession = sqlsessionFactory.openSession();          // 查询的不清楚多少 用selectList          List list = openSession.selectList( "likeQuery" ,  '明' );          for  (User user : list) {              System.out.println(user);          }          // 释放资源          openSession.close();      }   }

8. #{} 与 ${}区别

#{}表示一个占位符号，通过#{}可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换。#{}可以有效防止sql注入。 #{}可以接收简单类型值或pojo属性值。 如果parameterType传输单个简单类型值，#{}括号中可以是value或其它名称。

${}表示拼接sql串，通过${}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换， ${}可以接收简单类型值或pojo属性值，如果parameterType传输单个简单类型值，${}括号中只能是value。

sql注入案例:"%"#{}"%" 如果#{}传入的是

     < typeAliases >

        

        

        

         < package  name = "com.github.pojo"  />

     typeAliases >

    

     < environments  default = "development" >

         < environment  id = "development" >

            

             < transactionManager  type = "JDBC"  />

            

             < dataSource  type = "POOLED" >

                 < property  name = "driver"  value = "com.mysql.jdbc.Driver"  />

                 < property  name = "url"

                     value = "jdbc:mysql://localhost:3306/mybatis45?characterEncoding=utf-8"  />

                 < property  name = "username"  value = "root"  />

                 < property  name = "password"  value = "root"  />

             dataSource >

         environment >

     environments >

 

    

     < mappers >

        

        

         

        

        

         

        

         < package  name = "com.github.mapper" />

     mappers >

configuration >

2.UserMapper.java 接口

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

// 2.Mapper接口的方法名和Mapper.xml中statement的id必须相同 // 3.Mapper接口的入参类型必须和Mapper.xml中定义的每个sql的parameterType相同 // 4.Mapper接口的输出参数类型必须和Mapper.xml中定义的每个sql的resultType相同 public  interface  UserMapper {        // 根据用户id查询一个用户信息      public  User findUserById(Integer id);        // 根据用户名称模糊查询用户信息列表      public  List likeQuery(String username);        // 添加用户信息      public  void  addUser(User user);   }

3.UserMapper.xml 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

xml  version = "1.0"  encoding = "UTF-8"  ?> PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> < mapper  namespace = "com.github.mapper.UserMapper" >            < select  id = "findUserById"  parameterType = "Integer"  resultType = "user" >         select * from user where id = #{id}       select >                 < insert  id = "addUser"  parameterType = "user" >          insert into user           (username, birthday,sex,address)          values(#{username},#{birthday},#{sex},#{address})      insert >                 < delete  id = "deleteUser"  parameterType = "Integer" >          delete  from user where id = #{id}      delete >            < update  id = "updateUser"  parameterType = "user" >          update user set           username = #{username},          birthday = #{birthday},          sex = #{sex},          address = #{address}          where id = #{id}      update >                 < select  id = "likeQuery"  parameterType = "String"  resultType = "user" >          select * from user where username like '%${value}%'      select >       mapper >

4.使用junit进行测试

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

public  class  UserMapperTest {        private  SqlSessionFactory sqlSessionFactory;        @Before      public  void  init()  throws  Exception {          // 1.加载核心配置文件 在src下          String resource =  "SqlMapConfig.xml" ;            // 2.获取xml文件流          InputStream in = Resources.getResourceAsStream(resource);            // 3.通过流构造SqlSessionFactory SqlSessionFactoryBuilder将其当成一个工具          sqlSessionFactory =  new  SqlSessionFactoryBuilder().build(in);      }        @Test      public  void  testFindUserById() {          // 工厂开启session          SqlSession sqlSession = sqlSessionFactory.openSession();          // 从sqlSession中获取UserMapper接口的代理对象          UserMapper mapper = sqlSession.getMapper(UserMapper. class );          // 执行查询          User user = mapper.findUserById( 27 );          System.out.println(user);          // 释放资源          sqlSession.close();      }        @Test      public  void  testLikeQuery() {          // 工厂开启session          SqlSession sqlSession = sqlSessionFactory.openSession();          // 从sqlSession中获取UserMapper接口的代理对象          UserMapper mapper = sqlSession.getMapper(UserMapper. class );          // 执行查询          List list = mapper.likeQuery( "明" );          // 因为我知道数据不为空所以不进行防止空指针操作了          for  (User user : list) {              System.out.println(user);          }          // 释放资源          sqlSession.close();      }        @Test      public  void  testAddUser() {          // 工厂开启session          SqlSession sqlSession = sqlSessionFactory.openSession();          // 从sqlSession中获取UserMapper接口的代理对象          UserMapper mapper = sqlSession.getMapper(UserMapper. class );          User user =  new  User();          user.setUsername( "赵云" );          user.setAddress( "常山" );          // 执行添加          mapper.addUser(user);          // 执行提交事务!!!          sqlSession.commit();          // 释放资源          sqlSession.close();      }   }