Mybatis入门看这一篇就够了

客官°小女子只卖身不卖艺 2021-09-15 00:14 510阅读 0赞

# 什么是MyBatis #

> MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis。是一个基于Java的持久层框架

# 为什么我们要用Mybatis？ #

无论是Mybatis、Hibernate都是ORM的一种实现框架，都是对JDBC的一种封装！

![这里写图片描述][SouthEast]

到目前为止，我们已经在持久层中学了几种技术了…

*  **Hibernate**
 *  **jdbc**
 *  **SpringDAO**

那我们为啥还要学Mybatis呢？？？现在Mybatis在业内大行其道，那为啥他能那么火呢？？

Hibernate是一个比较老旧的框架，用过他的同学都知道，只要你会用，用起来十分舒服…啥sql代码都不用写…但是呢，它也是有的缺点：：**处理复杂业务时，灵活度差, 复杂的HQL难写难理解，例如多表查询的HQL语句**

而JDBC很容易理解，就那么几个固定的步骤，就是开发起来太麻烦了，因为什么都要我们自己干..

而SpringDAO其实就是JDBC的一层封装，就类似于dbutils一样，没有特别出彩的地方….

我们可以认为，**Mybatis就是jdbc和Hibernate之间的一个平衡点**…毕竟现在业界都是用这个框架，我们也不能不学呀！

--------------------

# Mybatis快速入门 #

其实我们已经学过了Hibernate了，对于Mybatis入门其实就非常类似的。因此就很简单就能掌握基本的开发了…

## 导入开发包 ##

导入Mybatis开发包

*  mybatis-3.1.1.jar
 *  commons-logging-1.1.1.jar
 *  log4j-1.2.16.jar
 *  cglib-2.2.2.jar
 *  asm-3.3.1.jar

导入mysql/oracle开发包

*  mysql-connector-java-5.1.7-bin.jar
 *  Oracle 11g 11.2.0.1.0 JDBC\_ojdbc6.jar

## 准备测试工作 ##

创建一张表

create table students( id int(5) primary key, name varchar(10), sal double(8,2) );

创建实体：

/** * Created by ozc on 2017/7/21. */
    
    public class Student { 
        private Integer id;
        private String name;
        private Double sal;
    
        public Student() {
        }
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Double getSal() {
            return sal;
        }
    
        public void setSal(Double sal) {
            this.sal = sal;
        }
    }

## 创建mybatis配置文件 ##

创建mybatis的配置文件，配置数据库的信息….数据库我们可以配置多个，但是默认的只能用一个…

<?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>
    
    
        
        <properties resource="db.properties"/>
    
        
        <environments default="mysql_developer">
            
            <environment id="mysql_developer">
                
                <transactionManager type="jdbc"/>
                
                <dataSource type="pooled">
                    
                    <property name="driver" value="${mysql.driver}"/>
                    <property name="url" value="${mysql.url}"/>
                    <property name="username" value="${mysql.username}"/>
                    <property name="password" value="${mysql.password}"/>
                </dataSource>
            </environment>
    
    
            
            <environment id="oracle_developer">
                
                <transactionManager type="jdbc"/>
                
                <dataSource type="pooled">
                    
                    <property name="driver" value="${oracle.driver}"/>
                    <property name="url" value="${oracle.url}"/>
                    <property name="username" value="${oracle.username}"/>
                    <property name="password" value="${oracle.password}"/>
                </dataSource>
            </environment>
        </environments>
    
    
    </configuration>

## 编写工具类测试是否获取到连接 ##

使用Mybatis的API来创建一个工具类，通过mybatis配置文件与数据库的信息，得到Connection对象

package cn.itcast.javaee.mybatis.util;
    
    import java.io.IOException;
    import java.io.Reader;
    import java.sql.Connection;
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    
    /** * 工具类 * @author AdminTC */
    public class MybatisUtil { 
        private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<SqlSession>();
        private static SqlSessionFactory sqlSessionFactory;
        /** * 加载位于src/mybatis.xml配置文件 */
        static{
            try {
                Reader reader = Resources.getResourceAsReader("mybatis.xml");
                sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
            } catch (IOException e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        }
        /** * 禁止外界通过new方法创建 */
        private MybatisUtil(){}
        /** * 获取SqlSession */
        public static SqlSession getSqlSession(){
            //从当前线程中获取SqlSession对象
            SqlSession sqlSession = threadLocal.get();
            //如果SqlSession对象为空
            if(sqlSession == null){
                //在SqlSessionFactory非空的情况下，获取SqlSession对象
                sqlSession = sqlSessionFactory.openSession();
                //将SqlSession对象与当前线程绑定在一起
                threadLocal.set(sqlSession);
            }
            //返回SqlSession对象
            return sqlSession;
        }
        /** * 关闭SqlSession与当前线程分开 */
        public static void closeSqlSession(){
            //从当前线程中获取SqlSession对象
            SqlSession sqlSession = threadLocal.get();
            //如果SqlSession对象非空
            if(sqlSession != null){
                //关闭SqlSession对象
                sqlSession.close();
                //分开当前线程与SqlSession对象的关系，目的是让GC尽早回收
                threadLocal.remove();
            }
        }   
        /** * 测试 */
        public static void main(String[] args) {
            Connection conn = MybatisUtil.getSqlSession().getConnection();
            System.out.println(conn!=null?"连接成功":"连接失败");
        }
    }

## 创建实体与映射关系文件 ##

配置实体与表的映射关系

<?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">
    
    
    <mapper namespace="cn.itcast.javaee.mybatis.app04.Student"> 
    
        
        <resultMap type="student" id="studentMap">
                                     
            <id property="id" column="id"/>
            <result property="name" column="name"/>
            <result property="sal" column="sal"/>
        </resultMap>
    
    </mapper>

现在我们已经有了Mybatis的配置文件和表与实体之前的映射文件了，因此我们要将配置文件和映射文件关联起来

在测试类上，我们是可以获取得到连接的

![这里写图片描述][SouthEast 1]

--------------------

## 编写DAO ##

public class StudentDao { 
    
    
        public void add(Student student) throws Exception {
            //得到连接对象
            SqlSession sqlSession = MybatisUtil.getSqlSession();
            sqlSession.insert();
        }
    
        public static void main(String[] args) throws Exception {
    
            StudentDao studentDao = new StudentDao();
    
            Student student = new Student(1, "zhongfucheng", 10000D);
            studentDao.add(student);
    
        }
    }

到现在为止，我们实体与表的映射文件仅仅映射了实体属性与表的字段的关系…

我们在Hibernate中如果想要插入数据什么的，只要调用save()方法就行了。Hibernate是自动化屏蔽掉了数据库的差异，而我们**Mybatis是需要自己手动编写SQL代码的**…

那么SQL代码是写在哪里的呢？？？明显地，我们作为一个框架，不可能在程序中写SQL，我们是在实体与表的映射文件中写的！

**Mybatis实体与表的映射文件中提供了insert标签【SQL代码片段】供我们使用**

//在JDBC中我们通常使用?号作为占位符，而在Mybatis中，我们是使用#{}作为占位符
        //parameterType我们指定了传入参数的类型
        //#{}实际上就是调用了Student属性的get方法
    
        <insert id="add" parameterType="Student">
    
            INSERT INTO ZHONGFUCHENG.STUDENTS (ID, NAME, SAL) VALUES (#{id},#{name},#{sal});
        </insert>

在程序中调用映射文件的SQL代码片段

public void add(Student student) throws Exception {
            //得到连接对象
            SqlSession sqlSession = MybatisUtil.getSqlSession();
            try{
                //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
                sqlSession.insert("StudentID.add", student);
                sqlSession.commit();
            }catch(Exception e){
                e.printStackTrace();
                sqlSession.rollback();
                throw e;
            }finally{
                MybatisUtil.closeSqlSession();
            }
        }

值得注意的是：**Mybatis中的事务是默认开启的，因此我们在完成操作以后，需要我们手动去提交事务！**

## Mybatis工作流程 ##

*  **通过Reader对象读取Mybatis映射文件**
 *  **通过SqlSessionFactoryBuilder对象创建SqlSessionFactory对象**
 *  **获取当前线程的SQLSession**
 *  **事务默认开启**
 *  **通过SQLSession读取映射文件中的操作编号，从而读取SQL语句**
 *  **提交事务**
 *  **关闭资源**

# 完成CRUD操作 #

我们在上面中已经简单知道了Mybatis是怎么使用的以及工作流程了，这次我们使用Mybatis来完成CRUD的操作，再次巩固Mybatis的开发步骤以及一些细节

包与类之间的结构

![这里写图片描述][SouthEast 2]

## 增加学生 ##

配置文件

<?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>
        
        <properties resource="db.properties"/>
    
        
        <environments default="mysql_developer">
            
            <environment id="mysql_developer">
                
                <transactionManager type="jdbc"/>
                
                <dataSource type="pooled">
                    
                    <property name="driver" value="${mysql.driver}"/>
                    <property name="url" value="${mysql.url}"/>
                    <property name="username" value="${mysql.username}"/>
                    <property name="password" value="${mysql.password}"/>
                </dataSource>
            </environment>
    
    
            
            <environment id="oracle_developer">
                
                <transactionManager type="jdbc"/>
                
                <dataSource type="pooled">
                    
                    <property name="driver" value="${oracle.driver}"/>
                    <property name="url" value="${oracle.url}"/>
                    <property name="username" value="${oracle.username}"/>
                    <property name="password" value="${oracle.password}"/>
                </dataSource>
            </environment>
        </environments>
        <mappers>
            <mapper resource="zhongfucheng/StudentMapper.xml"/>
        </mappers>
    </configuration>

映射文件

<mapper namespace="StudentID">
    
        
        <resultMap type="zhongfucheng.Student" id="studentMap">
            
            <id property="id" column="id"/>
            <result property="name" column="name"/>
            <result property="sal" column="sal"/>
        </resultMap>
    
        <insert id="add" parameterType="zhongfucheng.Student">
            INSERT INTO ZHONGFUCHENG.STUDENTS (ID, NAME, SAL) VALUES (#{id},#{name},#{sal});
        </insert>
    
    </mapper>

插入数据

public class StudentDao { 
    
        public void add(Student student) throws Exception {
            //得到连接对象
            SqlSession sqlSession = MybatisUtil.getSqlSession();
            try{
                //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
                sqlSession.insert("StudentID.add", student);
                sqlSession.commit();
            }catch(Exception e){
                e.printStackTrace();
                sqlSession.rollback();
                throw e;
            }finally{
                MybatisUtil.closeSqlSession();
            }
        }
        public static void main(String[] args) throws Exception {
            StudentDao studentDao = new StudentDao();
            Student student = new Student(3, "zhong3", 10000D);
            studentDao.add(student);
        }
    }

![这里写图片描述][SouthEast 3]

## 根据ID查询数据 ##

增加select标签

<select id="findById" parameterType="int" resultMap="studentMap">
            SELECT * FROM STUDENTS WHERE id = #{id};
        </select>

查询出来的结果是一个Student对象，我们调用SelectOne方法

public Student findById(int id) throws Exception {
            //得到连接对象
            SqlSession sqlSession = MybatisUtil.getSqlSession();
            try{
                //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
                return sqlSession.selectOne("StudentID.findById",id);
            }catch(Exception e){
                e.printStackTrace();
                sqlSession.rollback();
                throw e;
            }finally{
                MybatisUtil.closeSqlSession();
            }
        }
        public static void main(String[] args) throws Exception {
            StudentDao studentDao = new StudentDao();
            Student student = studentDao.findById(1);
            System.out.println(student.getName());
    
        }

![这里写图片描述][SouthEast 4]

## 查询所有数据 ##

<select id="findAll" resultMap="studentMap">
            SELECT * FROM STUDENTS;
        </select>

我们查询出来的结果不单单只有一个对象了，因此我们使用的是SelectList这个方法

public List<Student> findAll() throws Exception {
            //得到连接对象
            SqlSession sqlSession = MybatisUtil.getSqlSession();
            try{
                //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
                return sqlSession.selectList("StudentID.findAll");
            }catch(Exception e){
                e.printStackTrace();
                sqlSession.rollback();
                throw e;
            }finally{
                MybatisUtil.closeSqlSession();
            }
        }
        public static void main(String[] args) throws Exception {
            StudentDao studentDao = new StudentDao();
            List<Student> students = studentDao.findAll();
            System.out.println(students.size());
    
        }

## 根据id删除 ##

<delete id="delete" parameterType="int">
            DELETE FROM STUDENTS WHERE id=#{id};
    
        </delete>

调用delete方法删除

public void delete(int id ) throws Exception {
            //得到连接对象
            SqlSession sqlSession = MybatisUtil.getSqlSession();
            try{
                //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
                sqlSession.delete("StudentID.delete", id);
                sqlSession.commit();
            }catch(Exception e){
                e.printStackTrace();
                sqlSession.rollback();
                throw e;
            }finally{
                MybatisUtil.closeSqlSession();
            }
        }
        public static void main(String[] args) throws Exception {
            StudentDao studentDao = new StudentDao();
            studentDao.delete(1);
    
        }

![这里写图片描述][SouthEast 5]

## 修改 ##

<update id="update" parameterType="zhongfucheng.Student">
    
            update students set name=#{name},sal=#{sal} where id=#{id};
    
        </update>

查询出对应的对象，对其进行修改

public void update(Student student ) throws Exception {
            //得到连接对象
            SqlSession sqlSession = MybatisUtil.getSqlSession();
            try{
                //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
                sqlSession.update("StudentID.update", student);
                sqlSession.commit();
            }catch(Exception e){
                e.printStackTrace();
                sqlSession.rollback();
                throw e;
            }finally{
                MybatisUtil.closeSqlSession();
            }
        }
        public static void main(String[] args) throws Exception {
            StudentDao studentDao = new StudentDao();
            Student student = studentDao.findById(2);
            student.setName("fucheng");
            student.setSal(2000D);
            studentDao.update(student);
    
        }

![这里写图片描述][SouthEast 6]

## 小细节 ##

--------------------

## Mybatis分页 ##

分页是一个非常实用的技术点，我们也来学习一下使用Mybatis是怎么分页的…

我们的分页是需要多个参数的，并不是像我们之前的例子中只有一个参数。**当需要接收多个参数的时候，我们使用Map集合来装载**！

public List<Student>  pagination(int start ,int end) throws Exception {
            //得到连接对象
            SqlSession sqlSession = MybatisUtil.getSqlSession();
            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();
            }
        }
        public static void main(String[] args) throws Exception {
            StudentDao studentDao = new StudentDao();
            List<Student> students = studentDao.pagination(0, 3);
            for (Student student : students) {
    
                System.out.println(student.getId());
    
            }
    
        }

那么在实体与表映射文件中，我们接收的参数就是map集合

<select id="pagination" parameterType="map" resultMap="studentMap">
    
            /*根据key自动找到对应Map集合的value*/
            select * from students limit #{start},#{end};
    
        </select>

![这里写图片描述][SouthEast 7]

# 动态SQL #

何为动态SQL？？回顾一下我们之前写的SSH项目中，有多条件查询的情况，如下图

![这里写图片描述][SouthEast 8]

我们当时刚开始做的时候，是需要在Controller中判断SQL是否已经有条件了，因为SQL语句需要拼接起来….这样干的话，就非常容易出错的。

如下的代码，如果有多个条件的话，那么拼接起来很容易出错！

public String listUI() {
    
            //查询语句
            String hql = "FROM Info i ";
            List<Object> objectList  = new ArrayList<>();
    
            //根据info是否为null来判断是否是条件查询。如果info为空，那么是查询所有。
            if (info != null) {
                if (StringUtils.isNotBlank(info.getTitle())) {
                    hql += "where i.title like ?";
                    objectList.add("%" + info.getTitle() + "%");
                }
            }
            infoList = infoServiceImpl.findObjects(hql,objectList);
            ActionContext.getContext().getContextMap().put("infoTypeMap", Info.INFO_TYPE_MAP);
            return "listUI";
        }

后来，我们觉得这样不好，于是就专门写了一个查询助手类：

package zhongfucheng.core.utils;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /** * Created by ozc on 2017/6/7. */
    public class QueryHelper { 
    
        private String fromClause = "";
        private String whereClause = "";
        private String orderbyClause = "";
        private List<Object> objectList;
    
        public static String ORDER_BY_ASC = "asc";
        public static String ORDER_BY_DESC = "desc";
    
    
    
        //FROM子句只出现一次
        /** * 构建FROM字句，并设置查询哪张表 * @param aClass 用户想要操作的类型 * @param alias 别名 */
        public QueryHelper(Class aClass, String alias) {
            fromClause = " FROM " + aClass.getSimpleName() + " " + alias;
        }
        //WHERE字句可以添加多个条件，但WHERE关键字只出现一次
        /** * 构建WHERE字句 * @param condition * @param objects * @return */
        public QueryHelper addCondition(String condition, Object... objects) {
            //如果已经有字符了，那么就说明已经有WHERE关键字了
            if (whereClause.length() > 0) {
                whereClause += " AND " + condition;
            } else {
                whereClause += " WHERE" + condition;
            }
            //在添加查询条件的时候，?对应的查询条件值
            if (objects == null) {
                objectList = new ArrayList<>();
            }
    
            for (Object object : objects) {
                objectList.add(object);
            }
    
            return this;
        }
        /** * * @param property 要排序的属性 * @param order 是升序还是降序 * @return */
        public QueryHelper orderBy(String property, String order) {
    
            //如果已经有字符了，那么就说明已经有ORDER关键字了
            if (orderbyClause.length() > 0) {
                orderbyClause += " , " + property +" " + order;
            } else {
                orderbyClause += " ORDER BY " + property+" " + order;
            }
            return this;
        }
    
        /** * 返回HQL语句 */
        public String returnHQL() {
            return fromClause + whereClause + orderbyClause;
        }
    
        /** * 得到参数列表 * @return */
        public List<Object> getObjectList() {
            return objectList;
        }
    }

这样一来的话，我们就不用自己手动拼接了，给我们的查询助手类去拼接就好了。

而如果我们使用Mybatis的话，就可以免去查询助手类了。因为**Mybatis内部就有动态SQL的功能【动态SQL就是自动拼接SQL语句】**！

## 动态查询 ##

<select id="findByCondition" resultMap="studentMap" parameterType="map">
    
            select * from students
    
            <where>
                <if test="name!=null">
                    and name=#{name}
                </if>
                <if test="sal!=null">
                    and sal < #{ sal} </if>
            </where>
    
        </select>

查询出来小于9000块的人

public List<Student> findByCondition(String name,Double sal) throws Exception {
            //得到连接对象
            SqlSession sqlSession = MybatisUtil.getSqlSession();
            try{
                //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
                /** * 由于我们的参数超过了两个，而方法中只有一个Object参数收集 * 因此我们使用Map集合来装载我们的参数 */
                Map<String, Object> map = new HashMap();
                map.put("name", name);
                map.put("sal", sal);
                return sqlSession.selectList("StudentID.findByCondition", map);
            }catch(Exception e){
                e.printStackTrace();
                sqlSession.rollback();
                throw e;
            }finally{
                MybatisUtil.closeSqlSession();
            }
        }
        public static void main(String[] args) throws Exception {
            StudentDao studentDao = new StudentDao();
            List<Student> students = studentDao.findByCondition(null,9000D);
            for (Student student : students) {
                System.out.println(student.getId() + "---" + student.getName() + "----" + student.getSal());
            }
    
    
        }

![这里写图片描述][SouthEast 9]

## 动态更新 ##

![这里写图片描述][SouthEast 10]

<update id="updateByConditions" parameterType="map">
    
            update students
            <set>
                <if test="name!=null">
                     name = #{name},
                </if>
                <if test="sal!=null">
                     sal = #{sal},
                </if>
            </set>
            where id = #{id}
        </update>

给出三个更新的字段

public void updateByConditions(int id,String name,Double sal) throws Exception {
            //得到连接对象
            SqlSession sqlSession = MybatisUtil.getSqlSession();
            try{
                //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
                /** * 由于我们的参数超过了两个，而方法中只有一个Object参数收集 * 因此我们使用Map集合来装载我们的参数 */
                Map<String, Object> map = new HashMap();
                map.put("id", id);
                map.put("name", name);
                map.put("sal", sal);
                sqlSession.update("StudentID.updateByConditions", map);
                sqlSession.commit();
            }catch(Exception e){
                e.printStackTrace();
                sqlSession.rollback();
                throw e;
            }finally{
                MybatisUtil.closeSqlSession();
            }
        }
    
        public static void main(String[] args) throws Exception {
            StudentDao studentDao = new StudentDao();
            studentDao.updateByConditions(2,"haha",500D);
    
        }

![这里写图片描述][SouthEast 11]

## 动态删除 ##

![这里写图片描述][SouthEast 12]  
以前我们使用JDBC也好，Hibernate也好，想要批量删除的时候，总是使用的是循环删除。而我们现在使用的是Mybatis，SQL语句是自己写的。所以我们可以写下如下的SQL来进行删除

delete from students where id in (?,?,?,?);

而我们的Mybatis又支持动态SQL,所以删除起来就非常方便了！

<delete id="deleteByConditions" parameterType="int">
    
            
            delete from students where id in
             <foreach collection="array" open="(" close=")" separator="," item="ids">
                 #{ids}
             </foreach>
    
        </delete>

删除编号为2，3，4的记录

public void deleteByConditions(int... ids) throws Exception {
            //得到连接对象
            SqlSession sqlSession = MybatisUtil.getSqlSession();
            try{
                //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
                /** * 由于我们的参数超过了两个，而方法中只有一个Object参数收集 * 因此我们使用Map集合来装载我们的参数 */
                sqlSession.delete("StudentID.deleteByConditions", ids);
                sqlSession.commit();
            }catch(Exception e){
                e.printStackTrace();
                sqlSession.rollback();
                throw e;
            }finally{
                MybatisUtil.closeSqlSession();
            }
        }
    
        public static void main(String[] args) throws Exception {
            StudentDao studentDao = new StudentDao();
            studentDao.deleteByConditions(2,3,4);
    
        }

![这里写图片描述][SouthEast 13]

## 动态插入 ##

我们要想动态插入的话，就比其他的DML语句稍微复杂一点，因为它有两部分是不确定的，平常的SQL语句是这样的：

insert into student(id,name,sal) values(?,?,?)

![这里写图片描述][SouthEast 14]

SQL代码块是不能像之前那样帮我们自动去除多余的逗号的，因此我们需要使用trim标签来自己手动去除…

编写insertSQL语句的时候，不要忘了写()括号。

<sql id="key">
            <trim suffixOverrides=",">
                <if test="id!=null">
                    id,
                </if>
    
                <if test="id!=null">
                    name,
                </if>
    
                <if test="id!=null">
                    sal,
                </if>
            </trim>
        </sql>
    
        <sql id="value">
            <trim suffixOverrides=",">
                <if test="id!=null">
                    #{id},
                </if>
    
                <if test="id!=null">
                    #{name},
                </if>
    
                <if test="id!=null">
                    #{sal},
                </if>
            </trim>
        </sql>
        
        <insert id="insertByConditions" parameterType="zhongfucheng.Student">
    
            insert into students (<include refid="key"/>) values
            (<include refid="value"/>)
    
        </insert>

测试三个不同内容的数据

public void insertByConditions(Student student) throws Exception {
            //得到连接对象
            SqlSession sqlSession = MybatisUtil.getSqlSession();
            try{
                //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
                sqlSession.insert("StudentID.insertByConditions", student);
                sqlSession.commit();
            }catch(Exception e){
                e.printStackTrace();
                sqlSession.rollback();
                throw e;
            }finally{
                MybatisUtil.closeSqlSession();
            }
        }
    
        public static void main(String[] args) throws Exception {
            StudentDao studentDao = new StudentDao();
            studentDao.insertByConditions(new Student(55, null, null));//name和sal为空
    
            studentDao.insertByConditions(new Student(66, "haxi", null));//sal为空
            studentDao.insertByConditions(new Student(77, null, 3999d));//name为空
    
    
        }

![这里写图片描述][SouthEast 15]

# 总结 #

*  Mybatis的准备工作与Hibernate差不多，都需要一个总配置文件、一个映射文件。
 *  Mybatis的SQLSession工具类使用ThreadLocal来对线程中的Session来进行管理。
 *  **Mybatis的事务默认是开启的，需要我们手动去提交事务。**
 *  **Mybatis的SQL语句是需要手写的，在程序中通过映射文件的命名空间.sql语句的id来进行调用!**
 *  在Mybatis中，增删改查都是需要我们自己写SQL语句的，然后在程序中调用即可了。SQL由于是我们自己写的，于是就相对Hibernate灵活一些。
 *  **如果需要传入多个参数的话，那么我们一般在映射文件中用Map来接收。**
 *  由于我们在开发中会经常用到条件查询，在之前，我们是使用查询助手来帮我们完成对SQL的拼接的。而Mybatis的话，我们是自己手写SQL代码的。
 *  **Mybatis也支持一些判断标签，于是我们就可以通过这些标签来完成动态CRUD的操作了。**
 *  值得注意的是，**我们的sql片段代码是需要我们自己手动去分割，号的。**

> 如果文章有错的地方欢迎指正，大家互相交流。**习惯在微信看技术文章，想要获取更多的Java资源的同学，可以关注微信公众号:Java3y**

[SouthEast]: /images/20210827/40fe6952f3bf42c48e5e57995e286eb8.png
[SouthEast 1]: /images/20210827/92aec603cd8f458fa30bd3b75051176f.png
[SouthEast 2]: /images/20210827/8e9152d54b0a43de9f79d6c7e6f30a9a.png
[SouthEast 3]: /images/20210827/357a1d58ca8146f08d9c0927fe0b3053.png
[SouthEast 4]: /images/20210827/e6f42e524d0c4c48bd176e1c7a6ba0e2.png
[SouthEast 5]: /images/20210827/462876a938b8455880fe84385a8a68ac.png
[SouthEast 6]: /images/20210827/49b5b2f792bc47b7ad548107c81e9e1d.png
[SouthEast 7]: /images/20210827/63398134d5d946d2877d3ee6a8a62090.png
[SouthEast 8]: /images/20210827/fb40e383b234486893797c7f2c14fd45.png
[SouthEast 9]: /images/20210827/5adfcc0b71ae48e4950fa464b7275a36.png
[SouthEast 10]: /images/20210827/9c5815a92c524af7b4f93a8095fb2297.png
[SouthEast 11]: /images/20210827/1c9442ad7aa24ba6a3cde242b172cbeb.png
[SouthEast 12]: /images/20210827/c9f058c9bf6042b0a11432fa63656b86.png
[SouthEast 13]: /images/20210827/6ad67fbaded94ce995a0eed3746dcdbf.png
[SouthEast 14]: /images/20210827/f5cfe7095a5f4e6da8d98901be2c694a.png
[SouthEast 15]: /images/20210827/9fdabb1f124940d3ac3aeae7c54b8ab1.png