lagou 爪哇 1-1 mybatis 笔记

acc8226

发布于 2022-05-17 16:29:36

7760

发布于 2022-05-17 16:29:36

文章被收录于专栏：叽叽西

笔记主要来源 https://gitee.com/lagouedu/Basic-document/blob/master/document/MyBatis.md

l 经典三层

web表现层（视图+controller）、service层、dao层

分层的好处

代码清晰、解耦、便于维护，出现问题容易定位

分层开发下的常见框架

dao层：hibernate、mybatis

service层：spring框架（对象容器）

web表现层：springmvc框架

[了解]原生JDBC操作数据库分析

package com.mybatis.dao;

import com.mybatis.pojo.User;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

public class UserDaoImpl implements UserDao {

   private String driver = "com.mysql.jdbc.Driver";
   private String url = "jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8";
   private String username = "root";
   private String password = "root";


   public List<User> queryUserList() throws Exception {
      List<User> userList = new ArrayList<User>();

      Class.forName(driver);
      /**
       * 问题一：频繁获取/释放数据库连接，影响数据库和应用性能
       * 解决：数据库连接池技术，C3P0,DRUID（阿里巴巴荣誉出品，号称前无古人后无来者世界最强没有之一）
       */
      Connection connection = DriverManager.getConnection(url, username, password);
      /**
       * 问题二：sql语句硬编码，后期难以维护
       * 解决：若sql语句和java代码分离，比如sql写在配置文件中。Mybatis就是这么干的
       */
      String sql = "select * from user";
      /**
       * 问题三：sql语句where条件和占位符一一对应，后期难以维护
       */
      // String sql1 = "select * from user where username=? and id=?";
      PreparedStatement preparedStatement = connection.prepareStatement(sql);
      // preparedStatement.setInt(1,2);
      ResultSet resultSet = preparedStatement.executeQuery();
      User user = null;
      /**
       * 问题四：结果集解析麻烦，查询列硬编码
       * 期望：如果单条记录直接返回实体对象，如果多条记录返回实体的集合
       */
      while(resultSet.next()) {
         user = new User();
         user.setId(resultSet.getInt("id"));
         user.setUsername(resultSet.getString("username"));
         user.setSex(resultSet.getString("sex"));
         user.setBirthday(resultSet.getDate("birthday"));
         user.setAddress(resultSet.getString("address"));

         userList.add(user);
      }
      resultSet.close();
      preparedStatement.close();
      connection.close();
      return userList;
   }
}

Mybatis框架是一个半自动的ORM持久层框架，也可以在Java中实现类似 insert(User)的操作最终操作数据库，但是需要我们自己写Sql语句。Mybatis是目前比较流行的Dao层框架。

自定义Mybatis框架小结

l 框架的开发使用流程

编写源代码—>打jar包—>框架使用者引入jar包—>按照框架的规范进行XML配置—>Java程序中调用框架API实现功能

l 引入框架坐标即可，它所依赖的dom4j和jaxen都不需要我们引入，这是Maven的依赖传递

l 框架是基础知识的整合（本课程中的jdbc、dom4j、xpath、反射、数据库元数据等）

l 框架往往都会用到设计模式（本课程扩展了工厂设计模式和构建者设计模式）

l 框架展示了代码的拆分思想，各司其职，便于维护

[掌握]Mybatis框架快速入门

l Mybatis入门程序

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>

<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency>

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.46</version>
</dependency>

<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
</dependencies>

n pojo类User.java

package com.mybatis.pojo;

import java.util.Date;

public class User {

    private Integer id;
    private String username;
    private String sex;
    private Date birthday;
    private String address;

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", sex='" + sex + '\'' +
                ", birthday=" + birthday +
                ", address='" + address + '\'' +
                '}';
    }
}

n SqlMapConfig.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 default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?characterEncoding=utf8" />
<property name="username" value="root" />
<property name="password" value="root" />
</dataSource>
</environment>
</environments>

<mappers>
<mapper resource="UserMapper.xml"></mapper>
</mappers>
</configuration>

n UserMapper.xml

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE mapper
      PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
      "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="test">
<select id="queryUserList" resultType="com.mybatis.pojo.User">
      select * from user
</select>
</mapper>

n 测试程序

@Test
public void testMybatis() throws IOException {
      InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
      SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
      SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
      SqlSession sqlSession = sqlSessionFactory.openSession();
      List<User> list = sqlSession.selectList("test.queryUserList");
      if(list != null && list.size() > 0) {
      for (int i = 0; i < list.size(); i++) {
      User user =  list.get(i);
      System.out.println(user);
      }
      }
      sqlSession.close();
      }

[理解]关于三个对象

l SqlSessionFactoryBuilder：创建工厂，生命周期短暂即可，类似于一个工具类

l SqlSessionFactory：应该只有一个工厂对象即可。

l SqlSession：和数据库通信的会话对象，底层对应connection连接。例如：假如多个线程公用一个sqlsession对象（connection），线程A操作了数据库尚未提交事务，线程B操作了数据库把这个connecttion的事务给提交了，会造成数据安全问题。所以一个线程应该有自己的一个sqlsession对象。

换言之，SqlSession是线程不安全的

[掌握]Mybatis入门级CRUD操作

功能需求：

基于已有数据表user，使用MyBatis实现以下功能：

n 根据用户id查询一个用户

n 根据用户名称模糊查询用户列表

n 添加一个用户

n 根据用户id修改用户名

n 根据用户id删除用户

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.46</version>
</dependency>
<!--mybatis的jar坐标-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency>
<!--log4j日志组件，要同时把兄弟log4j.properties引入-->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>utf-8</encoding>
</configuration>
</plugin>
</plugins>
</build>

组件：

POJO

SqlMapConfig.xml

新增业务，修改：UserMapper.xml

关联SqlMapConfig和UserMapper

新增业务，修改：Java程序调用（测试程序）

根据用户id查询用户

l UserMapper.xml

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE mapper
      PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
      "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--mapper根标签，映射的意思
      namespace：命名空间，分类管理的sql的作用
      -->
<mapper namespace="test">

<!--
      查询使用select标签
      parameterType：传入的参数类型
      resultType：封装的结果类型
      -->
<select id="queryUserById" parameterType="Integer" resultType="com.mybatis.pojo.User">
<!--
      #{}固定取参语法
      #{}取参名称：当parameterType传入简单数据类型的时候，取参名称任意，但是建议见名思意，比如是id就#{id}
      -->
      select * from user where id=#{id}
</select>

</mapper>

l 测试程序

/**
 * 测试用例(Use_case)：根据id查询用户
 */
@Test
public void testQueryUserById() throws IOException {
      InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
      SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
      SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
      SqlSession sqlSession = sqlSessionFactory.openSession();
      /*
       * 调用会话对象的api完成crud
       * param1：锁定sql的唯一标识符
       * param2：传入的参数
       * */
      User user = sqlSession.selectOne("test.queryUserById",1);
      System.out.println(user);
      sqlSession.close();
      inputStream.close();
      }

根据用户名模糊查询用户列表

l #{}方式取参

n UserMapper.xml

<!--根据用户名模糊查询用户列表-->
<!--注意：返回多条记录和返回单条记录，resultType配置是一样的-->
<select id="queryUserByUsername" parameterType="String" resultType="com.mybatis.pojo.User">
<!--
      #{}底层原理：预编译语句（防止sql注入，性能提高）
      #{}对字符串参数自动添加单引号对
      -->
      select * from user where username like #{username}
</select>

n 测试程序

/**
 * 测试用例(Use_case)：根据用户名模糊查询用户列表
 */
@Test
public void testQueryUserByUsername() throws IOException {
      InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
      SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
      SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
      SqlSession sqlSession = sqlSessionFactory.openSession();
      // TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 2
      List<User>  userList = sqlSession.selectList("test.queryUserByUsername","%王%");
      if(userList != null && userList.size() > 0) {
      for (int i = 0; i < userList.size(); i++) {
      User user =  userList.get(i);
      System.out.println(user);
      }
      }
      sqlSession.close();
      inputStream.close();
      }

l ${}方式取参

n UserMapper.xml

<!--
      ${}：另外一种取参方式
      ${}取参名称：当parameterType传入简单数据类型的时候，取参名称必须为value字符串
      ${}原理：简单的字符串，传什么参数拼接什么
      不会对字符串参数添加单引号对
      -->

<!--
      #和$取参使用原则
      能用#不用$(从底层原理角度出发说的，#是预编译语句),特殊情况使用$：当你传入的参数是数据库对象（比如表名动态传入），或者是
      order by 的那个字段，都不希望自动添加单引号对，所以使用$
      -->
<select id="queryUserByUsername$" parameterType="String" resultType="com.mybatis.pojo.User">
      select * from user where username like ${value}
</select>

n 测试程序

 /**
 
  - 测试用例(Use_case)：根据用户名模糊查询用户列表$取参形式
  */
 @Test
 public void testQueryUserByUsername$() throws IOException {
         InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
         SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
         SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
         SqlSession sqlSession = sqlSessionFactory.openSession();
         // TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 2
         List<User>  userList = sqlSession.selectList("test.queryUserByUsername$","'%王%'");
         if(userList != null && userList.size() > 0) {
         for (int i = 0; i < userList.size(); i++) {
         User user =  userList.get(i);
         System.out.println(user);
         }
         }
         sqlSession.close();
         inputStream.close();
         }

小结

查询部分小结：

l selectOne，当结果集有多条记录的时候，抛出异常；

l #{}和${}使用原则

能使用#不用，特殊情况下使用，特殊情况比如传入的参数是数据库对象（表名）或者order by的字段名时，不希望自动添加单引号对；

l 返回结果集列表的时候，resultType和返回单个对象配置都一样；

实现添加用户（及Mysql自增主键返回）

<!--
        #{}和${}取参时，当parameterType为pojo的时候，取参名称为pojo的属性名
        -->
<insert id="saveUser" parameterType="com.mybatis.pojo.User">

<!--
        selectKey用于查询主键数据
        order：selectKey中的sql在insert之前还是之后执行 AFTER/BEFORE
        resultType:查询出的主键的类型
        keyProperty：查询出的主键数据回显到pojo的哪个属性
        -->
<selectKey order="AFTER" resultType="Integer" keyProperty="id">
        select last_insert_id()
</selectKey>
        insert into user(username,sex,birthday,address)
        values(#{username},#{sex},#{birthday},#{address})
</insert>

自增主键返回：其实就是mybaits在执行完insert之后立马查询last_insert_id()

根据用户id修改用户名

<update id="updateUsernameById" parameterType="com.mybatis.pojo.User"> update user set username=#{username} where id=#{id}</update>

根据用户id删除用户

<delete id="deleteUserById" parameterType="Integer"> delete from user where id=#{id}</delete>

Mybatis解决原生JDBC操作数据库存在的问题

1、频繁创建、释放数据库连接造成系统资源浪费，影响系统性能。使用数据库连接池技术可以解决此问题。

解决：在SqlMapConfig.xml中配置数据连接池，使用连接池管理数据库连接。

2、Sql语句写在代码中造成代码不易维护，实际应用中Sql变化的可能较大，Sql变动需要改变java代码。

解决：将Sql语句配置在XXXXmapper.xml文件中与Java代码分离。

3、向Sql语句传参数麻烦，因为Sql语句的where条件不一定，可能多也可能少，占位符需要和参数一一对应（硬编码）。

解决：Mybatis自动将Java对象映射至Sql语句，通过statement中的parameterType定义输入参数的类型。

4、对结果集解析麻烦（查询列硬编码），Sql变化会导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成Pojo对象解析比较方便。

解决：Mybatis自动将Sql执行结果映射至Java对象，通过statement中的resultType定义输出结果的类型。

[掌握]Mybatis的两种Dao开发方式

使用MyBatis开发DAO的方式实现以下的功能：

n 根据用户id查询一个用户信息

原始Dao开发方式

定义接口（UserDao）

写实现类（UserDaoImpl）：在实现类中写crud那套程序

l 定义接口UserDao

package com.mybatis.dao;

import com.mybatis.pojo.User;

/**
 * 原始Dao开发方式接口定义
 */
public interface UserDao {

    User queryUserById(Integer id) throws Exception;
}

l 写实现类

package com.mybatis.dao;

import com.mybatis.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

public class UserDaoImpl implements UserDao {

    /**
     * 声明一个SqlSessionFactory变量，用于接收service层调用dao层时传入的工厂对象
     * 因为工厂对象全局唯一，对于全局唯一的对象，在分层的架构中，dao层使用时候应该由
     * 外部传入
     */
    private SqlSessionFactory sqlSessionFactory;
    public UserDaoImpl(SqlSessionFactory sqlSessionFactory) {
        this.sqlSessionFactory = sqlSessionFactory;
    }

    @Override
    public User queryUserById(Integer id) throws Exception {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        User user = sqlSession.selectOne("test.queryUserById", id);
        sqlSession.close();
        return user;
    }
}

注意：分层其实是对原有代码的重新组织

l 思考

一个项目当中会有很多表，都对应dao接口和实现类，实现类就是做增删改查这些东西

能否不写实现类只定义接口，让框架帮我们完成实现类的逻辑，那么就是Mapper动态代理的开发方式

Mapper动态代理开发方式

l 定义一个Mapper接口，这个接口其实和我们UserDao接口是一样的

Mapper接口中的接口方法被调用时候，最终要找到这个接口方法所使用的sql语句？那如何找到呢？

遵从下面4个规范即可

l 从Mybatis框架中拿到一个代理对象（代理的是这个Mapper接口），通过代理对象调用接口当中的方法完成业务

n 传统dao开发方式中的实现类其实起了一个连接、承上启下的作用，连接了接口和xml映射文件，效果就是调用接口方法时能够找到xml映射文件

n Mapper动态代理开发遵从的规范

u sql映射文件的namespace必须和mapper接口的全限定类名保持一致

u mapper接口的接口方法名必须和xml中的sql语句id保持一致

u mapper接口的接口方法形参类型必须和sql语句的输入参数类型保持一致

u mapper接口的接口方法返回类型必须和sql语句的resultType保持一致

小结

原始Dao和Mapper动态代理开发在企业中都很常见，推荐使用Mapper动态代理开发模式

[掌握]全局配置文件SqlMapConfig.xml的使用说明

注意：子标签是有顺序要求的，因为使用了dtd校验

properties（属性）

引入外部属性文件

typeAliases（类型别名）

Mybatis默认支持的别名

别名	映射的类型
_byte	byte
_long	long
_short	short
_int	int
_integer	int
_double	double
_float	float
_boolean	boolean
string	String
byte	Byte
long	Long
short	Short
int	Integer
integer	Integer
double	Double
float	Float
boolean	Boolean
date	Date
decimal	BigDecimal
bigdecimal	BigDecimal
map	Map

注意：更多默认别名参见mybatis源码中的TypeAliasRegistry类

自定义别名

mappers（映射器）

引入sql语句的xml配置文件，把sql语句加载到内存当中

l <mapper resource=""/> 万能型选手，基础crud、原始dao开发、mapper动态代理开发都可以使用这种方式

l 针对mapper动态代理开发dao层，我们进行一个增加

mapper class属性：执行mapper接口类的全限定类名

前提要求：

1、编译之后 mapper.xml和mapper.class在同一个目录文件夹中

2、两个文件名称相同

[掌握]Mybatis的输入类型和结果类型

parameterType（输入类型）

l 传递简单类型

参考上面

l 传递Pojo对象

参考上面

l 传递Pojo包装对象

n 需求：使用POJO包装对象，根据用户名模糊查询用户列表

地址：http://epub.sipo.gov.cn/gjcx.jsp

resultType（输出类型）

l 输出简单类型

查询user表总记录数

l 输出Pojo对象

参考上面

l 输出Pojo列表

参考上面

resultMap（手动映射）

l 订单表POJO类

package com.mybatis.pojo;

import java.util.Date;

public class Orders {
    // 订单id
    private int id;
    // 用户id
    private Integer userId;
    // 订单号
    private String number;
    // 订单创建时间
    private Date createtime;
    // 备注
    private String note;

    public int getId() {
        return id;
    }

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

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public Date getCreatetime() {
        return createtime;
    }

    public void setCreatetime(Date createtime) {
        this.createtime = createtime;
    }

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note;
    }

    @Override
    public String toString() {
        return "Orders{" +
                "id=" + id +
                ", userId=" + userId +
                ", number='" + number + '\'' +
                ", createtime=" + createtime +
                ", note='" + note + '\'' +
                '}';
    }
}

n OrdersMapper.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 namespace="com.mybatis.mapper.OrdersMapper">

<!--
        resultType：自动映射，要求查询列名和pojo属性名保持一致
        1 最终封装的对象
        2 查询列名和pojo属性名一致
        当不一致的时候，要使用手动映射
        resultMap：配置手动映射
        -->
<select id="queryOrdersAllList" resultMap="ordersResultMap">
        select * from orders
</select>


<resultMap id="ordersResultMap" type="orders">
<!--手动配置映射关系-->
<!--
        主键字段不一致的时候使用<id>标签配置
        普通字段不一致的时候使用<result>标签配置
        property严格区分大小写，要和pojo属性名称一致
        -->
<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
</resultMap>


</mapper>

工程准备

新建一个Maven类型的module：实现Mybatis第二天的保存用户功能，便于基于该功能的代码程序说明Mybatis数据库连接池和Mybatis事务控制。

[理解]Mybatis连接池和事务控制

Mybatis连接池

l POOLED使用连接池

n 什么时候从连接池获取连接

getMapper的时候还是真正调用api操作数据库的时候？

从连接池获取连接的时机：真正操作数据库调用api的时候，不是getMapper的时候

l 其他

n UNPOOLED：不使用数据库连接池（一般不使用）

n JNDI:(前提你的Mybatis环境必须是Web应用)（了解）

u 什么是JNDI

JNDI:java naming directory interface(java命名目录接口)，它是一种该服务发布技术，可以通过JNDI技术把数据源发布成一个服务，那么客户端可以调用这个服务

u 为什么必须是web应用

因为支持JNDI技术的往往是tomcat/weblogic/websphere这些中间件才支持JNDI技术

u 如果在Mybatis当中用，怎么用

参考附录

Mybatis事务控制

type="JDBC"：使用Jdbc的事务管理机制，connection的事务

Mybatis默认把Jdbc的事务自动提交给关闭了

注意：考虑提交的数据量较小的时候使用自动提交，如果数据量大影响了操作数据库的性能，那么考虑分批次手动控制事务的提交

type="MANAGED"：什么都不做，交给其他框架管理事务

[掌握]Mybatis映射文件的Sql深入（即动态Sql）

更优雅更方便的帮助我们拼接sql语句。

根据用户性别和用户名称查询用户列表

if标签/where标签

sql片段

引用sql片段使用include标签，refid指向sql片段的id，如果共享其他mapper文件当中的sql片段，只需要refid前面加上另外一个mapper映射文件的namespace即可

foreach标签

delete from user where id in(1,2,3)

String sql = "delete from user where id in("

for(String s: list) {

    sql += s + ","

}

substring

sql += ")"

需求：根据多个id来查询用户列表

select * from user where id in(1,2,3)

l 形式一：直接传入list集合给mybatis

l 形式二：直接传入数组给Mybatis

Mybatis底层别名定义类

<!--
        foreach直接传入Array数组
        -->
<select id="queryUserByIdsArray" parameterType="int[]" resultType="user">
        select id,username,sex,birthday,address from user
<!--
        foreach：遍历拼接sql语句
        collection：遍历的集合，注意当直接传数组，除了知道是数组外没有别的名字，所以collection固定配置为array
        open：遍历拼接前干点啥（拼接点什么字符串）
        close:遍历结束后干点啥（拼接点什么字符串）
        separator：遍历拼接时候使用的分隔符
        item：遍历到的具体元素值，等同于下面for循环中的s
        for(String s : list) {
        s
        }
        -->
        <foreach collection="array" open=" where id in(" close=")" separator="," item="item">
        #{item}
        </foreach>
        </select>

l 形式三：传入一个pojo，pojo中有list或者数组

 <!--        foreach直接传入pojo,pojo中封装list或者数组        --><select id="queryUserByIdsQueryVo" parameterType="queryvo" resultType="user">        select id,username,sex,birthday,address from user<!--        foreach：遍历拼接sql语句        collection：遍历的集合，当传入pojo的时候，collection配置为pojo当中集合的属性名        如果不指定具体属性名，那么mybatis是不知道要取pojo哪个属性的        open：遍历拼接前干点啥（拼接点什么字符串）        close:遍历结束后干点啥（拼接点什么字符串）        separator：遍历拼接时候使用的分隔符        item：遍历到的具体元素值，等同于下面for循环中的s        for(String s : list) {        s        }        -->        <foreach collection="idsList" open=" where id in(" close=")" separator="," item="item">        #{item}        </foreach>        </select>

[掌握]Mybatis的多表关联查询

多表：至少2张表

多表关系分析技巧：从一条记录出发，比如分析A表和B表的关系，就看A表的一条记录可以对应B表中几条记录，如果对应一条，从A到B表就是一对一的关系，如果对应多条就是一对多的关系。

多对多其实是双向的一对多

l 一对一

从订单表出发到用户表，一条订单记录只会对应用户表的一条记录，一对一

l 一对多

从用户表出发到订单表，一个用户记录可以对应订单表的多条记录，一对多

（通过主外键，一的一方是主表，多的一方是从表，外键在从表多的那一方）

l 多对多

用户和角色，一个用户可以有多个角色，一个角色也可以对应多个用户

通过中间表表达两个表之间的关系

a表 b表

id field.. id field..

中间表（往往两个字段即可）

aid bid

多表关联的SQL语句表达分析

l Sql语句表达

n 笛卡尔积

u SELECT * FROM USER,orders

SELECT * FROM USER u,orders o WHERE u.id=o.user_id(笛卡尔积进一步筛选)

n 关联查询

u 内关联 innder join on（和笛卡尔积进一步筛选效果一样）

SELECT * FROM USER u INNER JOIN orders o ON u.id=o.user_id

u 外连接(outer join on)（使用较多）

左外连接(left join) left join左边的表是基础表

SELECT * FROM USER u LEFT JOIN orders o ON u.id=o.user_id

右外连接(right join) right join右边的表是基础表

SELECT * FROM USER u RIGHT JOIN orders o ON u.id=o.user_id

l 内关联和外关联分析

一对一查询

Mybatis帮我们做的事情：

1、 SQL语句是用户自己写，Mybatis框架只是帮我们执行而已

2、封装结果集

需求：查询订单表全部数据，关联查询出订单对应的用户数据（username address）

l Mapper映射文件

<select id="queryOrdersUser" resultMap="ordersUserResultMap">
        SELECT
        o.`id`,
        o.`user_id`,
        o.`number`,
        o.`createtime`,
        o.`note`,
        u.`username`,
        u.`address`
        FROM
        orders o
        LEFT JOIN USER u
        ON o.`user_id` = u.`id`
</select>


<resultMap id="ordersUserResultMap" type="orders">
<!--两部分数据：订单+用户-->
<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>

<!--association：关联的意思,用于一对一关联封装数据
        property：一对一关联后封装成的数据所对应的属性名
        javaType：属性的类型
        -->
<association property="user" javaType="user">
<id column="user_id" property="id"/>
<result column="username" property="username"/>
<result column="address" property="address"/>
</association>
</resultMap>

l 测试程序

@Test
public void testQueryOrdersUser() {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class);
        List<Orders> ordersList = ordersMapper.queryOrdersUser();
        if(ordersList != null && ordersList.size() > 0) {
        for (int i = 0; i < ordersList.size(); i++) {
        Orders orders =  ordersList.get(i);
        System.out.println(orders);
        }
        }
        sqlSession.close();
        }

一对多查询

需求：查询全部用户数据，关联查询出订单数据

l Mapper映射文件

<!--一对多用例-->
<select id="queryUserOrders" resultMap="userOrdersResultmap">
        SELECT
        u.`id`,
        u.`username`,
        u.`sex`,
        u.`birthday`,
        u.`address`,
        o.`id` oid,
        o.`user_id`,
        o.`number`,
        o.`createtime`,
        o.`note`
        FROM
        USER u
        LEFT JOIN orders o
        ON u.`id` = o.`user_id`
</select>



<resultMap id="userOrdersResultmap" type="user">
<!--两部分数据：用户+订单-->
<id column="id" property="id"/>
<result column="username" property="username"/>
<result column="sex" property="sex"/>
<result column="birthday" property="birthday"/>
<result column="address" property="address"/>

<!--一对多使用collection标签
        property：封装成对应的属性的属性名
        ofType：因为此时属性是一个list集合，collection已经表明了集合的意思，最重要的指定list里面的泛型类型，
        所以使用ofType
        -->
<collection property="ordersList" ofType="orders">
<id column="oid" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
</collection>
</resultMap>

多对多查询

多对多关系分析

多对多是双向的一对多

实现Role到User的一对多

l Mapper映射文件

<select id="queryRoleUsers" resultMap="roleUsersResultMap">
        SELECT
        r.rid,
        r.rname,
        r.rdesc,
        u.`username`,
        u.`address`
        FROM
        role r
        LEFT JOIN user_role ur
        ON r.`RID` = ur.`RID`
        LEFT JOIN USER u
        ON ur.`UID` = u.`id`
</select>

<!-- 多对多拆分成双向的一对多-->
<resultMap id="roleUsersResultMap" type="role">
<id column="rid" property="rid"/>
<result column="rname" property="rname"/>
<result column="rdesc" property="rdesc"/>

<collection property="userList" ofType="user">
<result column="username" property="username"/>
<result column="address" property="address"/>
</collection>
</resultMap>

实现User到Role的一对多

[了解]扩展知识

Tomcat配置JNDI数据源（了解）

l 第一步：将数据库驱动程序(jar包)放到tomcat安装目录下的common\lib文件夹下

l 第二步：在Tomcat的conf/context.xml文件中进行jndi数据源服务配置

name：在JNDI中叫做目录名，等同于服务名，此处的jndi/mybatis是自定义的，往往以/连接前后字符串即可。

auth和type是固定的，其他都是数据库连接池的具体配置信息

l 第三步：在自己web项目的web.xml中引用Jndi数据源服务

l 第四步：在自己web项目的Mybatis配置文件中使用

配置data_source属性，指向你的数据源引用，java:comp/env/jndi/mybatis中红色部分是固定的，绿色部分是你自己定义的目录名（服务名）

工程准备

使用Mapper动态代理的方式实现：

l 根据用户id查询用户

l 查询全部订单数据并关联查询出用户数据（一对一）

l 查询全部用户数据并关联查询出订单数据（一对多）

便于基于代码程序讲解Mybatis延迟加载和缓存。

[掌握]Mybatis延迟加载策略

关联对象：数据库层次用户和订单是关联表，在对象层次订单对象和用户对象就叫做关联对象

什么是延迟加载？

在使用关联对象的过程中

比如使用了Orders对象，但是我只是获取Orders的订单数据尚未获取user的数据，但是依然查询了user表（这不是延迟）

我orders.getNumber()你不要查user表的数据，当我orders.getUser()你再去查user表

关联查询的关联对象，在较多的场合中并不需要的时候，只在少部分场合需要关联的那个对象数据，可以考虑使用延迟加载

Mybatis中怎么实现延迟加载？

步骤1：原来关联sql语句要拆分

1）第一条sql查询基础表

2）第二条sql根据基础表的条件查询关联表

步骤2：让两条sql自动产生联系，通过<association column="" select=""/> 或者<collection column="" select =""/>

l 全局延迟加载开关配置（一对一和一对多都需要开启）

l 一对一关联查询的延迟加载

<select id="queryOrdersWithUser" resultMap="ordersUserResultMap">
      SELECT
      o.`id`,
      o.`user_id`,
      o.`number`,
      o.`createtime`,
      o.`note`
      FROM
      orders o
</select>

<!--
      延迟加载分析
      1、原来关联查询的sql语句必然要拆分，如果不拆分，那肯定要执行关联查询，两个表用不用都要查
      2、sql=sql1+sql2拆分之后，要让这两个sql自动产生联系
      sql1:select id,user_id,number,createtime,note from orders
      sql2:select * from user u where id=user_id
      -->

<resultMap id="ordersUserResultMap" type="orders">
<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
<association property="user" javaType="user" column="user_id" select="com.mybatis.mapper.UserMapper.queryUserByUserId">
</association>
</resultMap>

<select id="queryUserByUserId"  parameterType="int" resultType="user">
      select id,username,sex,birthday,address from user where id=#{user_id}
</select>

l 一对多关联查询的延迟加载

<select id="queryUserWithOrders" resultMap="userOrdersResultMap">
      SELECT
      u.`id`,
      u.`username`,
      u.`sex`,
      u.`birthday`,
      u.`address`
      FROM
      USER u
</select>

<resultMap id="userOrdersResultMap" type="user">
<id column="id" property="id"/>
<result column="username" property="username"/>
<result column="sex" property="sex"/>
<result column="birthday" property="birthday"/>
<result column="address" property="address"/>

<collection property="ordersList" ofType="orders" column="id" select="com.mybatis.mapper.OrdersMapper.queryOrdersByUserId">
</collection>
</resultMap>

<!--拆分的第二条sql语句-->
<select id="queryOrdersByUserId" parameterType="int" resultType="orders">
      select o.id,o.user_id,o.number,o.createtime,o.note  from orders o  where o.user_id=#{id}
</select>

[了解]Mybatis缓存

Mybatis的一级缓存

Mybatis的一级缓存是SqlSession级别的缓存，是默认开启的

注意：以下情形缓存会失效（被清理掉）：

n sqlSession关闭

n sqlSession提交事务：意味着可能是一个增删改的动作，数据表数据产生变化，那么这个时候Mybatis就会把这个sqlSession已有的一级缓存给清理掉

Mybatis的二级缓存

l Mybatis二级缓存机制

l 怎么用Mybatis的二级缓存

n 开启二级缓存开关

第一个开关：需要在SqlMapConfig.xml中开启二级缓存总开关

第二个开关：需要在使用二级缓存的mapper.xml中开启（因为二级缓存是mapper级别的）

n Pojo实现序列化

ratio：命中率的意思，两次都去查询了二级缓存，但是第一次的时候缓存中没有数据，所以没有命中，第二次查询的时候缓存中已经有数据了，所以命中率是0.5

l Mybatis二级缓存的清理时机：当这个mapper.xml中执行了非select语句的时候，整个Mapper的缓存全部清除掉。

注意：避免使用二级缓存，因为二级缓存带来的好处远远比不上他所隐藏的危害

n 如果你针对user表的sql操作并不是全部都在UserMapper.xml中，使用缓存的结果可能会不正确。

n 多表操作一定不能使用缓存

为什么不能？首先不管多表操作写到那个Mapper.xml下，都会存在某个表不在这个Mapper下的情况。例如两个表：role和user_role，如果我想查询出某个用户的全部角色role，就一定会涉及到多表的操作

<select id="selectUserRoles" resultType="UserRoleVO">
      select * from user_role a,role b where a.roleid = b.roleid and a.userid = #{userid}
</select>

像上面这个查询，你会写到那个xml中呢？？不管是写到RoleMapper.xml还是UserRoleMapper.xml，或者是一个独立的XxxMapper.xml中。如果使用了二级缓存，都会导致上面这个查询结果可能不正确。如果你正好修改了这个用户的角色，上面这个查询使用缓存的时候结果就是错的。

[掌握]Mybatis的注解开发

效果：没有写sql语句的xml了

l 基础的crud（基础crud怎么使用注解）

l 关联查询延迟加载（怎么使用注解完成）

l 动态sql的注解方式

原则：把原来xml里面的内容都对应的放到注解上即可

注解开发不需要引入额外的jar包，和原来一致即可

注解添加在接口类的方法上

使用注解实现基本的CRUD

@Insert("insert into user(username,sex,birthday,address) values (#{username},#{sex},#{birthday},#{address})")

/*回显mysql自增主键id 
  等同于原来我们xml中使用<selectKey/>，一一对应过来即可
* */
@SelectKey(statement = "select last_insert_id()",before = false,keyProperty = "id",resultType = Integer.class)
void saveUser(User user);

@Update("update user set username=#{username} where id=#{id}")
void updateUsernameById(User user);

@Delete("delete from user where id=#{id}")
void deleteUserById(Integer id);

@Select("select id,username,sex,birthday,address from user where id=#{id}")
User queryUserById(Integer id);

@Select("select id,username,sex,birthday,address from user")
List<User> queryUserList();


@Select("<script>select id,username,sex,birthday,address from user" +
        "<where>" +
        "<if test=\"sex != null and sex != ''\">" +
        " and sex=#{sex}" +
        "</if>" +
        "<if test=\"username != null and username != ''\">" +
        " and username like #{username}" +
        "</if>" +
        "</where></script>")
List<User> queryUserByWhere(User user);


@Select("<script>select id,username,sex,birthday,address from user" +
        "<foreach collection=\"list\" open=\" where id in(\" close=\")\" separator=\",\" item=\"item\">" +
        "#{item}" +
        "</foreach></script>")
List<User> queryUserByIdsList(List<Integer> ids);

使用注解实现复杂关系映射开发

使用注解实现一对一查询

/*
 * 对应关系
 * @Results对应xml中的resultMap
 * @Result对应xml中的id/result
 * id：true/false，是否是主键，默认false
 * column：查询列名
 * property：pojo属性名
 * association：在注解中使用@Result+one=@One的方式去表达
 * fetchType：延迟加载类型，默认是延迟加载，eager：积极加载
 * */

@Results({
        @Result(id = true,column = "id",property = "id"),
        @Result(column = "user_id",property = "userId"),
        @Result(column = "number",property = "number"),
        @Result(column = "createtime",property = "createtime"),
        @Result(column = "note",property = "note"),
        @Result(property = "user",column = "user_id",javaType = User.class,one=@One(select = "com.mybatis.mapper.UserMapper.queryUserByUserid",fetchType = FetchType.LAZY))
})
List<Orders> queryOrdersUser();

@Select("select id,username,sex,birthday,address from user where id=#{user_id}")
User queryUserByUserid(Integer id);

使用注解实现一对多查询

l mapper接口

/*
 * 对应关系
 * @Results对应xml中的resultMap
 * @Result对应xml中的id/result
 * id：true/false，是否是主键，默认false
 * column：查询列名
 * property：pojo属性名
 * collection：在注解中使用@Result+many=@Many的方式去表达
 * xml中的ofType在注解中使用 javaType表达=List.class
 * fetchType：延迟加载类型，默认是延迟加载，eager：积极加载
 * */
@Select("select id,username,sex,birthday,address from user")
@Results({
        @Result(id = true,column = "id",property = "id"),
        @Result(column = "username",property = "username"),
        @Result(column="sex",property="sex"),
        @Result(column="birthday",property="birthday"),
        @Result(column="address",property="address"),
        @Result( property="ordersList",javaType = List.class,column="id",
                many = @Many(select="com.mybatis.mapper.OrdersMapper.queryOrdersByUserid",fetchType = FetchType.LAZY))
})
List<User> queryUserOrders();

@Select("select id,number from orders where user_id=#{userId}")
List<Orders> queryOrdersByUserid(Integer userId);

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2022-05-17，如有侵权请联系 cloudcommunity@tencent.com 删除

mybatis

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！