一、Mybatis的引入

  1. MyBatis是一款优秀的持久层框架；
  2. 它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。
  3. MyBatis可以通过简单的XML或注解来配置和映射原始类型、接口和Java POJO (Plain OldJava Objects,普通老式Java对象)为数据库中的记录。

  4. MyBatis本是apache的一个开源项目ibatis, 2010年这个项目i山apache迁移到了googlecode,并且改名为MyBatis ORM对象关系映射

  5. Mybatis就是帮助程序猿将数据存入数据库中，和从数据库中取数据、

  6. 传统的jdbc操作，有很多重复代码块.比如:数据取出时的封装，数据库的建立连接等，通过框架可以减少重复代码，提高开发效率.

  7. MyBatis是一 个半自动化的ORM框架(ObjectRelationshipMapping)

    —>对象关系映射（半自动化需要自己写sql语句）

  8. MyBatis官网：https://mybatis.org/mybatis-3/zh/index.html

优势：MyBatis的真正强大在于它的映射语句，这是它的优势所在。由于它的异常强大，映射器的XML文件就显得相对简单。如果拿它跟具有相同功能的JDBC代码进行对比，会立即发现省掉了将近95%的代码。MyBatis为聚焦于SQL而构建，以尽可能地为你减少麻烦

二、MyBatis使用

2.1 基于XML配置

2.1.1 配置Meavn文件，导入所有可能用到的资源

image.png

2.1.2 xml文件配置流程

image.png
image.png

数据库连接池：池中存储数据库连接对象，可以避免每次使用数据库连接对象都要重新创建，导致内存浪费。
单例的，只存储一份。

在java文件夹下配置的的包结构一定要在资源包下一样的设置。
image.png

2.1.3在xml文件下编写sql语句。

image.png

2.1.4 在test文件夹下创建测试类，注意写法
  1. public class MyBatis {
  2.     @Test
  3.     public void test01(){
  4.         try {
  5.             //根据流来读取mybatis核心配置文件，然后再读取相关数据
  6.             InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
  8.             //创建sqlSessionFactory对象
  9.             SqlSessionFactory sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder().build(resourceAsStream);
  11.             //sqlSession从工厂中取出来。
  12.             SqlSession sqlSession = sqlSessionFactoryBuilder.openSession();
  14.             //maybatis会在底层通过动态代理的方式为持久层创建对应的实现类。
  15.             UserDao userdao = sqlSession.getMapper(UserDao.class);
  17.             List<User> userlist = userdao.getuserlist();
  19.             for (User user : userlist) {
  20.                 System.out.println(user);
  21.             }
  23.             //关闭资源
  24.             sqlSession.close();
  25.             resourceAsStream.close();
  27.         } catch (IOException e) {
  28.             e.printStackTrace();
  29.         }
  30.     }
  31. }

2.2 底层原理

mybatis不需要实现类只需要接口，直接只用接口就行，mybatis底层通过例如。

  1. mybatis注解方式是怎样通过没有实现类的dao接口进行数据库操作 解答： 1）原理上：JDK动态动态代理的原理是根据 InvocationHandler 中的invoke()方法，由jdk为你的接口手动生成了一个实现了对应接口的类，因此，你的接口可以调用，这是理解mybatis接口没有实现类能被调用的关键。

2）功能上：可以看出mybatis中的接口就是XML文件的描述，一方面这样做的目的是和spring集成，将接口交给spring管理；另一方面是为了更加方便的管理XML文件（使用接口的package+interface作为namespace，method作为ID。

  1. public class MyBatisTest {
  3.     SqlSession sqlSession = null;
  5.     InputStream resourceAsStream = null;
  6.     /**
  7.      * @Before 在所有测试单元执行之前执行
  8.      */
  9.     @Before
  10.     public void mybatisBefore(){
  13.         try {
  15.             //根据流来读取mybatis的核心配置文件，然后读取相关数据
  16.             resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
  18.         } catch (IOException ioException) {
  20.             ioException.printStackTrace();
  21.         }
  23.         //创建sqlSessionFactory对象
  24.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
  26.         //将sqlSession从工厂中取出来
  27.         sqlSession = sqlSessionFactory.openSession();
  29.     }
  31.     /**
  32.      * @After在所有测试单元执行之后执行
  33.      */
  34.     @After
  35.     public void mybatisAfter(){
  38.         //关闭资源
  39.         if (sqlSession != null){
  41.             sqlSession.close();
  42.         }
  44.         if (resourceAsStream != null){
  46.             try {
  48.                 resourceAsStream.close();
  50.             } catch (IOException ioException) {
  52.                 ioException.printStackTrace();
  53.             }
  54.         }
  55.     }
  57.     @Test
  58.     public void test01(){
  60.         //mybatis会在底层通过动态代理的方式来为持久层接口创建对应的实现类
  61.         UserDao userDao = sqlSession.getMapper(UserDao.class);
  63.         //查询用户信息
  64.         List<User> userList = userDao.getUserList();
  66.         //遍历集合
  67.         for (User user : userList) {
  69.             System.out.println(user);
  70.         }
  72.     }
  73.     @Test
  74.     public void test02(){
  77.             //创建持久层的实例
  78.             UserDao userDao = new UserDaoImpl(sqlSession);
  80.             //查询用户信息
  81.             List<User> userList = userDao.getUserList();
  83.             //遍历集合
  84.             for (User user : userList) {
  86.                 System.out.println(user);
  87.             }
  90.     }
  92.     @Test
  93.     public void test03(){
  95.         //获取代理对象
  96.         UserDao userDao = (UserDao)getProxy();
  98.         List<User> userList = userDao.getUserList();
  100.         for (User user : userList) {
  102.             System.out.println(user);
  104.         }
  107.     }
  109.     /**
  110.      * 模拟mybatis底层通过动态代理来创建持久层的实现类
  111.      * @return
  112.      */
  113.     public Object getProxy(){
  115.         return Proxy.newProxyInstance(UserDao.class.getClassLoader(), new Class[]{UserDao.class}, new InvocationHandler() {
  117.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  119.                 Object invoke = method.invoke(new UserDao() {
  121.                     public List<User> getUserList() {
  123.                         List<User> users = sqlSession.selectList("com.eagleslab.dao.UserDao.getUserList");
  125.                         return users;
  127.                     }
  129.                 });
  131.                 return invoke;
  132.             }
  133.         });
  134.     }
  135. }

2.3 使用流程

  1. 在java文件夹下：创建实体类（也是接受类）；
  2. 在java文件夹下：写一个接口，包含我们要使用到的方法；

  3. 在资源文件夹下：创建映射的xml文件：命名空间换为接口的全类名；

    1.                                    id为方法的全局变量、以及返回类型使用对应的实体类的全类名
    1. <!--建立起实体属性和表字段的对应关系-->
    2. <resultType id="getstudentlist" type="com.eagleslab.pojo.Student">
  1. 在资源文件夹下：核心配置文件对上面的xml文件进行声明
  1. 在test文件夹下：

首先先建立使用的框架：主要就是使用
@Before

  • 根据流来读取mybatis的核心配置文件，然后读取相关数据
  • 创建sqlSessionFactory对象
  • 将sqlSession从工厂中取出来

@After

  • 提交事务

  • 关闭资源 ```java public class MyBatisTest02 { SqlSession sqlSession = null;

    InputStream resourceAsStream = null;

    /**

    • @Before 在所有测试单元执行之前执行 */ @Before public void mybatisBefore(){
  1.     try {
  3.         //根据流来读取mybatis的核心配置文件，然后读取相关数据
  4.         resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
  6.     } catch (IOException ioException) {
  8.         ioException.printStackTrace();
  9.     }
  11.     //创建sqlSessionFactory对象
  12.     SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
  14.     //将sqlSession从工厂中取出来
  15.     sqlSession = sqlSessionFactory.openSession();
  16. }
  18. /**
  19.  * @After在所有测试单元执行之后执行
  20.  */
  21. @After
  22. public void mybatisAfter(){
  24.     //提交事务
  25.     sqlSession.commit();
  27.     //关闭资源
  28.     if (sqlSession != null){
  30.         sqlSession.close();
  31.     }
  33.     if (resourceAsStream != null){
  35.         try {
  36.             resourceAsStream.close();
  38.         } catch (IOException ioException) {
  40.             ioException.printStackTrace();
  41.         }
  42.     }
  43. }
  1. ```java
  2. @Test
  3.     public void test01(){
  4.         //获取代理对象
  5.         StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
  7.         //查询所有的学生数据
  8.         List<Student> studentList = studentDao.getStudentList();
  9.         //遍历集合
  10.         for (Student student : studentList) {
  11.             System.out.println(student);
  12.         }
  13.     }
  1. 补充

当我们使用到的实体类字段与数据库中的表的字段名字不符合时，可以使用到如下标签进行解决

  1.  <!--建立起实体属性和表字段的对应关系-->
  2.     <resultMap id="studentVo" type="com.eagleslab.pojo.Student">
  3.  <!--注意后面使用方法的全类名可以使用studentVo来替代-->
  4.         <!--匹配主键字段-->
  5.         <id property="sid" column="id"></id>
  7.         <!--匹配非主键字段-->
  8.         <result property="stuName" column="name"></result>
  9.         <result property="age" column="age"></result>
  10.         <result property="sex" column="sex"></result>
  11.         <result property="birthday" column="birthday"></result>
  12.         <result property="address" column="address"></result>
  14.     </resultMap>

其他操作：

{} OGM表达式 : 可以防止sql注入，但是不能进行字符串拼接
${} el表达式

  1. <!--添加学生-->
  2. <!--
  3.                 #{} OGM表达式 : 可以防止sql注入
  4.                 ${} el表达式
  5.         -->
  6. <insert id="addStudent" parameterType="com.eagleslab.pojo.Student">
  8.     insert into tb_student(name,age,sex,birthday,address) values (#{stuName},#{age},#{sex},#{birthday},#{address})
  10. </insert>
  12. <!--根据id来修改学生数据-->
  13. <update id="updateStudentById" parameterType="com.eagleslab.pojo.Student">
  15.     update tb_student set name = #{stuName},age = #{age},sex = #{sex},birthday = #{birthday},address = #{address} where id = #{sid}
  17. </update>
  19. <!--根据id来删除学生数据-->
  20. <delete id="deleteStudentById" parameterType="int">
  22.     delete from tb_student where id = #{sid}
  24. </delete>
  26. <!--根据学生姓名来模糊查询-->
  27. <select id="findStudentLikeByName" parameterType="java.lang.String" resultMap="studentVo">
  29.     select * from tb_student where name like #{ewfeferefew}
  31. </select>
  33. <!--求学生的总个数-->
  34. <select id="getStudentCount" resultType="int">
  35.     select count(*) from tb_student
  36.     </select>

三、动态sql

3.1 定义：

动态SQL指的是根据不同的查询条件,生成

3.2 分类：

  1. if
  2. choose (when, otherwise)
    • trim (where, set)
  4. foreach

3.3 ：动态sql的使用方法

使用动态sql需要使用到对应的动态标签

  1.     <!--根据指定的条件来查询对应的学生数据-->
  2.     <select id="getStudentList" resultMap="studentVo" parameterType="hashmap">
  4.         select * from tb_student
  5.         <where>
  6.             <if test="name != null">
  7.                 and name = #{name}
  8.             </if>
  9.      <!--如果符合条件就对查询语句进行拼接-->
  10.             <if test="sex != null">
  11.                 and sex = #{sex}
  12.             </if>
  14.             <if test="id != null">
  15.                 and id = #{id}
  16.             </if>
  17.         </where>
  19.     </select>
  1. @Test
  2. public void test01(){
  4.     //创建代理对象
  5.     StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
  7.     HashMap hashMap = new HashMap();
  9.     hashMap.put("sex","男");
  10.     hashMap.put("id","5");
  12.     List<Student> studentList = studentMapper.getStudentList(hashMap);
  14.     for (Student student : studentList) {
  16.         System.out.println(student);
  17.         }

四、mybatis其他

4.1延迟加载和立即加载

  1. 什么是延迟加载?

真正在使用数据的时候才发起查询，不用的时候不查询，按需加载(懒加载)

  1. 什么是立即加载?

不管用不用，一调用方法，马上发起查询：

  • 针对一对多和多对多:通常情况下使用延迟加载
  • 针对多对和一对:通常情况下使用立即加载

4.2 n对n

4.2.1 一对一、一对多、客对一、多对多
  1. 一对一:账单对用户一个账中只能对应一个用户
  2. 一对多:用户对账单一个用户可以对应多个账单
  3. 多对一:多个学生可以对应一个班级
  4. 多对多:用户和角色:一个用户可以对应多个角色，一个角色也可以对应多个用户。多对多我们一般会指定中间表:用来建立两张表之间的联系

例如：张三是一个用户:在家庭中，张三则一个父亲(角色)，在企业中，足一个项目经理(角色)
多对多我们一般会指定中间表:用来建立两张表之间的联系

2,在mybatis中：

4.2.2 配置一对一

首先创建账户与用户两个类，账户类中聚合了用户类。
接下来在xml配置文件中进行如下操作：

注意：配置方式

聚合一个用户的字段的配置内容 
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.eagleslab.mapper.AccountMapper">
  7.     <!--建立起实体属性和表字段的对应关系-->
  8.     <resultMap id="accountVo" type="com.eagleslab.pojo.Account">
  10.         <!--匹配主键字段-->
  11.         <id property="tid" column="tid"></id>
  13.         <!--匹配非主键字段-->
  14.         <result property="money" column="money"></result>
  15.         <result property="uid" column="uid"></result>
  17.         <!--配置一对一的关系-->
  18.         <association property="user" javaType="com.eagleslab.pojo.User">
  20.             <!--配置用户的字段-->
  21.             <id column="id" property="uid"></id>
  22.             <result column="username" property="username"></result>
  23.             <result column="password" property="password"></result>
  25.         </association>
  26.     </resultMap>
  28.     <!--根据指定的条件来查询对应的学生数据-->
  29.     <select id="findAccountByAll" resultMap="accountVo">
  30.         select * from ts_account a inner join user u on u.id = a.uid
  31.     </select>
  33. </mapper>

配置完成后，注意将改配置文件在核心配置文件中进行注册。

4.2.3 配置一对多

首先创建账户与用户两个类，用户类中聚合了账户类。一个用户对应多个账户
接下来在xml配置文件中进行如下操作：

注意：配置方式 聚合一个账户的字段的配置内容 

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  6. <mapper namespace="com.eagleslab.mapper.UserMapper">
  8.     <resultMap id="userVo" type="com.eagleslab.pojo.User">
  10.         <id column="id" property="uid"></id>
  12.         <result column="username" property="username"></result>
  13.         <result column="password" property="password"></result>
  15.         <!--配置一对多-->
  16.         <collection property="accounts" ofType="com.eagleslab.pojo.Account">
  18.             <!--匹配主键字段-->
  19.             <id property="tid" column="tid"></id>
  21.             <!--匹配非主键字段-->
  22.             <result property="money" column="money"></result>
  23.             <result property="uid" column="uid"></result>
  25.         </collection>
  27.     </resultMap>
  29.     <select id="getUserList" resultMap="userVo">
  31.         select * from user u left join ts_account a on u.id = a.uid
  33.     </select>
  34. </mapper>

4.2.4 多对多

案例：一个用户可以对应多个角色，一个角色也可以对应多个用户

  1. 首先创建：用户表、角色表、中间表（多对多一定要有中间表）
  2. 创建表对应的实体类，每个类里聚合对方类型的list，封装。
  3. 创建每个类对应的接口，接口内定义方法。
  4. 创建xml文件：
    1.     <collection property="userList" ofType="com.eagleslab.pojo.User">
    2.         <id column="id" property="uid"></id>
    3.         <result column="username" property="username"></result>
    4.         <result column="password" property="password"></result>
    5.     </collection>
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  6. <mapper namespace="com.eagleslab.mapper.RoleMapper">
  8.     <!--建立起实体属性和表字段的对应关系-->
  9.     <resultMap id="roleVo" type="com.eagleslab.pojo.Role">
  11.         <!--匹配主键字段-->
  12.         <id property="rid" column="rid"></id>
  13.         <!--匹配非主键字段-->
  14.         <result property="roleName" column="role_name"></result>
  16.         <!--配置多对多的关系-->
  17.         <collection property="userList" ofType="com.eagleslab.pojo.User">
  19.             <id column="id" property="uid"></id>
  21.             <result column="username" property="username"></result>
  22.             <result column="password" property="password"></result>
  24.         </collection>
  27.     </resultMap>
  29.     <!--查询所有的角色数据-->
  30.     <select id="getRoleList" resultMap="roleVo">
  32.         select u.*,r.*
  34.         from user u
  36.         left join user_role ur
  38.         on u.id = ur.uid
  40.         left join tb_role r
  42.         on r.rid = ur.rid
  43.     </select>
  44. </mapper>

注意三表联查：需要两次连接，前一次作为后一次查询的子表。