Mybatis 复习

概述

mybatis 是一个用java编写的持久层框架, 它封装了jdbc操作的很多细节,使开发者只需要关注sql语句本身,而无需关注注册驱动,创建连接等繁杂过程,它使用了ORM思想实现了结果集的封装

ORM Object Relational Mapping 对象关系映射,把数据库表和实体类及实体类的属性对应起来,让我们可以操作实体类就实现操作数据库表

入门案例

创建数据库,创建User表

创建maven工程并导入坐标

<project ...>

    ...

	<packaging>jar</packaging>

    <dependencies>

        <dependency>

            <groupId>org.mybatis</groupId>

            <artifactId>mybatis</artifactId>

            <version>3.5.2</version>

        </dependency>

        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

            <version>8.0.15</version>

        </dependency>

    </dependencies>

</project>

编写实体类

public class User{

    private Integer id;

    private String username;

    private String password;

    getter()...

    setter()...

    toString()...

}

创建UserDao接口

public interface UserDao{

    List<User> findAll();	//查询所有用户

}

创建主配置文件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">

<!-- mybatis的主配置文件 -->

<configuration>

    <!-- 配置环境 -->

    <environments default="mysql">

        <!-- 配置mysql的环境 -->

        <environment id="mysql">

            <!-- 配置事务的类型 -->

            <transactionManager type="JDBC"></transactionManager>

            <!-- 配置数据源(连接池) -->

            <dataSource type="POOLED">

                <!-- 配置连接数据库的四个基本信息 -->

                <property name="driver" value="com.mysql.jdbc.Driver"/>

                <property name="url" value="jdbc:mysql://localhost:3306/db"/>

                <property name="username" value="root"/>

                <property name="password" value="root"/>

            </dataSource>

        </environment>

    </environments>

    <!-- 指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件 -->

    <mappers>

        <mapper resource="com/whteway/dao/UserDao.xml"/>

    </mappers>

</configuration>

创建映射配置文件UserDao.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.whteway.dao.UserDao">

    <!-- 配置查询所有,id为对应方法名,resultType指定结果封装位置 -->

    <select id="findAll" resultType="com.whteway.domain.User">

        select * from user

    </select>

</mapper>

注意
- Mybatis中把持久层的操作接口名称和映射文件也叫做Mapper,所以dao也可以叫mapper
- 在idea中创建com.whteway.dao包时是三级结构,创建目录时是一级目录
- 映射配置文件的位置结构必须和dao接口的包结构相同
- 映射配置文件的mapper标签的namespace属性的取值必须是dao接口的全限定类名
- 映射配置文件的操作标签的id属性必须是对应的方法名
- 遵循以上规则,则不用写dao实现类

使用

public void test(){

    //1.读取配置文件

    InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");

    //2.创建SqlSessionFactory工厂

    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

    SqlSessionFactory factory = builder.build(in);

    //3.使用工厂生产SqlSession对象

    SqlSession session = factory.openSession();

    //4.使用SqlSession创建Dao接口的代理对象

    UserDao userDao = session.getMapper(UserDao.class);

    //5.使用代理对象执行方法

    List<User> users = userDao.findAll();

    for(User user: users)

        System.out.println(user);

    //6.释放资源

    session.close();

    in.close();

}

注解方式

主配置文件SqlMapConfig.xml

...

    <mappers>

        <!-- <mapper resource="com/whteway/dao/UserDao.xml"/> -->

        <mapper class="com.whteway/dao/UserDao"/>

    </mappers>

...

UserDao.java

public interface UserDao{

    @Select("select * from uesr")

    List<User> findAll();

}

删除UserDao.xml

连接池

mybatis连接池提供三种方式的配置
- 配置位置：主配置文件中dataSource标签的type属性
- type取值：
  - POOLED
    
    采用传统的javax.sql.DataSource规范中的连接池
  - UNPOOLED
    
    采用传统的获取连接的方式，实现了DataSource接口，没有用连接池思想
  - JNDI
    
    采用服务器提供的JNDI技术实现，来获取DataSource对象，不同的服务器能拿到的DataSource不一样，如果不是web或者maven的war工程，就不能使用
事务管理
- 通过SqlSession的 commit() 和 rollback() 方法
- SqlSession openSession(boolean autoCommit); 传入false开启事务

自定义dao实现类(不常用, 用来研究原理)

public class UserDaoImpl implements UserDao{

    private SqlSessionFactory factory;

    public UserDaoImpl(SqlSessionFactory factory){

        this.factory = factory;

    }

    public List<User> findAll(){

        //使用工厂创建SqlSession对象

        SqlSession session = factory.openSession();

        //使用session对象执行sql语句

        List<User> users = session.selectList("映射配置文件的namespace.findAll");

        session.close();

        //返回查询结果

        return users;

    }

}

//-----------------使用----------------

public void test(){

    InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");

    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

    SqlSessionFactory factory = builder.build(in);

    UserDao userdao = new UserDaoImpl(factory);

    List<User> users = userDao.findAll();

    in.close();

}

流程分析

使用过程

读配置文件

读取配置文件时用绝对路径和相对路径(web工程部署后没有src路径)都有一定问题，实际开发中一般有两种方法
- 使用类加载器，它只能读取类路径的配置文件
- 使用SerbletContext对象的getRealPath()
创建SqlSessionFactory工厂

建造者模式（Builder Pattern）
使用工厂生产SqlSession对象

工厂模式（Factory Pattern）
使用SqlSession创建Dao接口的代理对象

代理模式（Proxy Pattern）
使用代理对象执行方法
释放资源

自定义dao中selectList()方法的执行流程，也是代理对象增强的逻辑

注册驱动，获取Connection对象（需要数据库信息）
- 通过SqlMapConfig.xml的数据库信息，解析xml文件用到的是dom4j技术
获取预处理对象PreparedStatement（需要sql语句）
- 通过SqlMapConfig.xml中的mapper标签定位UserDao.xml，映射配置文件中有sql语句
执行查询，得到结果集ResultSet
遍历结果集用于封装
- 根据UserDao.xml中的resultType反射获得User对象，User对象的属性名和表中列名一致，可以一一封装进user对象中，再把user对象封装进list中

所以，要想让selectList()执行，需要提供两个信息，连接信息和映射信息，映射信息包括sql语句和封装结果的实体类的全限定类名，所以映射信息可以用map存储

创建代理对象流程

根据dao接口的字节码创建dao的代理对象

public <T> T getMapper(Class<T> daoInterfaceClass){

    /*

      类加载器，使用和被代理对象相同的类加载器

      接口数组，和被代理对象实现相同的接口

      增强逻辑，自己提供，此处是一个InvocationHandler接口，需要写一个该接口的实现类，在其中调用selectList()方法

    */

    Proxy.newProxyInstance(类加载器, 接口数组，增强逻辑)；

}

单表CRUD

DML操作后要调用SqlSession.commit()方法进行事务提交

需要指定参数类型(实体类的全限定类名，基本类型可以用int,Integer,java.lang.Integer)

SQL语句传参时需要用#{实体类的属性值}，此处的属性值是setter方法的set后的字符串并首字母小写

保存 UserDao.saveUser(User user);

xml

<insert id="saveUser" parameterType="com.whteway.domain.User">

	insert into user(username, address, sex, birthday) values(#{id},#{username},#{password})

</insert>

更新 UserDao.updateUser(User user);

xml

<update id="updateUser" parameterType="com.whteway.domain.User">

	update user set username=#{username}, password#{password}) where id=#{id}

</insert>

注解

删除 UserDao.deleteUser(Integer userId);

xml

<delete id="deleteUser" parameterType="Integer">

	update from user where id=#{uid}

</delete>

查询单个 UserDao.findById(Integer id);

xml

<select id="findById" parameterType="INT" resultType="com.whteway.domain.User">

	select * from user where id=#{id}

</select>

查询多个 UserDao.findByName(String name);
- xml，传参的时候需要加%%（推荐，底层用的是PerparedStatement执行语句），不加%%可以使用固定写法 '%${value}%'（底层用的是Statement执行语句）
```
<select id="findByName" parameterType="string" resultType="com.whteway.domain.User">

	select * from user where username like #{name}

    /* select * from user where username like '%${value}' */

</select>
```

聚合函数 UserDao.findTotal();

xml

<select id="findTotal" resultType="int">

	select count(id) from user;

</select>

扩展

OGNL表达式
- Object Graphic Navigation Language 对象图导航语言
- 通过对象的取值方法来获取数据，省略get
  
  如：user.getUsername(); --> user.username
- mybatis中可以直接写username而不写user.，因为在parameterType中已经指定了类

根据自定义的条件类查询 UserDao.findByName(QueryVo vo); 设QueryVo中有属性User

xml

<select id="findByName" parameterType="com.whteway.domain.QueryVo" resultType="com.whteway.domain.User">

	select * from user where username like #{user.username}

</select>

获取保存数据的id
- sql中有一条语句"select last_insert_id();"可以返回上一条保存的记录的id，使用下面的配置后mybatis会将查出来的id值存入作为参数的user对象中
```
<insert ...>

	<selectKey keyProperty="id" keyColum="id" resultType="int" order="AFTER">

    	select last_insertid()

    </selectKey>

    insert ...

</insert>
```
返回值与列名的对应
- 返回值可以是基本类型，也可以是pojo（Plain Ordinary Java Object，普通java对象，即javaBeans）
- 当实体类属性和查询结果列名不一致时会导致数据无法封装进resultType中
  - 可以在sql语句中通过起别名的方式解决
  - 在映射配置文件中配置查询结果的列名和实体类属性名的对应关系，设User中有uid,name,pwd属性
```


<resultMap id="userMap" type="com.whteway.domain.User">

	<id property="uid" column="id"></id>

    <result property="name" column="username"></result>

    <result property="pwd" column="password"></result>

</resultMap>



<select id="findAll" resultMap="userMap">

    select * from user

</select>
```

自定义dao实现类完成CRUD

用session的不同方法执行sql语句，传入映射配置文件的namespace.SQL语句的id和sql需要的参数

selectOne，selectList，insert，update

public class UserDaoImpl implements UserDao{

    //只有第二步需要变化

    @Override

    public void saveUser(User user){

        //1.使用工厂创建SqlSession对象

        SqlSession session = factory.openSession();

        //2.使用session对象执行sql语句

        session.insert("com.whteway.dao.UserDao.saveUser", user);

        //3.释放资源

        session.close();

        //4.返回查询结果

        return;

    }

}

properties标签

配置properties，可以用标签配，也可以引用外部配置文件信息

resource属性，用于指定配置文件的位置，按照类路径的写法来写，并且必须存在于类路径下(放在和SqlMapConfig.xml相同路径下)

url属性，按照url的写法来写地址：协议://主机:端口 URI

<configuration>

    <properties resource="jdbcConfig.properties">

		<property name="driver" value="com.mysql.jdbc.Driver"/>

        <property name="url" value="jdbc:mysql://localhost:3306/db"/>

        <property name="username" value="root"/>

        <property name="password" value="root"/>

    </properties>

    <!-- 在实际配置中用"${driver}"取值 -->

</configuration>

typeAliases标签

配置别名，只能配置实体类的别名，当指定了别名就不再区分大小写

mybatis为基本类型和String配置了别名
```
<typeAliases>

	<typeAlias type="com.whteway.domain.User" alias="user"></typeAlias>

</typeAliases>
```
package标签

在typeAliases中使用：为整个包中的类配置别名，当指定之后，该包下的实体类都会以类名注册别名

在mappers中使用：指定dao接口所在的包，指定后，不需要再写resource或class了
```
<typeAliases>

	<package name="com.whteway.domain"></package>

</typeAliases>

<mappers>

	<package name="com.whteway.dao"></package>

</mappers>
```

动态SQL语句

if标签：满足条件则将标签内的语句拼接到sql语句后

<!-- 根据条件查询，传入的条件可能是id，也可能是username -->

<select id="findUserByCondition" resultMap="userMap" parameterType="user">

	select * from where 1=1

    <if test="username != null">and username=#{username}</if>

   	<if test="id != null">and id=#{id}</if>

</select>

where标签：sql后加 where 再将标签内的语句拼接到sql后

<!-- if标签代码改进 -->

<select id="findUserByCondition" resultMap="userMap" parameterType="user">

	select * from

    <where>

    	<if test="username != null">and username=#{username}</if>

    	<if test="id != null">and id=#{id}</if>

    </where>

</select>

foreach标签

循环将标签内部的语句和属性中的片段拼接到sql后

open属性：开始片段；close属性：结束片段；separator属性：每个元素的分割符

<!-- 根据queryvo中提供的id集合，查询用户信息 -->

<select id="findByIds" resultMap="userMap" parameterType="queryvo">

	select * from user

    <where>

    	<if test="ids != null and ids.size() > 0">

        	<foreach collection="ids" open="and id in (" close=")" item="id" separator=",">

            	#{id}

            </foreach>

        </if>

    </where>

</select>

sql标签

抽取重复的sql语句

<!-- 定义，末尾不要加分号 -->

<sql id="defaultUser">select * from user</sql>

<!-- 使用 -->

<select id="findUserByCondition" resultMap="userMap" parameterType="user">

	<include refid="defaultUser"></include>

    where id=#{id}

</select>

多表查询

关键在于SQL语句的编写，在实体类和映射配置中只能定义查询结果的封装

定义映射关系时，column属性的值是对应查询结果的列名的，如果有重复字段名，则需要在sql语句中使用别名，那么在resultMap中的column属性值也要与别名对应

一对多（Mybatis中把多对一当作一对一处理）

user(id, username, password)，account(id, uid, money);

User.java

public class User implements Serili{

    /* ... */

    //一对多关系映射，主表实体应该包含从表实体的集合引用

    private List<Account> accounts;

    /* getters and setters */

}

<resultMap id="userAccountMap" type="user">

    <!-- 普通属性的关系映射... -->

	<!-- 一对多的关系映射，查询时user.account.id需要取别名 -->

    <collection property="accounts" ofType="account">

    	<id column="aid" property="id"></id>

        <result column="uid" property="uid"></result>

        <result column="money" property="money"></result>

    </collection>

</resultMap>

Acount.java

public class Account implements Serializable{

    /* ... */

    //一对一关系映射，从表实体应该包含主表实体的对象引用

    private User user;

    /* getters and setters */

}

<resultMap id="accountUserMap" type="account">

	<!-- 普通属性的关系映射... -->

    <!-- 一对一的关系映射 -->

    <association property="user" column="uid" javaType="user">

    	<id column="id" property="id"></id>

        <result column="username" property="username"></result>

        <result column="password" property="password"></result>

    </association>

</resultMap>

多对多，需要使用中间表

user(id, username, password)，role(id, name)，user_role(uid, rid)；

在User类中加Role的集合roles，并在UserDao.xml中配置resultMap，使用collection标签配置roles

在Role类中加User的集合users，并在RoleDao.xml中配置resultMap，使用collection标签配置users

延迟加载

问题：一个用户有多个账户，在查询用户时，即使用了多表查询的sql语句，也可能用不到关联的帐户信息，这时候查询账户表浪费资源
延迟加载（按需加载，懒加载）

在真正使用数据时才发起查询，不用的时候不查询

比如：查询用户和账户时，输入的语句是，实际运行时，由于调用查询方法一定会有User对象或列表接收返回值，所以会立即"select * from user"，当用到user.accounts时，才会执行"select * from account where uid=?"
立即加载

只要调用方法，马上发起查询
方式选择

一对多、多对多：通常采用延迟加载，即有查询结果带集合时延迟

多对一、一对一：通常采用立即加载

配置开启延迟加载

<!-- SqlMapConfig.xml -->

<configuration>

    <settings>

    	<!-- 打开支持延迟加载开关 -->

		<setting name="lazyLoadingEnabled" value="true" />

    	<!-- 将积极(立即)加载改为消息(延迟)加载，3.4.2及之后默认为false，可以不配 -->

    	<Setting name="aggressiveLazyLoading" value="false" />

    </settings>

</configuration>

缓存

缓存：存在于内存中的数据

缓存可以减少和数据库的交互次数，提高执行效率
适用情况

适用：经常查询且不常改变的，数据的正确性对最终结果影响不大的

不适用：经常改变的，正确性对最终结果影响很大的，如汇率，股价等
Mybatis一级缓存
- 指SqlSession对象的缓存，当SqlSession对象消失时，缓存随之消失
- 当执行查询的结果会同时存入到SqlSession提供的一块区域中，该区域结构是一个Map，当查询时，mybatis会先去sqlsession中查询是否有对应数据，如果有则直接用
- Mybatis默认开启一级缓存
- 缓存Map的value是对象，所以两次查询得到的对象是同一个
- sqlSession.clearCache(); //不销毁sqlSession清空缓存
- 当执行DML时，会清空一级缓存

Mybatis二级缓存

指SqlSessionFactory对象的缓存

配置开启二级缓存（三步）

<!-- SqlMapConfig.xml -->

<configuration>

    <settings>

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

    </settings>

</configuration>

<!-- UserDao.xml -->

<mapper ...>

	<cache/>

    <select ... useCache="true"> ... </select>

</mapper>

二级缓存中存入的是数据，而不是对象，所以两次查询得到的对象不是同一个

注解开发

SqlMapConfig.xml 主配置文件不能省略

注意：只要使用注解开发，如果同时存在映射配置文件，即使mappper中指定了class属性，也会报错

<configuration>

	<!-- ... -->

    <!-- 指定带有注解的dao接口位置 -->

    <mappers>

    	<package name="com.whteway.dao"></package>

    </mappers>

</configuration>

CRUD注解，加在dao接口的方法上
- @Select("sql") 相当于select标签
- @Insert("sql") 相当于insert标签
- @Update("sql") 相当于update标签
- @Delete("sql") 相当于delete标签
映射关系注解
- @Results 相当于resultMap标签
- @Result 相当于result标签
- @ResultMap 相当于CRUD标签的resultMap属性
- 使用方式，@Results可以直接用在方法上(不用指定id属性)
  
  指定id属性后，其他方法可以用@ResultMap("resultsId")调用对应@Results
```
@Results(value={

    @Result(id="true", column="id", property="userId"),

    @Result(column="username", property="name"),

    @Result(column="password", property="psw")

})
```
多表查询的注解
- @One 指定一的一方，用在Result标签中
  
  select属性指向一个方法，该方法可以通过User主键查询User，该方法必须存在
  
  fetchType属性指定延迟加载策略，FetchType.DEFAULT()，FetchType.LAZY()，FetchType.EAGER()，
```
@Select("select * from account")

@Results(value={

    /* ... */

	@Result(column="uid", property="user", one=@One(select="com.whteway.UserDao.findById", fetchType=FetchType.EAGER))

})

List<Account> findAll();
```
- @Many 指定多的一方，用在Result标签中
  
  select属性指向一个方法，该方法可以通过User主键(Account的外键)查询所有符合条件的Account，该方法必须存在
  
  fetchType同@One
```
@Select("select * from user")

@Results(value={

    /* ... */

	@Result(column="id", property="accounts", many=@Many(select="com.whteway.AccountDao.findByUid", fetchType=FetchType.DEFAULT))

})

List<User> findAll();
```
注解开启二级缓存

@CacheNamespace(blocking = true) 用在Dao接口上

巴特西