拉勾 1-1 mybatis 笔记

2020-05-31  本文已影响0人  acc8226

笔记主要来源
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 测试程序

小结

查询部分小结:

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(属性)

引入外部属性文件

<properties resource="db.properties"><property name="jdbc.username" value="root1"/></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

自定义别名

<typeAliases><package name="com.mybatis.pojo"/></typeAliases>

mappers(映射器)

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

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

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

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

​ 前提要求:

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

2、两个文件名称相同

<mapper class="com.mybatis.mapper.UserMapper"/><package name="com.mybatis.mapper"/>

[掌握]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 全局延迟加载开关配置(一对一和一对多都需要开启)

<setting name="lazyLoadingEnabled" value="true" /><setting name="aggressiveLazyLoading" value="false" /><setting name="lazyLoadTriggerMethods" value="true" />

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); 
上一篇下一篇

猜你喜欢

热点阅读