mybatis总结

常见面试题：

1.ORM框架工作原理

　　　　1、以一定的映射方式，实体模型和数据库关系的映射

　　　　2、ORM框架启动时加载这些映射和数据库配置文件

　　　　3、ORM通过对最原生jdbc的封装提供更加便利的操作API

　　　　4、Dao通过ORM提供的便捷API以对象的方式操作数据库关系。

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

　　(1）mybatis是一个优秀的基于java的持久层框架，它内部封装了jdbc，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。

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

 3.MyBatis与Hibernate有哪些不同？

　　　(1)  Hibernate是一个完整的ORM框架,常规CRUD不需要写SQL语句，会自动生成SQL;  MyBatis 并不是一个完整的ORM框架,因为我们还需要自己去写全部SQL.

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

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

4. mybatis的基本工作流程　　

　　1.读取配置文件（配置文件包含数据库连接信息和Mapper映射文件或者Mapper包路径）

　　　　Mybatis 读取XML配置文件后会将内容放在一个Configuration类中，Configuration类会存在整个Mybatis生命周期，以便重复读取。

　　2. SqlSessionFactoryBuilder会读取Configuration类中信息创建SqlSessionFactory。SqlSessionFactory的生命周期是程序级,程序运行的时候建立起来,程序结束的时候消亡。

　　3.SqlSessionFactory建立SqlSession,目的执行sql语句，SqlSession是过程级,一个方法中建立,方法结束应该关闭

　　4.当用户使用mapper.xml文件中配置的的方法时，mybatis首先会解析sql动态标签为对应数据库sql语句的形式，并将其封装进MapperStatement对象，然后通过executor将sql注入数据库执行，并返回结果。

　　5.将返回的结果通过映射，包装成java对象。

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

#{}是预编译处理，Mybatis在处理#{}时，会将sql中的#{}替换为?号，调用PreparedStatement的set方法来赋值；防止SQL注入, 提高系统安全性.

${}是字符串替换。Mybatis在处理${}时，就是把${}替换成变量的值（没有  “ ” ），一般用与排序 和 分页场景。

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

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

<select id=”selectorder” parametertype=”int” resultetype=”me.gacl.domain.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=”me.gacl.domain.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>
 

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

8. 通常一个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执行结果返回。

9.Mybatis是如何进行分页的？分页插件的原理是什么？

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

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

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

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

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

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

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

在xml映射器中配置useGeneratedKeys参数，设定keyProperty的值为在Entity里面的字段名，通过实体类对象的getId()方法得到对应的值就是数据库中的主键值。

12. mybatis一级缓存二级缓存

一级缓存

Mybatis在没有配置的默认情况下只开启一级缓存，一级缓存只是相对于同一个SqlSession而言。所以在参数和SQL完全一样的情况下，我们使用同一个SqlSession对象调用一个Mapper方法，往往只执行一次SQL，因为使用SelSession第一次查询后，MyBatis会将其放在缓存中，以后再查询的时候，如果没有声明需要刷新，并且缓存没有超时的情况下，SqlSession都会取出当前缓存的数据，而不会再次发送SQL到数据库。

1、一级缓存的生命周期有多长？

　　a、MyBatis在开启一个数据库会话时，会 创建一个新的SqlSession对象，SqlSession对象中会有一个新的Executor对象。Executor对象中持有一个新的PerpetualCache对象；当会话结束时，SqlSession对象及其内部的Executor对象还有PerpetualCache对象也一并释放掉。

　　b、如果SqlSession调用了close()方法，会释放掉一级缓存PerpetualCache对象，一级缓存将不可用。

　　c、如果SqlSession调用了clearCache()，会清空PerpetualCache对象中的数据，但是该对象仍可使用。

　　d、SqlSession中执行了任何一个update操作(update()、delete()、insert()) ，都会清空PerpetualCache对象的数据，但是该对象可以继续使用。

二级缓存：

SqlSessionFactory层面上的二级缓存默认是不开启的，二级缓存的开席需要进行配置，实现二级缓存的时候，MyBatis要求返回的POJO必须是可序列化的。 也就是要求实现Serializable接口，配置方法很简单，只需要在映射XML文件配置就可以开启缓存了<cache/>，如果我们配置了二级缓存就意味着：

• 映射语句文件中的所有select语句将会被缓存。
• 映射语句文件中的所欲insert、update和delete语句会刷新缓存。
• 缓存会使用默认的Least Recently Used（LRU，最近最少使用的）算法来收回。
• 根据时间表，比如No Flush Interval,（CNFI没有刷新间隔），缓存不会以任何时间顺序来刷新。
• 缓存会存储列表集合或对象(无论查询方法返回什么)的1024个引用
• 缓存会被视为是read/write(可读/可写)的缓存，意味着对象检索不是共享的，而且可以安全的被调用者修改，不干扰其他调用者或线程所做的潜在修改。

参考mybatis面试总结：https://blog.csdn.net/a745233700/article/details/80977133

常见编程题 (涵盖：批量插入，批量删除)

1. SQL映射器Mapper接口

MyBatis基于代理机制，可以让我们无需再编写Dao的实现。直接把以前的dao接口定义成符合规则的Mapper。

注意事项:

① :接口必须Mapper结尾,名字是DomainMapper

② :mapper.xml文件要和Mapper接口建立关系,通过namespace:要能连接到Mapper接口

③ : User get(Long id)返回值,方法,参数类型等必须使:Mapper接口和mapper.xml保持一致

 具体步骤代码如下： 
1. 核心配置文件：mybatis-config.xml 及 db.properties 

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
	<!-- 引入db.properties -->
	<properties resource="db.properties"></properties>
	
	<!-- 环境们的配置 -->
	<environments default="development">
		<!--环境的配置:  -->
		<environment id="development">
			<!--使用jdbc方式管理事务 -->
			<transactionManager type="JDBC" />
			<!-- 数据源的四大配置 -->
			<dataSource type="POOLED">
				<property name="driver" value="${jdbc.driverClassName}" />
				<property name="url" value="${jdbc.url}" />
				<property name="username" value="${jdbc.username}" />
				<property name="password" value="${jdbc.password}" />
			</dataSource>
		</environment>
	</environments>
	<!-- 注册对象关系映射文件 -->
	<mappers>
		<mapper resource="com/gs/domain/UserMapper.xml"/>
	</mappers>
</configuration>

　　

db.properties 文件

jdbc.driverClassName = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=UTF-8
jdbc.username = root
jdbc.password = root

　　

2. 创建sqlSession 对象的工具类：MyBatisUtils.java

package com.gs.tools;

import java.io.IOException;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MyBatisUtils {
	private static SqlSessionFactory factory= null;
	static {
		try {
			factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	public static SqlSession getSession(){
		return factory.openSession();
	}
}

　

3. User.java 三个字段。

public class User {
	private Long id;
	private String username;
	private String password;
    ......getter setter 无参 有参，toString()
    
}    

　　

4. UserMapper 接口

public interface UserMapper {
	
	 //得到一个用户
	User get(Long id);
	
	 // 得到所有用户
	List<User> getAll();
	
	 //批量删除用户
	void deleteBatch(List<Long> list);
	
	 //批量插入用户
	void insertBatch(List<User> lists);
}

　　

5.UserMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 使用sql映射器Mapper接口的方式
namespace的值 是  对应接口的全限定名称

 -->
<mapper namespace="com.gs.mapper.UserMapper">
	
	<!-- 得到一个用户 -->
	<select id="get" parameterType="long" resultType="com.gs.domain.User">
		select * from user where id = #{?}
	</select>
	
	<!--得到所有用户  -->
	<select id="getAll" resultType="com.gs.domain.User">
		select * from user 
	</select>
	
	<!--批量删除用户  -->
	<delete id="deleteBatch" parameterType="list">
		delete from user where id in 
		<foreach collection="list" index="index" open="(" separator="," close=")" item="ids">
			#{ids}
		</foreach>
	</delete>
	
	<!-- 批量插入用户 -->
	<insert id="insertBatch" parameterType="list">
	insert into user(id,username,password) 
	values   
	<foreach collection="list" item="item" index="index" separator=",">
		(#{item.id},#{item.username},#{item.password})
	</foreach> 

	</insert>
</mapper> 

　　

6.测试类 testMybatis.java

package com.gs.test;

import java.util.ArrayList;
import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import com.gs.domain.User;
import com.gs.mapper.UserMapper;
import com.gs.tools.MyBatisUtils;

public class testMybatis{
	@Test
	public void getuser(){
		SqlSession session = MyBatisUtils.getSession();
		//获取UserMapper接口的对象
		UserMapper userMapper = session.getMapper(UserMapper.class);
		//namespace = 接口全限定名称 +.+ 方法名
		User user = userMapper.get(1L);
		System.out.println(user);
	}
	@Test
	public void getAllUser(){
		SqlSession session = MyBatisUtils.getSession();
		UserMapper userMapper = session.getMapper(UserMapper.class);
		List<User> users = userMapper.getAll();
		System.out.println(users);
	}
	@Test
	public void deleteBatchUser(){
		SqlSession session = MyBatisUtils.getSession();
		UserMapper userMapper = session.getMapper(UserMapper.class);
		List<Long> lists = new ArrayList<>();
		lists.add(2L);
		lists.add(3L);
		userMapper.deleteBatch(lists);
		session.commit();//提交事务
		session.close();
	}
	@Test
	public void insertBatchUser(){
		SqlSession session = MyBatisUtils.getSession();
		UserMapper userMapper = session.getMapper(UserMapper.class);
		List<User> lists = new ArrayList<>();
		lists.add(new User(null,"樊俊杰","456"));
		lists.add(new User(null,"樊太快了","789"));
		userMapper.insertBatch(lists);
		session.commit();//提交事务
		session.close();
	}
}

　　

　

2. MyBatis提供两种方式处理我们多表关联对象，嵌套查询和嵌套结果。

 1.(多对一)关联映射。  （一个部门有多个用户，先从多个用户入手。）

1. User 和 Dept 实体类

public class User {
	private Long id;
	private String name;
	private String password;
	private Dept dept;
}

public class Dept {
	private Long id;
	private String name;
	
}

　　

2.  DomainMapper.xml

<!-- 单向多对一嵌套结果（发一条左外连接sql解决问题，映射文件Mapper结果的手动封装ResultMap）
		使用嵌套结果映射来处理重复的联合(association)结果的子集。
	-->
	<select id="getUser1" resultMap="many2oneMap">
		select u.id, u.name, u.password,  d.id did,  d.name dname
		from t_user u  left join t_dept d  on u.dept_id=d.id; 
	</select>
	
	<!-- 封装查询的User结果 -->
	<resultMap type="com.gs.manytoone.User" id="many2oneMap">
		<id column="id" property="id"/>
		<result column="name" property="name"/>
		<result column="password" property="password"/>
		<!--user的dept属性是一个对象Dept，使用联合查询关键字来封装 association：联合查询-->
		<association property="dept" javaType="com.gs.manytoone.Dept">
			<id column="did" property="id"/>
			<result column="dname" property="name"/>
		</association>
	</resultMap>
	
	
	
	<!-- 单向多对一嵌套查询(先查询多方User，使用ResultMap来封装结果，在结果里，再通过User的dept属性，再查一次Dept对象.)
	 -->
	 <select id="getUser2" resultMap="many2oneList">
	 		select id,name,password,dept_id from t_user;
	 </select>
	 <select id="getDeptById" parameterType="long" resultType="com.gs.manytoone.Dept">
	 		select id,name from t_dept where id= #{id}
	 </select>
	 <resultMap type="com.gs.manytoone.User" id="many2oneList">
	 		<id column="id" property="id"/>
			<result column="name" property="name"/>
			<result column="password" property="password"/>
			<association property="dept" column="dept_id" 
						select="com.gs.manytoone.DomainMapper.getDeptById">
			</association>
	 </resultMap>

　　

3. 测试类

@Test
	public void getUser1() {
		SqlSession session = MyBatisUtils.getSession();
		List<User> users = session.selectList("com.gs.manytoone.DomainMapper.getUser1");
		for (User user : users) {
			System.out.println(user);
		}
		session.commit();
		session.close();
	}
	
	@Test
	public void getUser2() {
		SqlSession session = MyBatisUtils.getSession();
		List<User> users = session.selectList("com.gs.manytoone.DomainMapper.getUser2");
		for (User user : users) {
			System.out.println(user);
		}
		session.commit();
		session.close();
	}

　　

4.查询的结果：

User [id=1, name=张三, password=123456, dept=Department [id=1, name=财务部]]
User [id=2, name=李四, password=111, dept=Department [id=1, name=财务部]]
User [id=3, name=五五, password=123, dept=Department [id=2, name=后勤部]]
User [id=4, name=周六, password=122, dept=Department [id=3, name=经理部]]
User [id=5, name=周七, password=12332, dept=Department [id=3, name=经理部]]

2.  (一对多，多对多)集合映射

员工和部门:

   在部门方，需要查询到当前部门下的所有员工。----集合查询

1. User 和 Dept 实体类

public class User {
	private Long id;
	private String name;
	private String password;
}
public class Dept {
	private Long id;
	private String name;
	private Set<User> users = new HashSet<>();
}

　　

2.  DomainMapper.xml

<!-- 单向一对多嵌套结果(一条sql语句) -->
	<select id="getDept1" resultMap="one2manyMap">
		select d.id did, d.name dname, u.id, u.name, u.password 
		from t_dept d left join t_user u
		on d.id=u.dept_id order by d.id
	</select>
	<resultMap type="com.gs.onetomany.Dept" id="one2manyMap">
		<id column="did" property="id"/>
		<result column="dname" property="name"/>
		<collection property="users" ofType="com.gs.onetomany.User"> 
			<id column="id" property="id"/>
			<result column="name" property="name"/>
			<result column="password" property="password"/>
		</collection>
	</resultMap>
	
	
	<!-- 单向一对多嵌套查询(先查询多个Dept，使用ResultMap来封装结果，在结果里，再通过Dept的users属性，再查一次User对象.) -->
	<select id="getDept2" resultMap="one2manyList">
		select d.id did , d.name dname from t_dept d
	</select>
	<select id="getUserById" parameterType="long" resultType="com.gs.onetomany.User">
		select id,name,password from t_user where dept_id=#{?}
	</select>
	<resultMap type="com.gs.onetomany.Dept" id="one2manyList">
		<id column="did" property="id"/>
		<result column="dname" property="name"/>
		<collection property="users" column="did"
					select="com.gs.onetomany.DomainMapper.getUserById">
		</collection>
	</resultMap>

　　

3. 测试类

@Test
	public void getUser1() {
		SqlSession session = MyBatisUtils.getSession();
		List<Dept> allDept = session.selectList("com.gs.onetomany.DomainMapper.getDept1");
		for (Dept dept : allDept) {
			System.out.println(dept);
		}
		session.commit();
		session.close();
	}
	
	@Test
	public void getUser2() {
		SqlSession session = MyBatisUtils.getSession();
		List<Dept> allDept = session.selectList("com.gs.onetomany.DomainMapper.getDept2");
		for (Dept dept : allDept) {
			System.out.println(dept);
		}
		session.commit();
		session.close();
	}

　　

　　

4.查询的结果：

Dept [id=1, name=财务部, users=[User [id=2, name=李四, password=111], User [id=1, name=张三, password=123456]]]
Dept [id=2, name=后勤部, users=[User [id=3, name=五五, password=123]]]
Dept [id=3, name=经理部, users=[User [id=5, name=周七, password=12332], User [id=4, name=周六, password=122]]]