mybatis基本知识和基本使用

最新推荐文章于 2024-08-08 14:55:32 发布

zhang_xaio_yu

最新推荐文章于 2024-08-08 14:55:32 发布

阅读量2.9k

点赞数

文章标签： java intellij-idea mysql

本文链接：https://blog.csdn.net/zhang_xaio_yu/article/details/124620376

版权

文章目录

一:MyBatis：

MyBatis是一个半自动的ORM框架，你给sql，我来执行

ORM：（Object Relation Mapping）对象关系映射，将java中的一个对象与数据表中的一行记录一一对应。

ORM框架提供了实体类与数据表的映射关系，通过映射文件的配置，将文件保存到了数据表中，实现了对象的持久化。

MyBatis特点：

支持自定义sql，存储过程
对原有的JDBC进行了封装，几乎消除了所有JDBC代码（打开连接，执行sql等），让开发者专注sql
支持XML和注解配置(@xxxx)的方式自动完成ORM操作，实现结果映射，对象的属性和数据表的对应关系就叫映射

二：MyBatis框架部署：

框架部署：就是将框架引入到我们的项目中

过程：

1：创建Maven项目

java工程
Web工程

2：在项目中添加MyBatis依赖

https://mvnrepository.com/

在pom.xml中添加依赖---- mybatis 与 mysql driver

<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>
 
 
 
 
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.6</version>
</dependency>

说明，在pom.xml 中添加包的说明以后，需要到Maven中刷新一下，将包安装进来

3：创建MyBatis配置文件,配置数据库连接

需要先定义MyBatis配置模板，其他的模板也可以在这里进行配置

选择resources----右健New----Edit File Templates

<?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>
</configuration>

在mybatis-config.xml中添加数据库连接信息

<?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>
<!--  environments配置数据库连接信息  -->
<!--    environments中可以定义多个environments标签（正式测试预发布），每个environments可以定义一套数据库连接配置-->
<!--    default属性，用来执行使用哪个environment 标签，-->
    <environments default="mysql">
        <environment id="mysql">
<!--      transactionManager用于配置数据库管理方法      -->
            <transactionManager type="JDBC"></transactionManager>
<!--            dataSource标签用来配置数据库连接信息-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql"/>
                <property name="url" value="jdbc:mysql://localhost:3306/jdbcpractice?characterEncoding = utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

三：MyBatis框架使用

案例：学生信息的数据库操作

1：创建数据表

CREATE TABLE tb_students(
	sid int PRIMARY key auto_increment,
	stu_num CHAR(5) not null UNIQUE,
	stu_name VARCHAR(20) not null,
	stu_gender CHAR(2) not null,
	stu_age int not null
);

2：创建实体类

导入lombok

然后添加注释

package com.liguoqing.pojo;
 
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
 
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class Student {
    private int stuId;
    private String stuNum;
    private String stuName;
    private String stuGender;
    private  int stuAge;
 
}

3：创建DAO接口，并创建操作方法

package com.liguoqing.dao;
 
import com.liguoqing.pojo.Student;
 
public interface StudentDAO {
    public int insertStudent(Student student);
    public int deleteStudent(Student stuNum);
}

4：创建DAO接口的映射文件

模板：

 
<?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="">
 
</mapper>

在resources目录下，新建mappers文件夹

在mappers中新建“StudentMapper”.xml的文件，这个可以根据上面的模板进行创建，注意这里的StudentMapper名称建议跟DAO联系起来

在映射文件中，对DAO中的方法进行实现

<?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文件相当于DAO接口的实现类,namespace属性要指定实现DAO接口的全限定名(全限定名:包名加类名)-->
<!-- copy reference-->
<mapper namespace="com.liguoqing.dao.StudentDAO">
<!--parameterType 这个参数在DAO中已经指定类型了,在这里可以省略-->
    <insert id="insertStudent" parameterType="com.liguoqing.pojo.Student">
         insert into tb_student(stu_num,stu_name,stu_gender,stu_age)
         values(#{stuNum},#{stuName},#{stuGender},#{stuAge})
    </insert>
    <delete id="deleteStudent">
        delete  from  tb_student where stu_num = #{stuNum}
    </delete>
</mapper>

5：将映射文件添加到主配置文件

<?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>
<!--  environments配置数据库连接信息  -->
<!--    environments中可以定义多个environments标签（正式测试预发布），每个environments可以定义一套数据库连接配置-->
<!--    default属性，用来执行使用哪个environment 标签，-->
    <environments default="mysql">
        <environment id="mysql">
<!--      transactionManager用于配置数据库管理方法      -->
            <transactionManager type="JDBC"></transactionManager>
<!--            dataSource标签用来配置数据库连接信息-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql"/>
                <property name="url" value="jdbc:mysql://localhost:3306/jdbcpractice?characterEncoding = utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
 
    <mappers>
        <mapper resource="mappers/StudentMapper.xml"></mapper>
    </mappers>
 
</configuration>

四：单元测试

ps:（测试类往往是在测试类名后加Test，测试方法往往是在测试方法名前加Test）

1: 添加单元测试依赖 junit

2：创建测试类

在被测试接口类名后面 alt + insert ——> test

package com.liguoqing.dao;
 
import com.liguoqing.pojo.Student;
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 org.junit.Test;
 
import javax.annotation.Resource;
 
import java.io.IOException;
import java.io.InputStream;
 
import static org.junit.Assert.*;
 
public class StudentDAOTest {
 
    @Test
    public void insertStudent() {
 
        try {
            //加载mybatis配置文件
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            //创建builder
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            //会话工厂,连接工厂
            SqlSessionFactory factory = builder.build(is);
            //sqlsession 代表数据库的连接,也代表数据库的连接对象
            //会话(连接)
            SqlSession sqlSession = factory.openSession();
            StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
//            System.out.println(studentDAO);
            int i = studentDAO.insertStudent(new Student(0,"10002","java少年","男",24));
            //需要手动提交
            sqlSession.commit();
            System.out.println(i);
        } catch (IOException e) {
            e.printStackTrace();
        }
 
 
    }
 
    @org.junit.Test
    public void deleteStudent() {
    }
}

五：MyBatis 的CRUD操作

案例：学生信息的增删查改

1：添加操作

略

2：删除操作

根据学号删除一条学生信息

步骤：

在StudentDAO中定义删除方法

package com.liguoqing.dao;
 
import com.liguoqing.pojo.Student;
 
public interface StudentDAO {
    public int insertStudent(Student student);
    public int deleteStudent(String stuNum);
}

在StudentMapper.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">
<!--mapper文件相当于DAO接口的实现类,namespace属性要指定实现DAO接口的全限定名(全限定名:包名加类名)-->
<!-- copy reference-->
<mapper namespace="com.liguoqing.dao.StudentDAO">
<!--parameterType 这个参数在DAO中已经指定类型了,在这里可以省略-->
    <insert id="insertStudent" parameterType="com.liguoqing.pojo.Student">
         insert into tb_students(stu_num,stu_name,stu_gender,stu_age)
         values(#{stuNum},#{stuName},#{stuGender},#{stuAge})
    </insert>
    <delete id="deleteStudent">
        delete  from  tb_students where stu_num = #{stuNum}
    </delete>
</mapper>

测试：在StudentDAO的测试类中添加测试方法

package com.liguoqing.dao;
 
import com.liguoqing.pojo.Student;
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 org.junit.Test;
 
import javax.annotation.Resource;
 
import java.io.IOException;
import java.io.InputStream;
 
import static org.junit.Assert.*;
 
public class StudentDAOTest {
 
    @Test
    public void insertStudent() {
 
        try {
            //加载mybatis配置文件
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            //创建builder
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            //会话工厂,连接工厂
            SqlSessionFactory factory = builder.build(is);
            //sqlsession 代表数据库的连接,也代表数据库的连接对象
            //会话(连接)
            SqlSession sqlSession = factory.openSession();
            StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
//            System.out.println(studentDAO);
            int i = studentDAO.insertStudent(new Student(0,"10002","java少年","男",24));
            //需要手动提交
            sqlSession.commit();
            System.out.println(i);
        } catch (IOException e) {
            e.printStackTrace();
        }
 
 
    }
 
    @Test
    public void testDeleteStudent() {
        try {
 
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            //SqlSessionFactory表示mybatis的会话工厂,工厂模式
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
            //SqlSession 对象是mybatis和数据库之间的连接，也就是会话，创建了连接，可以得到所有的mapper对象(映射关系)
            SqlSession sqlSession = sqlSessionFactory.openSession();
            //通过SqlSession 对象调用getMapper方法获取DAO接口对象
            StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
            //调用被测试方法
            int i = studentDAO.deleteStudent("10001");
            //提交事务
            sqlSession.commit();
            System.out.println(i);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
}

3：修改操作

<update id="updateStudent">
       update tb_students
       set stu_name=#{stuName},
           stu_gender=#{stuGender},
           stu_age=#{stuAge}
       where stu_num = #{stuNum}
   </update>

根据学号，修改其他字段信息

@Test
public void  testUpdateStudent(){
    try {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = builder.build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
        int i = studentDAO.updateStudent(new Student(3,"10002",".net小小少年","男",25));
        sqlSession.commit();
        assertEquals(1,i);//期望,单元测试的期望返回结果
        System.out.println(i);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

4：查询操作-查询所有

package com.liguoqing.dao;
 
import com.liguoqing.pojo.Student;
 
import java.util.List;
 
public interface StudentDAO {
    public int insertStudent(Student student);
    public int deleteStudent(String stuNum);
    public int updateStudent(Student student);
    public List<Student> listStudents();
 
 
}

第一种

       resultType执行查询结果，封装的对象的实体类
        resultSets指定当前操作返回的集合类型（可省略）
        resultType返回的类型
        <select id="listStudents" resultType="com.liguoqing.pojo.Student" resultSets="java.util.List">
            select
                sid as stuId,
                stu_num as stuNum,
                stu_name as stuName,
                stu_gender as stuGender,
                stu_age as stuAge
            from tb_students
        </select>

第二种(推荐)


 
<!--resultMap标签用于定义实体类和数据表的映射关系（ORM）-->
<resultMap id="studentMap" type="com.liguoqing.pojo.Student">
    <id column="sid" property="stuId"/>
    <result column="stu_num" property="stuNum"/>
    <result column="stu_name" property="stuName"/>
    <result column="stu_gender" property="stuGender"/>
    <result column="stu_age" property="stuAge"/>
</resultMap>
 
<!--    resultMap 用于引用一个实体的映射关系，当配置了resultMap以后，resultType就可以省略-->
<select id="listStudents" resultMap="studentMap">
    select sid,
           stu_num,
           stu_name,
           stu_gender,
           stu_age
    from tb_students
</select>

@Test
public void testStudentList() {
    try {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = builder.build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
        List<Student> studentList = studentDAO.listStudents();
        assertNotNull(studentList);
        sqlSession.commit();
        for (Student student : studentList
        ) {
            System.out.println(student);
        }
 
    } catch (IOException e) {
 
    }
 
 
}

5:查询操作-查询一条记录

根据学号查询一个学生信息

在StudentDAO中定义接口方法

package com.liguoqing.dao;
 
import com.liguoqing.pojo.Student;
 
import java.util.List;
 
public interface StudentDAO {
    public int insertStudent(Student student);
    public int deleteStudent(String stuNum);
    public int updateStudent(Student student);
    public List<Student> listStudents();
    public Student queryStudent(String stuNum);
 
 
}

在StudentDAOMappperxml 中配置StudentDAO接口的方法实现–SQL

<?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文件相当于DAO接口的实现类,namespace属性要指定实现DAO接口的全限定名(全限定名:包名加类名)-->
<!-- copy reference-->
<mapper namespace="com.liguoqing.dao.StudentDAO">
    <!--parameterType 这个参数在DAO中已经指定类型了,在这里可以省略-->
    <insert id="insertStudent" parameterType="com.liguoqing.pojo.Student">
        insert into tb_students(stu_num, stu_name, stu_gender, stu_age)
        values (#{stuNum}, #{stuName}, #{stuGender}, #{stuAge})
    </insert>
 
    <delete id="deleteStudent">
        delete
        from tb_students
        where stu_num = #{stuNum}
    </delete>
 
    <update id="updateStudent">
        update tb_students
        set stu_name   = #{stuName},
            stu_gender = #{stuGender},
            stu_age    = #{stuAge}
        where stu_num = #{stuNum}
 
    </update>
 
    <!--    resultType执行查询结果，封装的对象的实体类-->
    <!--    resultSets指定当前操作返回的集合类型（可省略）-->
    <!--    resultType返回的类型-->
    <!--    <select id="listStudents" resultType="com.liguoqing.pojo.Student" resultSets="java.util.List">-->
    <!--        select-->
    <!--            sid as stuId,-->
    <!--            stu_num as stuNum,-->
    <!--            stu_name as stuName,-->
    <!--            stu_gender as stuGender,-->
    <!--            stu_age as stuAge-->
    <!--        from tb_students-->
    <!--    </select>-->
 
<!--resultMap标签用于定义实体类和数据表的映射关系（ORM）-->
    <resultMap id="studentMap" type="com.liguoqing.pojo.Student">
        <id column="sid" property="stuId"/>
        <result column="stu_num" property="stuNum"/>
        <result column="stu_name" property="stuName"/>
        <result column="stu_gender" property="stuGender"/>
        <result column="stu_age" property="stuAge"/>
    </resultMap>
<!--    resultMap 用于引用一个实体的映射关系，当配置了resultMap以后，resultType就可以省略-->
    <select id="listStudents" resultMap="studentMap">
        select sid,
               stu_num,
               stu_name,
               stu_gender,
               stu_age
        from tb_students
    </select>
 
 
    <select id="queryStudent" resultMap="studentMap">
        select sid,
               stu_num,
               stu_name,
               stu_gender,
               stu_age
        from tb_students
        where stu_num = #{stuNum}
    </select>
 
 
 
 
</mapper>

单元测试-- 查询不需要提交事务

@Test
public void testStudent() {
    try {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = builder.build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
        Student student = studentDAO.queryStudent("10002");
         assertNotNull(student);
        //查询不用提交事务
        System.out.println(student);
    } catch (IOException e) {
 
    }
}

6：查询操作-多参数查询

方法的参数数量和mapper.xml中sql语句关系

在MyBatis进行操作：
*** 1：如果操作方法只有一个简单类型或者字符串类型的参数，**
*** 在Mapper配置中可以直接通过#{key}获取，这个key的占位符号可以随便写**

*** 2：如果操作方法有一个对象类型的参数，**
*** 在Mapper配置中可以直接通过#{attrName}获取对象的指定属性值(attrName必须是参数对象的属性)**

*** 3：如果操作方法有一个Map类型的参数，**
*** 在Mapper配置中可以直接通过#{key}获取key的指定value值**

*** 4：如果操作方法有多个参数，该如何处理呢？**
*** 通过MyBatis自带的参数 arg0 arg1 … 来获取相应的参数**
*** 也可以通过在方法的参数中加入@Param(“key”) 给参数添加注解的方式**

分页查询

参数 start ，pagesize

在StudentDAO中定义操作方法，如果方法有多个参数，使用@Param 注解声明参数的别名

package com.liguoqing.dao;
 
import com.liguoqing.pojo.Student;
import org.apache.ibatis.annotations.Param;
import java.util.HashMap;
import java.util.List;
 
public interface StudentDAO {
    /*
    * 在MyBatis进行操作：
    * 1：如果操作方法只有一个简单类型或者字符串类型的参数，
    * 在Mapper配置中可以直接通过#{key}获取，这个key的占位符号可以随便写
    * 2：如果操作方法有一个对象类型的参数，
    * 在Mapper配置中可以直接通过#{attrName}获取对象的指定属性值(attrName必须是参数对象的属性)
    * 3：如果操作方法有一个Map类型的参数，
    * 在Mapper配置中可以直接通过#{key}获取key的指定value值
    * 4：如果操作方法有多个参数，该如何处理呢？
    * 通过MyBatis自带的参数 arg0 arg1 .. 来获取相应的参数
    * 也可以通过@Param("key") 给参数添加注解的方式
     */
    public int insertStudent(Student student);
    public int deleteStudent(String stuNum);
    public int updateStudent(Student student);
    public List<Student> listStudents();
    public Student queryStudent(String stuNum);
//    public List<Student> listStudentsByPage(HashMap<String,Integer> map);
//    public List<Student> listStudentsByPage(int start,int pageSize);
    public List<Student> listStudentsByPage(@Param("start") int start
                                        ,@Param("pageSize") int pageSize);
}

在StudentMapper.xml配置sql时，使用#{}获取到指定的参数

<?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文件相当于DAO接口的实现类,namespace属性要指定实现DAO接口的全限定名(全限定名:包名加类名)-->
<!-- copy reference-->
<mapper namespace="com.liguoqing.dao.StudentDAO">
    <!--parameterType 这个参数在DAO中已经指定类型了,在这里可以省略-->
    <insert id="insertStudent" parameterType="com.liguoqing.pojo.Student">
        insert into tb_students(stu_num, stu_name, stu_gender, stu_age)
        values (#{stuNum}, #{stuName}, #{stuGender}, #{stuAge})
    </insert>
 
    <delete id="deleteStudent">
        delete
        from tb_students
        where stu_num = #{stuNum}
    </delete>
 
    <update id="updateStudent">
        update tb_students
        set stu_name   = #{stuName},
            stu_gender = #{stuGender},
            stu_age    = #{stuAge}
        where stu_num = #{stuNum}
 
    </update>
 
    <!--    resultType执行查询结果，封装的对象的实体类-->
    <!--    resultSets指定当前操作返回的集合类型（可省略）-->
    <!--    resultType返回的类型-->
    <!--    <select id="listStudents" resultType="com.liguoqing.pojo.Student" resultSets="java.util.List">-->
    <!--        select-->
    <!--            sid as stuId,-->
    <!--            stu_num as stuNum,-->
    <!--            stu_name as stuName,-->
    <!--            stu_gender as stuGender,-->
    <!--            stu_age as stuAge-->
    <!--        from tb_students-->
    <!--    </select>-->
 
    <!--resultMap标签用于定义实体类和数据表的映射关系（ORM）-->
    <resultMap id="studentMap" type="com.liguoqing.pojo.Student">
        <id column="sid" property="stuId"/>
        <result column="stu_num" property="stuNum"/>
        <result column="stu_name" property="stuName"/>
        <result column="stu_gender" property="stuGender"/>
        <result column="stu_age" property="stuAge"/>
    </resultMap>
    <!--    resultMap 用于引用一个实体的映射关系，当配置了resultMap以后，resultType就可以省略-->
    <select id="listStudents" resultMap="studentMap">
        select sid,
               stu_num,
               stu_name,
               stu_gender,
               stu_age
        from tb_students
    </select>
 
 
    <select id="queryStudent" resultMap="studentMap">
        select sid,
               stu_num,
               stu_name,
               stu_gender,
               stu_age
        from tb_students
        where stu_num = #{stuNum}
    </select>
 
<!--    <select id="listStudentsByPage" resultMap="studentMap">-->
<!--        select sid,-->
<!--               stu_num,-->
<!--               stu_name,-->
<!--               stu_gender,-->
<!--               stu_age-->
<!--        from tb_students limit #{start}, #{pageSize}-->
<!--    </select>-->
 
        <select id="listStudentsByPage" resultMap="studentMap">
            select sid,
                   stu_num,
                   stu_name,
                   stu_gender,
                   stu_age
            from tb_students
                    limit #{start}, #{pageSize}
            <!-- limit #{arg0}, #{arg1}-->
            <!-- limit #{param1}, #{param2}-->
 
        </select>
 
 
</mapper>

—注意：如果DAO操作方法，没有通过@Param指定参数别名，在SQL中也可以通过MyBatis自带的arg0 ，arg1… 或者 param1,param2…获取参数

单元测试

  @Test
    public void testlistStudentsByPage() {
        try {
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            SqlSessionFactory sqlSessionFactory = builder.build(is);
            SqlSession sqlSession = sqlSessionFactory.openSession();
            StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
 
//            HashMap<String,Integer> map = new HashMap<String,Integer>();
//            map.put("start",0);
//            map.put("pageSize",2);
//            List<Student> studentList = studentDAO.listStudentsByPage(map);
 
            List<Student> studentList = studentDAO.listStudentsByPage(0,2);
 
            assertNotNull(studentList);
            sqlSession.commit();
            for (Student student : studentList
            ) {
                System.out.println(student);
            }
        } catch (IOException e) {
 
        }
    }

7：查询操作-查询总记录数

StudentDAO

package com.liguoqing.dao;
 
import com.liguoqing.pojo.Student;
import org.apache.ibatis.annotations.Param;
 
import java.util.HashMap;
import java.util.List;
 
public interface StudentDAO {
    /*
    * 在MyBatis进行操作：
    * 1：如果操作方法只有一个简单类型或者字符串类型的参数，
    * 在Mapper配置中可以直接通过#{key}获取，这个key的占位符号可以随便写
    * 2：如果操作方法有一个对象类型的参数，
    * 在Mapper配置中可以直接通过#{attrName}获取对象的指定属性值(attrName必须是参数对象的属性)
    * 3：如果操作方法有一个Map类型的参数，
    * 在Mapper配置中可以直接通过#{key}获取key的指定value值
    * 4：如果操作方法有多个参数，该如何处理呢？
    * 通过MyBatis自带的参数 arg0 arg1 .. 来获取相应的参数
    * 也可以通过@Param("key") 给参数添加注解的方式
     */
    public int insertStudent(Student student);
    public int deleteStudent(String stuNum);
    public int updateStudent(Student student);
    public List<Student> listStudents();
    public Student queryStudent(String stuNum);
//    public List<Student> listStudentsByPage(HashMap<String,Integer> map);
//    public List<Student> listStudentsByPage(int start,int pageSize);
    public List<Student> listStudentsByPage(@Param("start") int start
                                        ,@Param("pageSize") int pageSize);
 
    public int getCount();
 
}

在StudentMapper.xml配置sql时，使用 resultType 指定当前操作的返回类型为int

<select id="getCount" resultType="int">
    select count(1) from tb_students
</select>

单元测试

@Test
public void testGetStudentCount(){
    try{
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = builder.build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
        int i = studentDAO.getCount();
        System.out.println(i);
    }catch (IOException e){
 
    }
 
}

8：添加操作回填生成的主键

在StudentMapper.xml

在insert标签中 useGeneratedKeys 设置添加操作是否需要回填生成的主键 keyProperty 设置回填的位置

  <!--parameterType 这个参数在DAO中已经指定类型了,在这里可以省略-->
<!--    useGeneratedKeys 设置添加操作是否需要回填生成的主键-->
<!--    keyProperty 设置回填的位置-->
    <insert id="insertStudent" parameterType="com.liguoqing.pojo.Student" useGeneratedKeys="true" keyProperty="stuId">
        insert into tb_students(stu_num, stu_name, stu_gender, stu_age)
        values (#{stuNum}, #{stuName}, #{stuGender}, #{stuAge})
    </insert>

六：MyBatis工具类封装

MyBatisUtil

package com.liguoqing.utils;
 
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;
 
public class MyBatisUtil {
 
    private static SqlSessionFactory factory;//单例的
    private static final ThreadLocal<SqlSession> local = new ThreadLocal<SqlSession>(); //线程锁，各个线程之间不影响，例如开启关闭数据库连接之类的
 
    static {
        try {
            //加载myBatis配置文件,创建会话工厂
            factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    //得到sqlSession对象
    public static SqlSession getSqlSession() throws IOException {
        SqlSession sqlSession = local.get();
        if (sqlSession == null){
            sqlSession = factory.openSession();
            local.set(sqlSession);
        }
        return sqlSession;
    }
 
    public static <T extends Object>T getMapper(Class<T> C) throws IOException {
        SqlSession sqlSession = getSqlSession();
        T dao = sqlSession.getMapper(C);
        return dao;
    }
 
    public static SqlSessionFactory getFactory() throws IOException {
        if (factory == null){
            factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        }
        return factory;
    }
 
 
}

增删改，需要commit

七：事务管理

sqlSession对象：

getMapper(DAO.class) 获取Mapper（DAO接口的实例）
事务管理

1：手动提交事务

sqlSession .commit() 提交事务
sqlSession.rollback() 事务回滚

 @Test
    public void insertStudent() {
 
        try {
//            //加载mybatis配置文件
//            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
//            //创建builder
//            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//            //会话工厂,连接工厂
//            SqlSessionFactory factory = builder.build(is);
//            //sqlsession 代表数据库的连接,也代表数据库的连接对象
//            //会话(连接)
//            SqlSession sqlSession = factory.openSession();
//            StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
//            System.out.println(studentDAO);
 
             SqlSession sqlSession = MyBatisUtil.getSqlSession();
             //1:当我们获取sqlSession对象时,就默认开启了事务
            try{
                StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
                Student student = new Student(0, "10005", "java少年", "男", 24);
                int i = studentDAO.insertStudent(student);
                //2：操作完成并成功以后，需要手动提交
                sqlSession.commit();
                System.out.println(student);
                System.out.println(i);
            }catch (Exception e){
                //3:当操作出现异常，调用rollback进行回滚
                sqlSession.rollback();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
 
 
    }

2：自动提交事务

sqlSession = factory.openSession(true);//这里的参数，如果不填，默认是false，也就是需要手动进行提交，如果填了true会自动提交事务

MyBatisUtil优化

package com.liguoqing.utils;
 
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;
 
public class MyBatisUtil {
 
    private static SqlSessionFactory factory;//单例的
    private static final ThreadLocal<SqlSession> local = new ThreadLocal<SqlSession>(); //线程锁，各个线程之间不影响，例如开启关闭数据库连接之类的
 
    static {
        try {
            //加载myBatis配置文件,创建会话工厂
            factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    //得到sqlSession对象
    public static SqlSession getSqlSession(boolean isAutoCommit) throws IOException {
        SqlSession sqlSession = local.get();
        if (sqlSession == null){
            sqlSession = factory.openSession(isAutoCommit);//这里的参数，如果不填，默认是false，也就是需要手动进行提交，如果填了true会自动提交事务
            local.set(sqlSession);
        }
        return sqlSession;
    }
  // <T extends Object>T  表示字符T是一个类型      (Class<T> t)参数的类型Class 类型的泛型
    public static <T extends Object>T getMapper(Class<T> C) throws IOException {
        SqlSession sqlSession = getSqlSession(true);//自动提交
        T dao = sqlSession.getMapper(C);
        return dao;
    }
 
    public static SqlSessionFactory getFactory() throws IOException {
        if (factory == null){
            factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        }
        return factory;
    }
 
 
}

测试操作：

    @Test
    public void testDeleteStudent() {
        try {
 
//            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
//            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
//            //SqlSessionFactory表示mybatis的会话工厂,工厂模式
//            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
//            //SqlSession 对象是mybatis和数据库之间的连接，也就是会话，创建了连接，可以得到所有的mapper对象(映射关系)
//            SqlSession sqlSession = sqlSessionFactory.openSession();
//            //通过SqlSession 对象调用getMapper方法获取DAO接口对象
//            StudentDAO studentDAO = sqlSession.getMapper(StudentDAO.class);
//            //调用被测试方法
//            int i = studentDAO.deleteStudent("10001");
//            //提交事务
//            sqlSession.commit();
//            System.out.println(i);
            StudentDAO studentDAO = MyBatisUtil.getMapper(StudentDAO.class);
            int i = studentDAO.deleteStudent("10001");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

当有多个操作一般都使用手动提交

MyBatisUtil 事务管理优化：

package com.liguoqing.utils;
 
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;
 
public class MyBatisUtil {
 
    private static SqlSessionFactory factory;//单例的
    private static final ThreadLocal<SqlSession> local = new ThreadLocal<SqlSession>(); //线程锁，各个线程之间不影响，例如开启关闭数据库连接之类的
 
    static {
        try {
            //加载myBatis配置文件,创建会话工厂
            factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
 
    //得到sqlSession对象
    private static SqlSession getSqlSession(boolean isAutoCommit) throws IOException {
        SqlSession sqlSession = local.get();
        if (sqlSession == null){
            sqlSession = factory.openSession(isAutoCommit);//这里的参数，如果不填，默认是false，也就是需要手动进行提交，如果填了true会自动提交事务
            local.set(sqlSession);
        }
        return sqlSession;
    }
 
    //手动事务管理
    public static SqlSession getSqlSession() throws IOException {
        return getSqlSession(false);
    }
 
    //自动事务管理
    public static <T extends Object>T getMapper(Class<T> C) throws IOException {
        SqlSession sqlSession = getSqlSession(true);
        T dao = sqlSession.getMapper(C);
        return dao;
    }
 
    public static SqlSessionFactory getFactory() throws IOException {
        if (factory == null){
            factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        }
        return factory;
    }
 
 
}

八：MyBatis主配置文件

mybatis-config.xml 是MyBatis框架的主配置文件，主要用于配置MyBatis数据源以及工作属性信息

注意：

标签使用时需要注意顺序
空标签会导致报错

1：properties标签

可以定义键值对
可以引用属性文件

在resource 文件夹下创建 jdbc.properties 文件，配置兼职对如下：

mysql_driver=com.mysql.jdbc.Driver
mysql_url=jdbc:mysql://localhost:3306/jdbcpractice?characterEncoding = utf-8
mysql_username=root
mysql_password=123456

在mybatis-config.xml中通过properties 标签引用 jdbc.properties 文件，引入后在配置environment时，可以直接使用jdbc.properties 的key获取value

2：settings标签

<!--    设置mybatis的属性-->
    <settings>
<!--        启动二级缓存-->
        <setting name="cacheEnable" value="true"/>
<!--        启用延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
    </settings>

3：typeAliases标签

<!--    typeAliases用于给实体类取别名，在映射文件中可以直接使用别名来替代实体类的全限定名-->
    <typeAliases>
        <typeAlias type="com.liguoqing.pojo.Student" alias="Student"></typeAlias>
    </typeAliases>

4：plugins标签

<!--    plugins主要用于配置MyBatis插件，例如分页插件-->
    <plugins>
        <plugin interceptor=""></plugin>
    </plugins>

5：environment

<!--  environments配置数据库连接信息  -->
<!--    environments中可以定义多个environments标签（正式测试预发布），每个environments可以定义一套数据库连接配置-->
<!--    default属性，用来执行使用哪个environment 标签，-->
    <environments default="mysql">
        <environment id="mysql">
<!--      transactionManager用于配置数据库管理方法     type="JDBC" 可以进行事务的提交和回滚操作，type="MANAGED" 事务的提交和回滚由容器进行控制 -->
            <transactionManager type="JDBC"></transactionManager>
<!--            dataSource标签用来配置数据库连接信息 POOLED|UNPOOLED 是否使用连接池-->
            <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>
    </environments>

6：mappers标签

<!--    mappers用于载入映射文件，载入DAO类-->
    <mappers>
        <mapper resource="mappers/StudentMapper.xml"></mapper>
    </mappers>

九：映射文件

1：MyBatis初始化，可以跳进源码看一下

用到了动态代理

2：Mappers根标签

mapper文件相当与DAO接口的实现类，namespace属性要执行实现DAO的全限定名（Copy Reference）

3：insert标签

public int insertStudent(Student student);

声明添加操作（sql: insert…）

常用属性：

id属性，绑定对应DAO中的方法
parameterType属性，用以指定接口中对应方法的参数类型（可省略）
useGeneratedKeys属性，用以设置添加操作是否需要回填生成的主键
keyProperty属性，指定回填的id设置到参数对应中的哪个字段中
timeout属性，设置超时时间，如果不设置会一直等待，如果设置了值并到时如果还没有执行，那么会报错

主键回填两种方式：

方式一：

<insert id="insertStudent" parameterType="com.liguoqing.pojo.Student" useGeneratedKeys="true" keyProperty="stuId">
    insert into tb_students(stu_num, stu_name, stu_gender, stu_age)
    values (#{stuNum}, #{stuName}, #{stuGender}, #{stuAge})
</insert>

方式二：

<insert id="insertStudent">
    <selectKey keyProperty="stuId" resultType="java.lang.Integer">
        select  last_insert_id()
    </selectKey>
    insert into tb_students(stu_num, stu_name, stu_gender, stu_age)
    values (#{stuNum}, #{stuName}, #{stuGender}, #{stuAge})
</insert>

4：deleted标签

public int deleteStudent(String stuNum);

<delete id="deleteStudent">
    delete
    from tb_students
    where stu_num = #{stuNum}
</delete>

5：update标签

public int updateStudent(Student student);

<update id="updateStudent">
    update tb_students
    set stu_name=#{stuName},
        stu_gender=#{stuGender},
        stu_age=#{stuAge}
    where stu_num = #{stuNum}
</update>

6：select标签

public List<Student> listStudents();

select两种查询方式

查询要添加一个结果类型的标签 resultMap resultType

方式一:resultMap(推荐)

<resultMap id="studentMap" type="com.qfdue.pojo.Student">
    <id column="sid" property="stuId"/>
    <result column="stu_num" property="stuNum"/>
    <result column="stu_name" property="stuName"/>
    <result column="stu_gender" property="stuGender"/>
    <result column="stu_age" property="stuAge"/>
</resultMap>
<!--    resultMap 用于引用一个实体的映射关系，当配置了resultMap以后，resultType就可以省略-->
<select id="listStudents" resultMap="studentMap">
    select sid,
           stu_num,
           stu_name,
           stu_gender,
           stu_age
    from tb_students
</select>


<select id="queryStudent" resultMap="studentMap">
    select sid,
           stu_num,
           stu_name,
           stu_gender,
           stu_age
    from tb_students
    where stu_num = #{stuNum}
</select>

方式二:resultType

<select id="listStudents" resultType="com.qfdue.pojo.Student">
    select sid as stuId, stu_num as stuNum, stu_name stuName, stu_gender stuGender, stu_age stuAge
    from tb_students
</select>

声明查询操作

id属性，指定绑定方法的方法名
resultType属性，期望从这条语句中返回结果的类全限定名或别名。注意，如果返回的是集合，那应该设置为集合包含的类型，而不是集合本身的类型。 resultType 和 resultMap 之间只能同时使用一个。
resultMap属性，对外部 resultMap 的命名引用。结果映射是 MyBatis 最强大的特性，如果你对其理解透彻，许多复杂的映射问题都能迎刃而解。 resultType 和 resultMap 之间只能同时使用一个。
parameterType属性，将会传入这条语句的参数的类全限定名或别名。这个属性是可选的，因为 MyBatis 可以通过类型处理器（TypeHandler）推断出具体传入语句的参数，默认值为未设置（unset）。
useCache属性，指定查询操作是否使用缓存
timeout属性，设置超时时间
… 其他的属性可以查看MyBatis文档

7：resultMap标签

<!--resultMap标签用于定义实体类和数据表的映射关系（ORM）-->
<resultMap id="studentMap"  type="Student">
    <id column="sid" property="stuId"/>
    <result column="stu_num" property="stuNum"/>
    <result column="stu_name" property="stuName"/>
    <result column="stu_gender" property="stuGender"/>
    <result column="stu_age" property="stuAge"/>
</resultMap>

8：cache标签

设置当前dao进行数据库操作时的缓存属性设置

<cache type="" size="" readOnly="false"></cache>

9：sql 和 include

1.未使用sql片段

<select id="listStudents" resultMap="studentMap">
    select sid,
           stu_num,
           stu_name,
           stu_gender,
           stu_age
    from tb_students
</select>

2.使用sql片段

<sql id="sqlpianduan">sid,
           stu_num,
           stu_name,
           stu_gender,
           stu_age</sql>
 
<!--    resultMap 用于引用一个实体的映射关系，当配置了resultMap以后，resultType就可以省略-->
<select id="listStudents" resultMap="studentMap">
    select <include refid="sqlpianduan"/>
    from tb_students
</select>

十：分页插件

分页插件是一个独立于MyBatis之外的第三方插件；

1：添加分压插件的依赖 —— PageHelper

<!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper -->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.2.0</version>
</dependency>

2：配置插件

在MyBatis的主配置文件中mybatis-config.xml 中通过 plugins标签进行配置，注意标签的位置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RBkxOXQX-1651847136734)(https://note.youdao.com/yws/public/resource/7e6936ecee33a2e46f43f44eb1a178c8/xmlnote/BE5DF1C76CB948A39AA6FB1734466745/13082)]

<!--    plugins主要用于配置MyBatis插件，例如分页插件-->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
    </plugins>

3：分页实例

对学生信息进行分页查询

@Test
public void testGetStudentByPage() throws IOException {
    StudentDAO studentDAO = MyBatisUtil.getMapper(StudentDAO.class);//sqlSession
    PageHelper.startPage(1,4);//分页，从第1页开始，往后的4条数据
    //一定要在查询数据之前startPage, 相当设置一个拦截器
    List<Student> studentList = studentDAO.listStudents();
    //查全量就可以，分页组件会自动将数据进行分页
    PageInfo<Student> pageInfo = new PageInfo<Student>(studentList);
    //返回的时候只需要将pageInfo 返回就可以，因为pageInfo中就包含了分页以及数据的所有信息
}

带条件的分页

package com.liguoqing.dao;
 
import com.liguoqing.pojo.Student;
import org.apache.ibatis.annotations.Param;
 
import java.util.HashMap;
import java.util.List;
 
public interface StudentDAO {
 
    public List<Student> listStudentsByGender(String gender);
 
}
————————————————————————————————————————————————————————————————————————————————
<select id="listStudentsByGender" resultMap="studentMap">
    select <include refid="sqlpianduan"/>
        from tb_students where stu_gender = #{stuGender}
</select>
—————————————————————————————————————————————————————————————————————————————————
   @Test
    public void testGetStudentByPageGender() throws IOException {
        StudentDAO studentDAO = MyBatisUtil.getMapper(StudentDAO.class);
        PageHelper.startPage(1,4);
        List<Student> girls = studentDAO.listStudentsByGender("女");
        PageInfo<Student> pageInfo = new PageInfo<Student>(girls);
        //pageInfo中就包含了分页以及数据信息
        for(Student s : pageInfo.getList()){
            System.out.println(s);
        }
    }

十一：关联映射

1：实体关系

实体——数据实体，实体关系指的就是数据和数据之间的关系

例如：用户和角色，房屋和漏洞，订单和商品

实体关系分为以下四种：

1.1：一对一关联：

实例：人和身份证、学生和学生证、用户基本信息和详情

数据表关系：

主键关联（用户表主键和详情表主键相同时，表示是匹配的数据）

#用户信息表
create table users(
    user_id int primary key auto_increment,
    user_name varchar(20) not null unique,
    user_pwd varchar(20) not null,
    user_realname varchar(20) not null,
    user_img varchar(100) not null
);

唯一外键关联

 
#用户详情表
create table details(
    detail_id int primary key auto_increment,
    user_addr varchar(50) not null,
    user_tel char(11) not null,
    user_desc varchar(200),
    uid int not null unique  
    #containt FK_USER foregic key (uid) references users(user_id)#这个设置是物理关联
    
    #并没有设置外键,外键的功能通过业务逻辑来实现
);

1.2：一对多、多对一关联：

实例：

一对多：班级和学生、类别和商品
多对一：学生和班级、商品和类别

数据表关系：

在多的一端添加外键和一的一端进行关联

1.3：多对多关联：

实例：用户和角色、角色和权限、房屋和业主、学生和社团、订单和商品

数据表关系：

建立第三张关系表添加两个外键，分别与两张表的主键进行关联

用户(user_id)——用户角色表(uid,rid) —— 角色(role_id)

2：创建项目，部署MyBatis框架

创建web项目（Maven）

两种方式导入依赖

1.在idea的projectStucture–>modules导入tmocat依赖

2.在pom文件中添加和tomcat有关的web依赖

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aODTALnv-1651847136739)(https://note.youdao.com/yws/public/resource/7e6936ecee33a2e46f43f44eb1a178c8/xmlnote/DF280629F6994A93B5AEA5FE797EAE69/13206)]

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
 
</web-app>

添加依赖

<dependencies>
 
    <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
        <scope>provided</scope>
    </dependency>
 
    <!-- https://mvnrepository.com/artifact/javax.servlet/jsp-api -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.0</version>
        <scope>provided</scope>
    </dependency>
 
 
</dependencies>

部署MyBatis框架

添加依赖

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.6</version>
</dependency>
 
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>

配置文件

帮助类

package com.guoqing.utils;
 
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;
 
public class MyBatisUtil {
 
    private static SqlSessionFactory factory;//单例的
    private static final ThreadLocal<SqlSession> local = new ThreadLocal<SqlSession>(); //线程锁，各个线程之间不影响，例如开启关闭数据库连接之类的
 
    static {
        try {
            //加载myBatis配置文件,创建会话工厂
            factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
 
    //得到sqlSession对象
    private static SqlSession getSqlSession(boolean isAutoCommit) throws IOException {
        SqlSession sqlSession = local.get();
        if (sqlSession == null){
            sqlSession = factory.openSession(isAutoCommit);//这里的参数，如果不填，默认是false，也就是需要手动进行提交，如果填了true会自动提交事务
            local.set(sqlSession);
        }
        return sqlSession;
    }
 
    //手动事务管理
    public static SqlSession getSqlSession() throws IOException {
        return getSqlSession(false);
    }
 
    //自动事务管理
    public static <T extends Object>T getMapper(Class<T> C) throws IOException {
        SqlSession sqlSession = getSqlSession(true);
        T dao = sqlSession.getMapper(C);
        return dao;
    }
 
    public static SqlSessionFactory getFactory() throws IOException {
        if (factory == null){
            //加载主配置文件
            factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        }
        return factory;
    }
 
 
}

2.1: 一对一关联

实例：用户和详情

创建数据表

#用户信息表
create table users(
    user_id int primary key auto_increment,
    user_name varchar(20) not null unique,
    user_pwd varchar(20) not null,
    user_realname varchar(20) not null,
    user_img varchar(100) not null
);
 
 
#用户详情表
create table details(
    detail_id int primary key auto_increment,
    user_addr varchar(50) not null,
    user_tel char(11) not null,
    user_desc varchar(200),
    uid int not null unique
);

创建实体类

User

 
<!--这里的@注解是通过lombook包帮我们实现的-->
<!--这里重写ToString 是为了打印-->
@Data  //让user有了get set方法
@NoArgsConstructor// 无参构造器
@AllArgsConstructor// 全参构造器
@ToString  //tostring方法
public class User {
    private int userId;
    private String userName;
    private String userPwd;
    private String userRealName;
    private String userImg;
}

Detail

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Detail {
    private int detailId;
    private String userAddr;
    private String userTel;
    private String userDesc;
    private int userId;
}

添加操作

package com.guoqing.dao;
 
import com.guoqing.pojo.User;
 
public interface UserDao {
    public int insertUser(User user);
}

测试代码：

@Test
public void testInsertUser() throws IOException {
    //用户注册提交了基本信息和详情到Servlet，Servlet接收到注册信息，分装到User和Detail对象中
    User user = new User(0,"zhangsan6","123123","张三","01.jpg",null);
    Detail detail = new Detail(f);
 
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    try{
 
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        int i = userDao.insertUser(user);//添加用户
        System.out.println(i);
 
        detail.setUserId(user.getUserId());
        DetailDao detailDao = sqlSession.getMapper(DetailDao.class);
        int n = detailDao.insertDetail(detail);//添加详情
        System.out.println(n);
 
        sqlSession.commit();//提交事务
 
    }catch (Exception e){
        e.printStackTrace();
        sqlSession.rollback();//回滚事务
    }
 
}

一对一关联查询

在查询用户的同时关联查询出与之对应的详情

实体

(一对一要将Detail 类加入到user类中)

User	Detail

映射文件

(要将detail 属性加入到user的result map标签中)

连接查询 inner join

子查询

测试代码：

@Test
public void testQueryUser() throws IOException {
    UserDao userDao = MyBatisUtil.getMapper(UserDao.class);
    User user = userDao.queryUser("zhangsan3");
    System.out.println(user);
}

2.2: 一对多关联

案例：班级（一）——学生（多）

创建数据表

#创建班级信息表
CREATE TABLE classes(
cid int PRIMARY key auto_increment,
cname VARCHAR(30) not null unique,
cdesc VARCHAR(100)
);
 
#创建学生信息表
CREATE TABLE students(
sid CHAR(5) PRIMARY key,
sname VARCHAR(20) not null,
sage int not null,
scid int not null 
);

创建实体类

Clazz	Student

关联查询

当查询一个班级的时候，要关联查询出这个班级下的所有学生

连接查询

连接查询的映射配置

子查询

注意mapper与主配置文件的关系以及变量重命名之间的配置

子查询的映射配置

2.3:多对一关联

实例：学生(n) ——班级（1）

当查询一个学生的时候，关联查询这个学生所在的班级信息

创建实体类

Student	Clazz

关联查询

连接查询

连接查询的映射配置

子查询

子查询映射配置

单个对象association

2.4：多对多关联

案例：学生(m)——课程(n)

创建数据表

#学生信息表如上
#课程信息表
CREATE TABLE courses(
 course_id int PRIMARY key auto_increment,
 course_name VARCHAR(50) not null
);
 
#选课信息表/成绩表(学号，课程号，成绩)
CREATE TABLE grades(
	sid CHAR(5) not null,
	cid int not null,
	score int not null
);

关联查询

查询学生时，同时查询出学生选择的课程

Student	Course

根据课程编号查询课程时，同时查询选择了这门课程的学生

Student	Course
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S8wm0OKl-1651847139600)(https://note.youdao.com/yws/public/resource/7e6936ecee33a2e46f43f44eb1a178c8/xmlnote/8AA75848E9BC4C0794814E9336033B4D/13514)]

连接查询映射配置

子查询映射配置

十二：动态SQL

快速构建一个项目

交友网；电商等网站都有筛选功能

不同的需求筛选条件不同，需要动态的拼接sql

用户的筛选条件不同，我们完成筛选执行的sql也不一样，我们可以通过穷举来意义完成不同条件的筛选，但是这种实现思路过于繁琐和复杂，MyBatis就提供了动态SQL的配置方式来实现多条件的查询。

12.1 什么是动态SQL

根据搜索条件，动态完成SQL的拼接

12.2动态SQL使用案例

案例：心仪对象搜索

12.2.1 创建数据表

#数据表
CREATE TABLE members(
	member_id int PRIMARY key auto_increment,
	member_nick VARCHAR(20) not null UNIQUE,
	member_gender char(2) not null,
	member_age int not null,
	member_city varchar(30) not null
);

12.2.2 创建实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Member {
    private int memberId;
    private String memberNick;
    private String memberGender;
    private int memberAge;
    private String memberCity;
}

12.2.3 创建DAO接口

在DAO接口中定义一个多条件查询的方法

public interface MemberDAO {
    //在多条件查询中，如果查询条件不确定，可以直接使用HashMap作为参数
    public List<Member> searchMember(HashMap<String,Object> params);
}

——————————MemberMapper.xml
<resultMap id="memberMap" type="Member">
    <id column="member_id" property="memberId"/>
    <result column="member_nick" property="memberNick"/>
    <result column="member_gender" property="memberGender"/>
    <result column="member_age" property="memberAge"/>
    <result column="member_city" property="memberCity"/>
</resultMap>
 
<select id="searchMember" resultMap="memberMap">
    select member_id,member_nick,member_gender,member_age,member_city
    from members
    where 1 = 1
    <if test="gender != null"><!--gender 就是参数对象的属性、参数Map的key-->
        and member_gender = #{gender}
    </if>
    <if test="minAge != null"><!--&gt; 大于号  -->
        and member_age &gt;= #{minAge}
    </if>
    <if test="maxAge != null"><!--&lt; 小于号  -->
        and member_age &lt;= #{maxAge}
    </if>
    <if test="city != null">
        and member_city != #{city}
    </if>
</select>
 
 

-----MemberDAOTest
   @Test
    public void TestSearchMember() throws IOException {
        HashMap<String,Object> params = new HashMap<String,Object>();
        params.put("gender","女");
//        params.put("minAge",19);
//        params.put("maxAge",23);
//        params.put("city","武汉");
        //当向Map中存放参数时，key必须与动态Sql中的参数保持一致
        MemberDAO memberDAO = MyBatisUtil.getMapper(MemberDAO.class);
        List<Member> members = memberDAO.searchMember(params);
 
        System.out.println(members);
 
    }

if标签

12.2.4 where标签(就可以去掉where 1=1)

12.2.5 trim标签

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bKskJW8k-1651847136744)(https://note.youdao.com/yws/public/resource/7e6936ecee33a2e46f43f44eb1a178c8/xmlnote/9C3C807BA7D94E2D97B27D5E7CC20192/13579)]

12.2.6 foreach标签 (在in语句后面)

DAO类:

 List<Member> searchMemberByCity(List<String> cities);

测试类：

@Test
public void testSearchMemberByCity() throws IOException {
    List<String> cities = new ArrayList<String>();
    cities.add("武汉");
    cities.add("厦门");
    MemberDAO memberDAO = MyBatisUtil.getMapper(MemberDAO.class);
    List<Member> members = memberDAO.searchMemberByCity(cities);
    for (Member m : members){
        System.out.println(m);
    }
}

十三：模糊查询

案例：根据昵称查询会员信息（模糊匹配 like）

13.1 模糊查询实现

13.1.0使用(@Param(“keyWord”) String keyWord)

13.1.1 DAO

public interface MemberDAO {
 
//根据昵称查询用户信息-- 模糊查询
//模糊查询需要使用 ${} 取值，与SQL进行拼接
//在使用${}时，即使只有一个参数也需要使用@Param注释声明参数的key (非String类型不需要)
    public List<Member> searchMemberByNick(@Param("keyWord") String keyWord);
 
}

13.1.2 映射文件

 
<!--如果参数是String 类型，需要使用parameterType声明参数类型-->
<select id="searchMemberByNick" parameterType="java.lang.String" resultMap="memberMap">
    select member_id,member_nick,member_gender,member_age,member_city
    from members
    where member_nick like '%${keyWord}%'
</select>

13.1.3 测试

    @Test
    public void testSearchMemberByNick() throws IOException {
        MemberDAO memberDAO = MyBatisUtil.getMapper(MemberDAO.class);
        List<Member> members = memberDAO.searchMemberByNick("x");
        for (Member m : members){
            System.out.println(m);
        }
    }

13.2使用(HashMap keyword)

13.2 #{} 和${}的区别

<!--${keyWord} 表示获取参数，先获取参数的值，拼接到SQL语句中，再编译执行SQL语句  可能引起SQL注入问题-->

sql注入:sql参数的值可能会导致原意发生变化

<!--#{keyWord} 表示获取参数，先完成SQL的编译(预编译)，预编译之后再将获取的参数设置到SQL中 可以避免SQL注入问题-->

十四：MyBatis日志配置

MyBatis 做为一个封装好的ORM框架，其运行过程我们没办法跟踪，为了让开发者了解MyBatis执行流程及每个执行步骤所完成的工作，MyBatis框架本身集成了log4j日志框架（这两天有漏洞），对运行的过程进行跟踪记录，我们只需对MyBatis进行相关的日志配置，就可以看到MyBatis运行过程中的日志信息。-

14.1 添加日志框架依赖

<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

14.2 添加日志配置文件

在 resources目录下创建名为 log4j.properties 文件，名称必须如此
在log4j.properties 文件中配置日志输出的方式

#声明日志的输出级别及输出格式
log4j.rootLogger=DEBUG,stdout
# MyBatis logging configuration...
log4j.logger.org.mybatis.example.BlogMapper=TRACE
# Console output ...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
#定义日志的打印格式    %t表示 线程名称    %5p 日志级别 %msg 日志信息  \:%m%n 换行
log4j.appender.stdout.layout.ConversionPattern=[%t] %5p -%msg \:%m%n

14.3 日志信息的级别

在使用日志框架输出日志信息的时候，会根据输出的日志信息的重要程度分为5个级别

级别	说明
DEBUG	调试
INFO	提示
WARN	警告
ERROR	一般
FATAL	致命

十五：配置数据库连接池-整合Druid

MyBatis作为一个ORM框架，在进行数据库操作时是需要和数据库连接的，MyBatis支持基于数据库连接池的连接创建方式。

当我们配置MyBatis数据源时，只要配置了dataSource标签的type属性值为POOLED时，就可以使用MyBatis内置的连接池管理连接。

如果我们想要使用第三方的数据库连接池，则需要进行自定义配置。

15.1 常见的连接池

DBCP
C3P0
Druid 性能比较好，提供了比较便捷的监控系统
Hikari 性能最好

功能	dbcp	druid	c3p0	HikariCP
是否支持PSCache	是	是	是	否
监控	jmx	jmx/log/http	jmx,log	jmx
扩展性	弱	好	弱	弱
sql拦截及解析	无	支持	无	无
代码	简单	中等	复杂	简单
更新时间	2015.8.6	2015.10.10	2015.12.09	2015.12.3
特点	依赖于common-pool	阿里开源，功能全面	历史久远，代码逻辑复杂，且不易维护	优化力度大，功能简单，起源于boneCP
连接池管理	LinkedBlockingDeque	数组		threadlocal+CopyOnWriteArrayList

15.2 添加Druid依赖

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>

15.3 创建Druid连接池工厂

public class DruidDataSourceFactory extends PooledDataSourceFactory {
    // protected DataSource dataSource = new UnpooledDataSource();

    
//    @Override
//    public DataSource getDataSource() {
//        return super.getDataSource();
//    }
    public DruidDataSourceFactory() {
        this.dataSource=new DruidDataSource();
    }
}

15.4 将DruidDataSourceFactory 配置给MyBatis数据源

<environments default="mysql">
        <environment id="mysql">
            <transactionManager type="jdbc"></transactionManager>
            <!--POOLED 使用MyBatis内置的连接池实现   -->
            <!--mybatis 需要一个连接池工厂  这个工厂可以产生数据库连接池 PooledDataSourceFactory -->
            <!--使用了多态-->
            <dataSource type="com.guoqing.utils.DruidDataSourceFactory">
                <property name="driverClass" value="${driver}"/>
                <property name="jdbcUrl" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

十六，MyBatis缓存

MyBatis是基于JDBC的封装，使数据库操作更加便捷MyBatis除了对JDBC操作步骤进行封装之外也对其性能进行了优化

在MyBatis引入了缓存机制，用于提升MyBatis的检索效率
在MyBatis引入延迟加载机制，用于对数据库不必要的访问

16.1 缓存的工作原理

缓存，就是存储数据的内存

16.2 MyBatis缓存

MyBatis缓存分为一级缓存和二级缓存

16.2.1 一级缓存

一级缓存也叫作Sqlsession缓存，为每个sqlsession单独分配的缓存内存，无需手动开启，可直接使用。多个sqlsession的缓存是不共享的。

特性：

1：如果多次查询使用的是同一个Sqlsession对象，则第一次查询以后，数据会存放到缓存，后续的查询则直接访问缓存中存储的数据。

 
    @Test
    public void testQueryMemberById() throws IOException {  
         /*(因为有localTread  在同一个线程中sqlSession 可以共享)
         
         getSqlSession()中的方法
         public static SqlSession getSqlSession(boolean isAutoCommit){
         SqlSession sqlSession = local.get();
         if (sqlSession==null){
              sqlSession = factory.openSession(isAutoCommit);
              local.set(sqlSession);
         }
         return sqlSession;
     }
     sqlSession是在同一个local中的是同一个sqlsession
         */
        SqlSession sqlSession = MyBatisUtil.getSqlSession();       
        MemberDAO memberDAO = sqlSession.getMapper(MemberDAO.class);
        Member member1 = memberDAO.queryMemberById(1);
        System.out.println(member1);
        //sqlSession.clearCache();
  
        
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
 		SqlSession sqlSession2 = MyBatisUtil.getSqlSession();
        MemberDAO memberDAO2 = sqlSession.getMapper(MemberDAO.class);
        Member member2 =memberDAO2.queryMemberById(1);
        System.out.println(member2);
    }

2：在同一个SqlSession对象的情况下,如果第一次查询完成后，对查询出的对象进行修改（此修改会影响到缓存），第二次查询会直接访问缓存，造成第二次查询的结果与数据库不一致。

3：当我们进行再次查询时，想要跳过缓存直接查询数据库，则可以通过sqlsession.clearCache();来清除当前SqlSession的缓存。

@Test
    public void testQueryMemberById() throws IOException {  
         /*(因为有localTread  在同一个线程中sqlSession 可以共享)
         
         getSqlSession()中的方法
         public static SqlSession getSqlSession(boolean isAutoCommit){
         SqlSession sqlSession = local.get();
         if (sqlSession==null){
              sqlSession = factory.openSession(isAutoCommit);
              local.set(sqlSession);
         }
         return sqlSession;
     }
     sqlSession是在同一个local中的是同一个sqlsession    
     但是后面有一个sqlSession.clearCache();方法将sqlSession缓存清空了
         */
        SqlSession sqlSession = MyBatisUtil.getSqlSession();       
        MemberDAO memberDAO = sqlSession.getMapper(MemberDAO.class);
        Member member1 = memberDAO.queryMemberById(1);
        System.out.println(member1);
        sqlSession.clearCache();
        
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
 		SqlSession sqlSession2 = MyBatisUtil.getSqlSession();
        MemberDAO memberDAO2 = sqlSession.getMapper(MemberDAO.class);
        Member member2 =memberDAO2.queryMemberById(1);
        System.out.println(member2);
    }

4：如果第一次查询以后，第二次查询以前，使用当前的sqlsession执行了修改操作，此修改操作会使第一次查询并缓存的数据失效，(查询不会) 因此第二次查询会再次访问数据库。

测试代码：

1.同一个sqlSession的测试

    @Test
    public void testQueryMemberById() throws IOException {  
         /*(因为有localTread  在同一个线程中sqlSession 可以共享)
         
         getSqlSession()中的方法
         public static SqlSession getSqlSession(boolean isAutoCommit){
         SqlSession sqlSession = local.get();
         if (sqlSession==null){
              sqlSession = factory.openSession(isAutoCommit);
              local.set(sqlSession);
         }
         return sqlSession;
     }
     sqlSession是在同一个local中的是同一个sqlsession
         */
        SqlSession sqlSession = MyBatisUtil.getSqlSession();       
        MemberDAO memberDAO = sqlSession.getMapper(MemberDAO.class);
        Member member1 = memberDAO.queryMemberById(1);
        System.out.println(member1);
        //sqlSession.clearCache();
  
        
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
 		SqlSession sqlSession2 = MyBatisUtil.getSqlSession();
        MemberDAO memberDAO2 = sqlSession.getMapper(MemberDAO.class);
        Member member2 =memberDAO2.queryMemberById(1);
        System.out.println(member2);
    }

2.不同sqlSession的情况

@Test
    public void testQueryMemberById() throws IOException {  
         /*(因为有localTread  在同一个线程中sqlSession 可以共享)
         
         getSqlSession()中的方法
         public static SqlSession getSqlSession(boolean isAutoCommit){
         SqlSession sqlSession = local.get();
         if (sqlSession==null){
              sqlSession = factory.openSession(isAutoCommit);
              local.set(sqlSession);
         }
         return sqlSession;
     }
     sqlSession是在同一个local中的是同一个sqlsession    
     但是后面有一个sqlSession.clearCache();方法将sqlSession缓存清空了
         */
        SqlSession sqlSession = MyBatisUtil.getSqlSession();       
        MemberDAO memberDAO = sqlSession.getMapper(MemberDAO.class);
        Member member1 = memberDAO.queryMemberById(1);
        System.out.println(member1);
        sqlSession.clearCache();
        
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
 		SqlSession sqlSession2 = MyBatisUtil.getSqlSession();
        MemberDAO memberDAO2 = sqlSession.getMapper(MemberDAO.class);
        Member member2 =memberDAO2.queryMemberById(1);
        System.out.println(member2);
    }

 
    @Test
    public void testQueryMemberById() throws IOException {
        /*
         static {
         try {
             InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
             factory = new SqlSessionFactoryBuilder().build(is);
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

     public static SqlSessionFactory getFactory(){
         return factory;
     }
     
     MyBatisUtil.getFactory().openSession();该方法创建的sqlSession是不同的
        */
        SqlSession sqlSession = MyBatisUtil.getFactory().openSession();
       
 
        MemberDAO memberDAO = sqlSession.getMapper(MemberDAO.class);
        Member member1 = memberDAO.queryMemberById(1);
        System.out.println(member1);
        
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
        SqlSession sqlSession2 = MyBatisUtil.getFactory().openSession();
        MemberDAO memberDAO2 = sqlSession.getMapper(MemberDAO.class);
        Member member2 =memberDAO2.queryMemberById(1);
        System.out.println(member2);
    }

16.2.2 两次查询与数据库数据不一致问题

16.2.3 二级缓存

二级缓存也称为SqlSessionFactory级缓存。通过同一个factory对象获取的SqlSession 可以共享二级缓存；

在应用服务器中SqlSessionFactory是单例的(Factory只创建了一次在整个项目中)，因此我们二级缓存可以实现全局共享。

特性：

1：二级缓存默认没有开启，需要在mybatis-config.xml中的setting标签中开启

2：二级缓存只能缓存实现了序列化接口的对象

在mybatis-config.xml 开启使用二级缓存

<settings>
    <setting name="cacheEnabled" value="true"/>
</settings>

在需要使用二级缓存的Mapper文件中配置cache标签使用二级缓存

<cache/>  
 
//该标签中有一些属性可以自行进行配置
//例如
淘汰策略属性: eviction = "FIFO"  先进先出
更新频率属性: flushInterval = "6000" 间隔多长时间刷新一次缓存
缓存区的大小属性:size = "223" 多少个对象的引用
只读属性: readOnly = "true" 只能读不能改

被缓存的实体类实现序列化接口

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Member implements Serializable {
    private int memberId;
    private String memberNick;
    private String memberGender;
    private Integer memberAge;
    private String memberCity;
}

测试
1：多个sqlsession对象来自于同一个sqlsessionFactory

@Test
    public void testQueryMemberById() throws IOException {
        SqlSessionFactory factory = MyBatisUtil.getFactory();
        //1：多个sqlsession对象来自于同一个sqlsessionFactory
        SqlSession sqlSession = factory.openSession(true);
        SqlSession sqlSession2 = factory.openSession(true);
 
        MemberDAO memberDAO = sqlSession.getMapper(MemberDAO.class);
        Member member1 = memberDAO.queryMemberById(1);
        System.out.println(member1);
//        sqlSession.clearCache();
        sqlSession.commit(); //2：第一次查询之后，执行sqlSession.commit() 会将当前sqlsession的查询结果缓存到二级缓存
 
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
 
        MemberDAO memberDAO2 = sqlSession2.getMapper(MemberDAO.class);
        Member member2 =memberDAO2.queryMemberById(1);
        System.out.println(member2);
    }

16.3 查询操作的缓存开关和修改是是否刷新缓存

<select id="queryMemberById" resultMap="memberMap" useCache="false">
    select member_id,member_nick,member_gender,member_age,member_city
    from members
    where member_id=#{mid}
</select>

修改

    <update id="updateMemberByNick" flushCache="true">
        update members
        set member_nick=#{memberNick},
            member_gender=#{memberGender},
            member_age=#{memberAge},
            member_city=#{memberCity}
        where member_nick = #{memberNick}
    </update>

十七: 延迟加载

延迟加载——如果在MyBatis中开启了延迟加载执行了子查询（至少查询两次以上），默认只实行第一次查询，当用到子查询的查询结果时，才会出发子查询的执行，如果无需使用子查询结果，则子查询不会执行。

开启延迟加载

fetchType="lazy"

<?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="com.guoqing.dao.ClassDAO">
 
    <resultMap id="classMap" type="Clazz">
        <id column="cid" property="classId"/>
        <result column="cname" property="className"/>
        <result column="cdesc" property="classDesc"/>
        <collection property="stus" select="com.guoqing.dao.StudentDAO.queryStudentsByCid" column="cid" fetchType="lazy"/>
    </resultMap>
 
    <select id="queryClassByCid" resultMap="classMap">
        select cid,cname,cdesc from classes where cid = #{cid}
    </select>
 
</mapper>

测试类

@Test
public void queryClassByCid() throws IOException {
    ClassDAO classDAO = MyBatisUtil.getMapper(ClassDAO.class);
    Clazz clazz = classDAO.queryClassByCid(1);
    System.out.println(clazz.getClassName());
    System.out.println(clazz.getStus());
}

————————————————————————

总结

Map

需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

预编译

1、什么是预编译

1.1、 sql的执行过程

① 词法和语义分析
② 优化sql语句，指定执行计划
③ 执行并返回结果

我们把这种普通语句称作Immediate Statements。

select colume from table where colume=1;
select colume from table where colume=2;

但是很多情况，我们的一条sql语句可能会反复执行，或者每次执行的时候只有个别的值不同，那么这个时候会对上面两条语句生成两个执行计划，一千次查询就需要一千个执行计划，生成执行计划非常耗费时间。

如果每次都需要经过上面的词法语义解析、语句优化、制定执行计划等，则效率就明显不行了，所以引出预编译功能。

1.2. 预编译语句

将这类语句中的值用占位符替代，可以视为将sql语句模板化或者说参数化，一般称这类语句叫Prepared Statements或者Parameterized Statements。

比如下面的语句

insert into category values(null,?,?)

1.3. 预编译

以java为例，预编译会使用preparestatement，会对预编译语句进行语法分析，编译。
那么这个时候会对上面的insert语句按照预编译语句生成一个执行计划，然后根据参数可以进行重用执行计划。

当处理批量SQL语句时，这个时候就可以体现PrepareStatement的优势，由于采用Cache机制，则预先编译的语句，就会放在Cache中，下次执行相同SQL语句时，则可以直接从Cache中取出来,效率要比statement高好几倍

当语句真正开始执行时，传过来的参数只会被看成纯文本，不会重新编译，不会被当做sql指令，所以可以防止注入。

很多时候最优的执行计划不是光靠知道sql语句的模板就能决定了，往往就是需要通过具体值来预估出成本代价。

注意MySQL的老版本（4.1之前）是不支持服务端预编译的，但基于目前业界生产环境普遍情况，基本可以认为MySQL支持服务端预编译。

一次编译、多次运行，省去了解析优化等过程；此外预编译语句能防止sql注入。

varchar和char的区别

1.char定长类型
    char(M)，M代表宽度即可容纳的字符数（如，char(4)，这里面可以存4个字母或者四个汉字 ） 如果存了N（N<=M）个字符，实占 M 个字符，不足M，向后补空格，取出时，去除后面的空格。
    varchar(M) 变长类型varchar(M)，M代表宽度，即可容纳的 字符 数如果存了N（N<=M）个字符，实占 N 个字符
2.     char 的速度比 varchar 快，但比 varchar 浪费空间
3.     char 的 M 的范围（0-255）  varchar 的 M 范围（0-65535）（约2W-6W个字符受字符集影响）
4.     char 和 varchar 的选择原则：
                1.空间利用效率
                        四字成语表：char（4）
                        个人简介，微博 140 字：varchar（140）

                2.速度
                        用户名：char
             根据实际情况具体衡量，兼顾空间和速度。

xml文件的标准样式

static,final,TreadLocal

（一）static

1、static修饰的方法和属性会统一交给类管理，即多个类对象只会对应一个属性或方法，并由JVM分配在堆中的一块不变的区域。

2、static修饰的方法，可以使用"类名.方法名"的方式调用，避免了需要new对象的繁琐和内存资源的消耗。

 

总结

1、用来修饰类成员变量，从而实现所有对象对成员变量的共享。

2、用来修饰成员方法，可以直接“类名.方法名”的方式调用，常用于工具类。

3、静态块用法，将多个类成员统一初始化，即在实际被调用之前就被初始化了，且只需要初始化一次。

4、静态导包用法，将类的方法直接导入到当前类中，从而直接使用“方法名”进行调用，更加方便。

 

（二）final

1、修饰成员变量，说明该变量的值是不可变得。标注该变量只能进行一次赋值操作，且在运行过程中不可改变它的值。

2、修饰方法入参，说明整个方法中，参数的值是不可变的。

注意：当入参为对象时，是可以改变引用对象中成员变量的值。

3、修饰方法，说明该方法不能被覆盖，即不能被继承该类的子类重写。

4、修饰类，说明该类是无法被继承的。

 

（三）ThreadLocal

1、ThreadLocal为每个使用该变量的线程提供独立的变量副本，因此每一个线程都可以独立地改变自己的副本，而不会影响其他线程所对应的副本。

2、解决多线程并发访问同一变量造成脏数据的问题。

 

提供的方法：
pub void set(Object value) 设置当前线程的线程局部变量的值
public Object get() 该方法返回当前线程所对应的线程局部变量的值
public void remove() 将当前线程局部变量的值删除，目的是为了内存的占用

静态代码块

还记得静态代码块的特点吗？随着类的加载而执行，而且只执行一次

静态代码块：执行优先级高于非静态的初始化块，它会在类初始化的时候执行一次，执行完成便销毁，它仅能初始化类变量，即static修饰的数据成员。

mybatis工具类讲解

package com.ara.utils;

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;

/**
 * Mybatis工具类
 * 主要用于获取SqlSession
 */
public class MybatisUtil {

    //私有静态 加载就被执行 让其只存在一份在内存中
    private static SqlSessionFactory sqlSessionFactory;

    //通过静态代码块来实例化SqlSessionFactory
    static {
        try {
            //读取Mybatis的配置文件
            InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
            //实例化SqlSessionFactory 
            //因为SqlSessionFactoryBuilder在创建SqlSessionFactory之后就再也不会使用了，所以我们这里直接使用匿名对象创建SqlSessionFactory
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * 获取SqlSession对象
     * 值得注意的是：获取的SqlSession对象在使用完毕之后应该立即关闭
     *
     * @return 返回SqlSession对象
     */
    public static SqlSession getSqlSession() {
        //通过SqlSessionFactory创建SqlSession供其他程序使用
        return sqlSessionFactory.openSession();
    }
}

studentmapper.xml

        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--类似创建了一个实现类-->
<mapper namespace="com.qfdue.dao.StudentDAO">
    <!--类似这个实现类的方法,但是这些方法的id要和StudentDAO的方法名一致-->
    <insert id="insertStudent" parameterType="com.qfdue.pojo.Student">

全类名复制

resources文件夹

如何快速得到文件的名称

jdk

环境变量

<cache/>  
 
//该标签中有一些属性可以自行进行配置
//例如
淘汰策略属性: eviction = "FIFO"  先进先出
更新频率属性: flushInterval = "6000" 间隔多长时间刷新一次缓存
缓存区的大小属性:size = "223" 多少个对象的引用
只读属性: readOnly = "true" 只能读不能改

         1.空间利用效率
                    四字成语表：char（4）
                    个人简介，微博 140 字：varchar（140）

            2.速度
                    用户名：char
         根据实际情况具体衡量，兼顾空间和速度。




### xml文件的标准样式

[外链图片转存中...(img-jzsUCAlE-1651847136752)]

### static,final,TreadLocal

```java
（一）static

1、static修饰的方法和属性会统一交给类管理，即多个类对象只会对应一个属性或方法，并由JVM分配在堆中的一块不变的区域。

2、static修饰的方法，可以使用"类名.方法名"的方式调用，避免了需要new对象的繁琐和内存资源的消耗。

 

总结

1、用来修饰类成员变量，从而实现所有对象对成员变量的共享。

2、用来修饰成员方法，可以直接“类名.方法名”的方式调用，常用于工具类。

3、静态块用法，将多个类成员统一初始化，即在实际被调用之前就被初始化了，且只需要初始化一次。

4、静态导包用法，将类的方法直接导入到当前类中，从而直接使用“方法名”进行调用，更加方便。

 

（二）final

1、修饰成员变量，说明该变量的值是不可变得。标注该变量只能进行一次赋值操作，且在运行过程中不可改变它的值。

2、修饰方法入参，说明整个方法中，参数的值是不可变的。

注意：当入参为对象时，是可以改变引用对象中成员变量的值。

3、修饰方法，说明该方法不能被覆盖，即不能被继承该类的子类重写。

4、修饰类，说明该类是无法被继承的。

 

（三）ThreadLocal

1、ThreadLocal为每个使用该变量的线程提供独立的变量副本，因此每一个线程都可以独立地改变自己的副本，而不会影响其他线程所对应的副本。

2、解决多线程并发访问同一变量造成脏数据的问题。

 

提供的方法：
pub void set(Object value) 设置当前线程的线程局部变量的值
public Object get() 该方法返回当前线程所对应的线程局部变量的值
public void remove() 将当前线程局部变量的值删除，目的是为了内存的占用

静态代码块

还记得静态代码块的特点吗？随着类的加载而执行，而且只执行一次

mybatis工具类讲解

package com.ara.utils;

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;

/**
 * Mybatis工具类
 * 主要用于获取SqlSession
 */
public class MybatisUtil {

    //私有静态 加载就被执行 让其只存在一份在内存中
    private static SqlSessionFactory sqlSessionFactory;

    //通过静态代码块来实例化SqlSessionFactory
    static {
        try {
            //读取Mybatis的配置文件
            InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
            //实例化SqlSessionFactory 
            //因为SqlSessionFactoryBuilder在创建SqlSessionFactory之后就再也不会使用了，所以我们这里直接使用匿名对象创建SqlSessionFactory
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * 获取SqlSession对象
     * 值得注意的是：获取的SqlSession对象在使用完毕之后应该立即关闭
     *
     * @return 返回SqlSession对象
     */
    public static SqlSession getSqlSession() {
        //通过SqlSessionFactory创建SqlSession供其他程序使用
        return sqlSessionFactory.openSession();
    }
}

studentmapper.xml

        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--类似创建了一个实现类-->
<mapper namespace="com.qfdue.dao.StudentDAO">
    <!--类似这个实现类的方法,但是这些方法的id要和StudentDAO的方法名一致-->
    <insert id="insertStudent" parameterType="com.qfdue.pojo.Student">

全类名复制

[外链图片转存中…(img-VDUKSwG5-1651847136753)]

resources文件夹

[外链图片转存中…(img-ZbdL202T-1651847136754)]

如何快速得到文件的名称

[外链图片转存中…(img-bolF63ag-1651847136755)]

jdk

[外链图片转存中…(img-ysYul8Lg-1651847136756)]

环境变量

[外链图片转存中…(img-gxsBtNyS-1651847136757)]

<cache/>  
 
//该标签中有一些属性可以自行进行配置
//例如
淘汰策略属性: eviction = "FIFO"  先进先出
更新频率属性: flushInterval = "6000" 间隔多长时间刷新一次缓存
缓存区的大小属性:size = "223" 多少个对象的引用
只读属性: readOnly = "true" 只能读不能改

zhang_xaio_yu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
mybatis基本知识和基本使用

文章目录一:MyBatis：二：MyBatis框架部署：1：创建Maven项目2：在项目中添加MyBatis依赖3：创建MyBatis配置文件,配置数据库连接在mybatis-config.xml中添加数据库连接信息三：MyBatis框架使用1：创建数据表2：创建实体类3：创建DAO接口，并创建操作方法4：创建DAO接口的映射文件5：将映射文件添加到主配置文件四：单元测试1: 添加单元测试依赖 junit2：创建测试类五：MyBatis 的CRUD操作1：添加操作2：删除操作3：修改操作4：查询操作-查
复制链接

扫一扫