mybatis基本学习-优快云博客

本文链接：https://blog.youkuaiyun.com/morningstarlyp/article/details/134275703

Mybatis原本是apache旗下的开源项目。原名叫ibatis，

2010年转投谷歌，从3.x开始更名为mybatis。

Mybatis是一款优秀的数据持久层框架

是对jdbc做了轻量级的封装

Mybatis对jdbc中的接口（connection）进行封装，

提供了一些自己的类实现

Mybatis 将数据库连接配置提取到xml文件中

也将sql语句也提取到xml文件中

还可以使用注解方式执行sql

还可以将数据库中记录映射到java对象中（pojo--model）

称为orm映射（object relational mapping）对象关系映射

还支持动态sql（可以在sql中进行逻辑处理）以及数据缓存

步骤：

搭建mybatis

1.准备工作创建一个数据库，再创建一个表

2.创建一个maven项目

3.添加依赖

4.创建一个mybatis核心配置

5.创建一个访问接口

6.创建sql

数据库连接池：

有一个容器，可以事先创建一些与数据库的连接对象 sqlsession connection

使用时不需要创建，直接从容器获取

因为之前每次创建数据库都会创建一个连接对象，用完销毁，频繁创建销毁比较浪费资源吗，所以引入池的概念，可以事先创建一些与数据库连接的对象，用的时候获取，用完放回，不需要要频繁创建。

数据库连接池不需要我们去实现，框架中或者第三方中有现成组件

eg: C3p0 dbcp 阿里巴巴德鲁伊

小提示：大家可以在自己的编译工具中添加lombok哦，方便不少

lombok 自动生成getter setter equals tostring方法消除冗余代码

本文中我装备了方便测试的Test依赖

所以见到下文中的代码中有@Test不要迷茫哦

设置dao层：

package com.ffyc.mybatispro.dao;

import com.ffyc.mybatispro.model.Admin;
import org.apache.ibatis.annotations.Param;

import java.util.List;

/**
 * 定义接口
 */
public interface AdminDao {
    Admin findAdminById(int id);

    Admin login(@Param("acc") String account,@Param("pwd") String password);

    void saveAdmin(Admin admin);//直接使用对象封装

    void updateAdmin(Admin admin);

    void deleteAdmin(int id);

    int findAdminCount(int id);

    //List<Admin> findAdmins(Admin admin);
    List<Admin> findAdmins(@Param("col") String col);
    
}

package com.ffyc.mybatispro.dao;

import com.ffyc.mybatispro.model.Major;

import java.util.List;

public interface MajorDao {
    Major findMajor(int id);

    List<Major> findMajors();
    Major findMajor1( int id);
}

package com.ffyc.mybatispro.dao;

import com.ffyc.mybatispro.model.Student;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;

import java.util.List;

public interface StudentDao {
    Student findStudent(int id);
    List<Student> findStudents();
    Student findStudent1(int id);


    @Insert("insert into student(name,gender,phone) value(#{name},#{gender},#{phone})")
    void  saveStudent(Student student);
    @Delete("delete from student where id = #{id}")
    void deleteStudent(int id);



    List<Student> findStu(Student student);

    void updateStu(Student student);

    void deleteStu1(Integer[] ids);
    void deleteStu2(List<Integer> ids);

    List<Student> findStu1(String[] columns);

    List<Student> findStu2(Student student);

}

那么首先要进行导入依赖，而且同时要配置一个mybatis.xml文件，在resource文件中创建mapper文件，每当有一个实体类，就有一个相应的mapper文件

导入依赖：

<!--导入依赖-->
    <dependencies>
<!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
<!--mybits-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
<!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

mybatis.xml:

里面有全局设置标签（可以打印日志信息，驼峰自动映射，二级缓存开启等），定义类型别名，配置数据库连接信息，数据库连接池（pool），sql映射文件

<?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>
<!--mybatis核心配置文件-->

<!--导入属性文件-->
    <properties   resource="config.properties"></properties>

<!--全局设置-->
    <settings>
        <!--配置日志组件 打印输入日志信息-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <setting name="cacheEnabled" value="true"/>
    </settings>

    <!--定义类型别名-->
    <typeAliases>
    <!--<typeAlias type="com.ffyc.mybatispro.model.Admin" alias="Admin"></typeAlias>-->
        <package  name="com.ffyc.mybatispro.model" />
    </typeAliases>
    <!--配置数据库连接信息-->
    <environments default="development">
        <environment id="development">
    <!--配置事务管理器-->
            <transactionManager type="JDBC"/>
    <!--数据库连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="${driverClassName}" />
                <property name="url" value="${url}" />
                <property name="username" value="${uname}" />
                <property name="password" value="${upassword}"/>
            </dataSource>
        </environment>
    </environments>
    <!--配置注册sql映射文件-->
    <mappers>
        <mapper resource="mappers/AdminMapper.xml"></mapper>
        <mapper resource="mappers/StudentMapper.xml"></mapper>
        <mapper resource="mappers/MajorMapper.xml"></mapper>
    </mappers>
</configuration>

resource里有mapper

实体类有Admin，Major，Student，

package com.ffyc.mybatispro.model;

public class Admin {
    private int id;
    private  String account;
    private  String password;
    private  String gender;
    private  String phone;


    public  Admin(){
        System.out.println("Admin无参构造方法");
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Admin{" +
                "id=" + id +
                ", account='" + account + '\'' +
                ", password='" + password + '\'' +
                ", gender='" + gender + '\'' +
                ", phone='" + phone + '\'' +
                '}';
    }
}





package com.ffyc.mybatispro.model;

import java.io.Serializable;
import java.util.List;

public class Major implements Serializable {
    private  int id;
    private  String name;
    private List<Student> studentList;

    public List<Student> getStudentList() {
        return studentList;
    }

    public void setStudentList(List<Student> studentList) {
        this.studentList = studentList;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Major{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", studentList=" + studentList +
                '}';
    }
}





package com.ffyc.mybatispro.model;

import java.io.Serializable;

public class Student  implements Serializable {
    private int id;
    private String name;
    private String gender;
    private String phone;

    private  Major major;
    private  Admin admin;

    public Major getMajor() {
        return major;
    }

    public void setMajor(Major major) {
        this.major = major;
    }

    public Admin getAdmin() {
        return admin;
    }

    public void setAdmin(Admin admin) {
        this.admin = admin;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", phone='" + phone + '\'' +
                ", major=" + major +
                ", admin=" + admin +
                '}';
    }


   /*    public static void main(String[] args) {
        Student student = new Student();
        Major major = new Major();
        student.setId(1);
        student.setName("eric");
        student.setGender("男");
        student.setPhone("1860000");
        student.setAdminid(1);
        major.setId(1);
        major.setName("数学");

        student.setMajor(major);
    }*/
}

AdminMapper：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace 的值是接口的地址，必须是全类名  将xml文件与接口进行绑定-->
<mapper namespace="com.ffyc.mybatispro.dao.AdminDao">


    <!-- #{}  用来获取参数，以预编译的方式，更加安全
         ${}  也是用来获取参数，但是属于字符串拼接  如果要传具体的值，还需要自己＋''
         ${}   一般用来向sql中动态传入列名，   ${clonum}

       -->
    <insert id="saveAdmin" parameterType="Admin" useGeneratedKeys="true" keyProperty="id" keyColumn="id">

        insert into admin(account,password,gender) value(#{account},#{password},#{gender})
    </insert>

    <update id="updateAdmin" parameterType="Admin">
        update admin
        set account = #{account}, password = #{password}, gender = #{gender} where id = #{id}
    </update>
    <delete id="deleteAdmin" parameterType="int">
        delete  from admin where id = #{id}
    </delete>

    <!--
     注意事项：
            单表自动封装时，列明和类中属性名字必须一致，不一样时可以起别名
            在命名标准的情况下，开启驼峰命名自动映射
            类中必须要有无参的构造方法
    -->

    <!-- 标签与接口的方法对应id=“接口中的方法” -->

    <select id="findAdminById"  parameterType="int" resultType="Admin">
        select * from admin where id = #{id}
    </select>

    <select id="login" resultType="Admin">
        select * from admin where account = #{acc} and password = #{pwd}
    </select>


    <select id="findAdminCount" resultType="Integer">
        select count(*) from admin where id = #{id}
    </select>

    <resultMap id="adminMap" type="Admin">
    <!--要把名称一一对应-->
        <id property="id" column="id"></id>
        <result property="account" column="account"></result>
        <result property="password" column="password"></result>
        <result property="gender" column="gen"></result>
        <result property="phone" column="phone"></result>
    </resultMap>
    <select id="findAdmins" resultMap="adminMap" parameterType="string">
    <!--select id,account,password,gen as gender from admin order by ${col} -->
        select id,account,password,gen,phone from admin order by ${col}
    </select>


</mapper>

MajorMapper:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace 的值是接口的地址，必须是全类名  将xml文件与接口进行绑定-->
<mapper namespace="com.ffyc.mybatispro.dao.MajorDao">

<cache
        flushInterval="2000"
        size="512"
        eviction="FIFO">
        </cache>

    <resultMap id="MajorDao" type="Major">
        <id property="id" column="id"></id>
        <result property="name" column="name"></result>
        <collection property="studentList" javaType="list" ofType="Student">
            <result property="name" column="sname"></result>
        </collection>
    </resultMap>
    <select id="findMajor" resultMap="MajorDao">
        SELECT
        m.id,m.name,
        s.name sname
        FROM
        major m
        LEFT JOIN student s
        ON s.majorid = m.id
        WHERE m.id = #{id}
    </select>
    <select id="findMajors" resultMap="MajorDao">
        SELECT
        m.id,m.name,
        s.name sname
        FROM
        major m
        LEFT JOIN student s
        ON s.majorid = m.id
    </select>



    <resultMap id="温胜广" type="Major">
        <id property="id" column="id"></id>
        <result property="name" column="name"></result>
        <collection property="studentList" javaType="list" ofType="Student"
                    select="findStudent" column="id"></collection>

    </resultMap>
    <select id="findMajor1"  parameterType="int" resultMap="温胜广">
        select  id,name from major where id = #{id}
    </select>
    <select id="findStudent" parameterType="int" resultType="Student">
        select name from student where majorid = #{id}
    </select>

</mapper>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace 的值是接口的地址，必须是全类名  将xml文件与接口进行绑定-->
<mapper namespace="com.ffyc.mybatispro.dao.StudentDao">



<!--    choose when  otherwise 且当有两个when都符合情况，第一个执行完成后就不会再执行第二个when，-->

<!--    <select id="findStu" parameterType="Student" resultType="Student">-->
<!--        select * from student-->
<!--        <choose>-->
<!--            <when test="name!=null">-->
<!--                name = #{name}-->
<!--            </when>-->
<!--            <when test="gender!=null">-->
<!--                and gender = #{gender}-->
<!--            </when>-->
<!--            <when test="phone!=null">-->
<!--                and phone = #{phone}-->
<!--            </when>-->
<!--        </choose>-->
<!--    </select>-->



    <update id="updateStu" parameterType="Student">
        update student
        <trim prefix="set" suffixOverrides=",">
            <if test="name!=null">
                name = #{name},
            </if>
            <if test="gender!=null">
                gender = #{gender},
            </if>
            <if test="phone!=null">
                phone = #{phone}
            </if>
        </trim>
        where id = #{id}
    </update>

    <delete id="deleteStu1">
        delete from student

        <where>
            <foreach collection="array" item="id" open="id in ("  separator="," close=")">
                ${id}
            </foreach>
        </where>
    </delete>
    <delete id="deleteStu2">
        delete from student

        <where>
            <foreach collection="list" item="id" open="id in ("  separator="," close=")">
                ${id}
            </foreach>
        </where>
    </delete>

    <!--
    <trim prefix="添加的是指定的前缀"  prefixOverrides="添加的是指定的需要覆盖的关键词"
    -->
    <select id="findStu" parameterType="Student" resultType="Student">
        select * from student
        <trim prefix="where" prefixOverrides="and|or">
            <if test="name!=null">
                name = #{name}
            </if>
            <if test="gender!=null">
                 and gender = #{gender}
            </if>
            <if test="phone!=null">
                and phone = #{phone}
            </if>
        </trim>
    </select>
    <select id="findStu1" resultType="com.ffyc.mybatispro.model.Student">
        select
        <foreach collection="array" item="c" separator=",">
            ${c}
        </foreach>
        from student
    </select>
        <!--
        Xml中不能出现一些 xml 中的特殊符号
        报错
        1.可以用实体符号代替
        < &lt;
        > &gt;
        " &quot;
        ’ &apos;
        & &amp;
        2.用<![CDATA[ ]]>，这样里面的内容不会被解析，当作原始数据输出
        -->
    <select id="findStu2" resultType="Student">
        select * from student where id <![CDATA[ <]]> 3
    </select>
</mapper>

接下来创建一个test包，里面进行测试：

package com.ffyc.mybatispro.test;

import com.ffyc.mybatispro.dao.AdminDao;
import com.ffyc.mybatispro.model.Admin;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class test1 {
    public static void main(String[] args) throws IOException {
        //读取mybatis的核心文件
        InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
        //创建SqlSessionFactory，用来创建sqlSession
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //创建Sqlsession对象，负责每一次与数据库会话
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //创建访问接口的代理对象
        AdminDao adminDao = sqlSession.getMapper(AdminDao.class);
        Admin admin =adminDao.findAdminById(1);
        System.out.println(admin);
        //关闭会话
        sqlSession.close();
    }
}

package com.ffyc.mybatispro.test;

import com.ffyc.mybatispro.dao.AdminDao;
import com.ffyc.mybatispro.model.Admin;
import com.ffyc.mybatispro.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;

public class test2 {
    public static void main(String[] args) {
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        AdminDao adminDao = sqlSession.getMapper(AdminDao.class);
        //Admin admin = adminDao.findAdminById(1);
        //Admin admin = adminDao.login("222", "789");

        //save  新增
/*      Admin admin = new Admin();
        admin.setAccount("333");
        admin.setPassword("999");
        admin.setGender("男");
        adminDao.saveAdmin(admin);
        System.out.println("获取到的id是："+admin.getId());*/

        //update 修改
       /* Admin admin1 = new Admin();
        admin1.setId(4);
        admin1.setAccount("999");
        admin1.setPassword("lyp");
        admin1.setGender("男");
        adminDao.updateAdmin(admin1);*/


        //delete  删除
        Admin admin2 = new Admin();
        adminDao.deleteAdmin(3);
        sqlSession.commit();//提交数据库事务  事务是一次与数据库进行交互的过程管理 默认关闭，需要主动开启
        sqlSession.close();
    }
}

package com.ffyc.mybatispro.test;

import com.ffyc.mybatispro.dao.AdminDao;
import com.ffyc.mybatispro.model.Admin;
import com.ffyc.mybatispro.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class test3 {
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    AdminDao adminDao = sqlSession.getMapper(AdminDao.class);
    @Test
    public  void findAdminByid(){
        Admin admin = adminDao.findAdminById(1);
        System.out.println(admin);
    }
    @Test
    public void findAdminCount(){
        int count = adminDao.findAdminCount(2);
        System.out.println(count);
    }

/*    @Test
    public void findAdmins(){
        Admin admin = new Admin();
        List<Admin> list = adminDao.findAdmins(admin);
        System.out.println(list);
    }*/
    @Test
    public void findAdmins(){
        Admin admin = new Admin();
        List<Admin> list = adminDao.findAdmins("account");
        System.out.println(list);
    }
}

package com.ffyc.mybatispro.test;

import com.ffyc.mybatispro.dao.StudentDao;
import com.ffyc.mybatispro.model.Student;
import com.ffyc.mybatispro.util.MyBatisUtil;
import com.sun.xml.internal.ws.api.pipe.ServerTubeAssemblerContext;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class test4 {
    @Test
    public void find1(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        Student student = studentDao.findStudent(1);
        System.out.println(student);
        sqlSession.close();
    }
    @Test
    public void find2(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        List<Student> students = studentDao.findStudents();
        System.out.println(students);
        sqlSession.close();
    }
    @Test
    public void find3(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        Student student = studentDao.findStudent1(3);
        System.out.println(student);
        sqlSession.close();
    }
    @Test
    public void save(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        Student student = new Student();
        student.setName("ppp");
        student.setGender("女");
        student.setPhone("999888");
        studentDao.saveStudent(student);
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void delete(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        studentDao.deleteStudent(5);
        sqlSession.commit();
        sqlSession.close();
    }


}

package com.ffyc.mybatispro.test;

import com.ffyc.mybatispro.dao.MajorDao;
import com.ffyc.mybatispro.model.Major;
import com.ffyc.mybatispro.model.Student;
import com.ffyc.mybatispro.util.MyBatisUtil;
import org.apache.ibatis.scripting.xmltags.SetSqlNode;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class test5 {
    @Test
    public void find1(){
        SqlSession sqlSession = MyBatisUtil .getSqlSession();
        MajorDao majorDao = sqlSession.getMapper(MajorDao.class);
        Major major = majorDao.findMajor(1);
        System.out.println(major);
        sqlSession.close();
    }
    @Test
    public void find2(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        MajorDao majorDao = sqlSession.getMapper(MajorDao.class);
        List<Major> majors = majorDao.findMajors();
        System.out.println(majors);
        for (Major m : majors){
            System.out.println(m.getName());
            for (Student student: m.getStudentList()){
                System.out.println(student.getName());
            }
            System.out.println("------------------------");
        }

        sqlSession.close();
    }
}

package com.ffyc.mybatispro.test;

import com.ffyc.mybatispro.dao.MajorDao;
import com.ffyc.mybatispro.model.Major;
import com.ffyc.mybatispro.model.Student;
import com.ffyc.mybatispro.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class test6 {
    @Test
    public void find1(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        MajorDao majorDao = sqlSession.getMapper(MajorDao.class);
        Major major= majorDao.findMajor1(1);
        System.out.println(major);
        sqlSession.close();
    }

}

package com.ffyc.mybatispro.test;

import com.ffyc.mybatispro.dao.StudentDao;
import com.ffyc.mybatispro.model.Student;
import com.ffyc.mybatispro.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

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

public class testStudent {
    @Test
    public void findStu(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        Student student = new Student();
        student.setGender("男");
        student.setPhone("1317777");
        studentDao.findStu(student);
        sqlSession.close();
    }
    @Test
    public void updateStu(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        Student student = new Student();
        student.setId(1);
        student.setName("周杰伦");
        student.setPhone("99999999");
        studentDao.updateStu(student);
        sqlSession.commit();//与数据库发生数据交互，类似于修改删除  都要提交事务管理器
        sqlSession.close();
    }
    @Test
    public void delStu(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        /*Integer[] ids = {1,2,3};
        studentDao.deleteStu1(ids);*/
        List<Integer> ids = new ArrayList<>();
        ids.add(4);
        ids.add(5);
        studentDao.deleteStu2(ids);
        sqlSession.commit();//与数据库发生数据交互，类似于修改删除  都要提交事务管理器
        sqlSession.close();
    }
    @Test
    public void findStu2(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        String[] cols = {"name","gender"};
        List<Student> studentList = studentDao.findStu1(cols);
        sqlSession.close();
    }

}

Mybatis一级缓存和二级缓存

一级缓存：

是SqlSession级别的默认开启

在同一个sqlsession中查询相同数据第二次会从缓存中直接获取，不用查询数据库

一级缓存中的数据在sqlsession销毁后会消失

Sqlsession.clearCache() 清除一级缓存中的数据

执行新增修改删除操作也会清除一级缓存数据

二级缓存：

SqlSessionFactory级别以namespace作为划分区间默认不开启

搭建：

在settings中开启全局二级缓存设置 value=true

对使用二级缓存的类实现接口 Serializable

在sql映射文件中加<cache>标签配置缓存策略

测试：

在第一个sqlsession关闭时，会将数据写入到二级缓存中

SqlSessionFactory 一个项目中只需要创建一次

Sqlsession 一次与数据库交互的对象管理事务管理缓存最为重要

Mybatis将数据库连接配置提取到xml文件中，还将sql语句提取到xml文件使用注解方式执行sql

将sql与java分离为后面的动态sql做好铺垫（逻辑处理数据缓存）

#{} 预编译值更安全 ${} 列名，动态没有预编译

package com.ffyc.mybatispro.test;

import com.ffyc.mybatispro.dao.MajorDao;
import com.ffyc.mybatispro.dao.StudentDao;
import com.ffyc.mybatispro.model.Major;
import com.ffyc.mybatispro.model.Student;
import com.ffyc.mybatispro.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

public class testMajor {
    @Test
    public void find1(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        MajorDao majorDao= sqlSession.getMapper(MajorDao.class);
        Major major1 = majorDao.findMajor1(1);
        sqlSession.close();//一级缓存数据在sqlsession关闭之后会把数据放到二级缓存中
    }
    @Test
    public void find2(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        MajorDao majorDao= sqlSession.getMapper(MajorDao.class);
        Major major1 = majorDao.findMajor1(1);
        sqlSession.close();
    }
}

package com.ffyc.mybatispro.test;

import com.ffyc.mybatispro.dao.StudentDao;
import com.ffyc.mybatispro.model.Student;
import com.ffyc.mybatispro.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

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

public class testStudent {
    @Test
    public void findStu(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        Student student = new Student();
        student.setGender("男");
        student.setPhone("1317777");
        studentDao.findStu(student);
        sqlSession.close();
    }
    @Test
    public void updateStu(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        Student student = new Student();
        student.setId(1);
        student.setName("周杰伦");
        student.setPhone("99999999");
        studentDao.updateStu(student);
        sqlSession.commit();//与数据库发生数据交互，类似于修改删除  都要提交事务管理器
        sqlSession.close();
    }
    @Test
    public void delStu(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        /*Integer[] ids = {1,2,3};
        studentDao.deleteStu1(ids);*/
        List<Integer> ids = new ArrayList<>();
        ids.add(4);
        ids.add(5);
        studentDao.deleteStu2(ids);
        sqlSession.commit();//与数据库发生数据交互，类似于修改删除  都要提交事务管理器
        sqlSession.close();
    }
    @Test
    public void findStu2(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        String[] cols = {"name","gender"};
        List<Student> studentList = studentDao.findStu1(cols);
        sqlSession.close();
    }

}