1.Mybaits常用注解说明

    @Insert：实现新增

　　@Select：实现查询

　　@Update：实现更新

　　@Delete：实现删除

　　@Result：实现结果集的封装

　　@Results：可以与Result一起使用，实现多个结果集的封装

　　@ResultMap：实现引用@Results定义的封装

　　@One：实现一对一结果集的封装
　　@Many：实现一对多结果集的封装

　　@SelectProvider：实现动态SQL映射
　　@CacheNamespace：实现注解二级缓存的使用

1.1 使用Mybatis注解实现基本CRUD

package com.llb.domain;

import java.io.Serializable;
import java.util.Date;


public class User implements Serializable{

    private Integer userId;
    private String userName;
    private String userAddress;
    private String userSex;
    private Date userBirthday;
}

此处故意与数据库列名不一致

1.2 使用注解方式开发持久层接口

package com.llb.dao;

import com.llb.domain.User;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import java.util.List;

/**
 * 针对crud有四个注解
 * @Select, @Insert， @Update, @Delete
 * 
 */
public interface UserMapper {

    /**
     * 查询所有用户
     * @return
     */
    @Select("select * from user")
    List<User> findAll();

    /**
     * 保存用户
     */
    @Insert("insert into user(username, address, sex, birthday) values (#{username}, #{address}, #{sex}, #{birthday})")
    void saveUser(User user);

    /**
     * 更新用户
     */
    @Update("update user set username = #{username}, address = #{address}, sex= #{sex}, birthday = #{birthday} where id = #{id}")
    void updateUser(User user);

    /**
     * 删除用户
     */
    @Delete("delete from user where id = #{id}")
    void deleteUser(Integer id);

    /**
     * 根据id查询用户
     */
    @Select("select * from user where id = #{id}")
    User findUserById(Integer id);

    /**
     * 根据姓名模糊查询
     */
//    @Select("select * from user where username like #{username}")
    @Select("select * from user where username like '%${value}%'")
    List<User> findUserByUsername(String username);

    /**
     * 查询总用户数量
     */
    @Select("select count(*) from user")
    Integer findTotal();
}

通过此注解方式，我们就不需要再去编写UserMapper.xml映射文件了

##1.3 编写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>
    <!--引入外部配置文件-->
    <properties resource="jdbcConfig.properties"></properties>

    <!--配置别名-->
    <typeAliases>
        <package name="com.llb.domain"></package>
    </typeAliases>

    <!--配置环境-->
    <environments default="mysql">
        <!--配置MySQl环境-->
        <environment id="mysql">
            <!--配置事务类型为JDBC-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源-->
            <!--POOLED创建连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"></property>
                <property name="url" value="${jdbc.url}"></property>
                <property name="username" value="${jdbc.username}"></property>
                <property name="password" value="${jdbc.password}"></property>
            </dataSource>
        </environment>
    </environments>

    <!--指定带有注解的dao接口所在位置-->
    <mappers>
        <!-- 配置 dao 接口的位置，它有两种方式
        第一种：使用 mapper 标签配置 class 属性
        第二种：使用 package 标签，直接指定 mapper 接口所在的包
        -->
        <!--<mapper class="com.llb.dao.UserMapper"></mapper>-->
        <package name="com.llb.dao"></package>
    </mappers>

</configuration>

1.4 编写测试方法

package com.llb.test;
/**
 * 
 */
public class AnnotationCRUD {

    InputStream in ;
    SqlSessionFactory factory;
    SqlSession sqlSession;
    UserMapper mapper;

    @Before
    public void init() throws IOException {
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        factory = new SqlSessionFactoryBuilder().build(in);
        sqlSession = factory.openSession();
        mapper = sqlSession.getMapper(UserMapper.class);
    }

    @After
    public void destroy() throws IOException {
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }

    /**
     * 测试注解保存用户
     */
    @Test
    public void testInsert(){
        User user = new User();
        user.setUsername("王五");
        user.setAddress("浙江杭州");
        user.setSex("男");
        user.setBirthday(new Date());
        mapper.saveUser(user);
    }

    /**
     * 测试注解修改用户
     */
    @Test
    public void testUpdate(){
        User user = new User();
        user.setId(53);
        user.setUsername("王五");
        user.setAddress("浙江杭州");
        user.setSex("男");
        user.setBirthday(new Date());
        mapper.updateUser(user);
    }

    /**
     * 测试注解删除用户
     */
    @Test
    public void testDelete(){
        mapper.deleteUser(53);
    }

    /**
     * 根据id查询用户
     */
    @Test
    public void testFindUserById(){
        User user = mapper.findUserById(41);
        System.out.println(user);
    }
    /**
     * 根据姓名模糊查询用户
     */
    @Test
    public void testFindUserByName(){
        List<User> users = mapper.findUserByUsername("%张%");
        for (User user: users) {
            System.out.println(user);
        }
    }

    /**
     * 总条数
     */
    @Test
    public void findTotal(){
        Integer total = mapper.findTotal();
        System.out.println(total);
    }

}

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

实现复杂关系映射开发之前我们可以在映射文件中通过配置<resultMap>来实现，在使用注解开发时，我们需要借助@Result、@Results、@One、@Many

2.1 复杂关系映射的注解说明

@Results 注解
代替的标签是<resultMap>
该注解中可以使用单个@Result，也可以使用@Results集合
@Results（{@Result（），@Result（）}）或@Results（@Result（））

@Result注解
代替了<id>和<result>标签
@Result中的属性介绍：
　　id 是否是主键字段
　　column 数据库的列名
　　property 需要装配的属性名
　　one 需要使用@One注解(@Result(one = @One()))
　　many 需要使用@Many注解(@Result(many = @Many()))

@One注解(一对一)
　　代替了<association>标签，是表查询的关键，在注解中用来指定子查询返回单一对象。
　　属性介绍：
　　　　select 指定用来多表查询的SqlMapper
　　　　fetchType 会覆盖全局的配置参数lazyLoadingEnabled。
　　使用格式：
　　　　@Result(column="", prperty="", one=@One(select=""))
@Many注解(一对多)
　　代替了<collection>标签，是多表查询的关键，在注解中用来指定子查询返回对象集合。
　　注意：聚集元素用来处理“一对多”的关系。需要指定映射的 Java 实体类的属性，属性的 javaType（一般为 ArrayList）但是注解中可以不定义；
　　
　　使用格式：
　　　　　　@Result(property="",column="",many=@Many(select=""))

2.2 使用注解实现一对一复杂关系映射延迟加载

需求：加载账户信息时并且加载该账户的用户信息，根据情况可实现延迟加载。（注解方式）

2.2.1 添加User实体类及Account实体类

用户实体类：

package com.llb.domain;

import java.io.Serializable;
import java.util.Date;
import java.util.List;

/**
 * 
 */
public class User implements Serializable {

    private Integer userId;
    private String userName;
    private String userAddress;
    private String userSex;
    private Date userBirthday;

}

账户实体类：

package com.llb.domain;

import java.io.Serializable;

/**
 * 账户的实体类
 * 
 */
public class Account implements Serializable {

    private Integer id;
    private Integer uid;
    private double money;

    //从表实体应该包含一个主表实体的对象引用
    private User user;

}

2.2.2 添加账户的持久层接口并使用注解配置

package com.llb.dao;import java.util.List;

/**
 * 
 */
public interface AccountMapper {


    /**
     * 多对一：立即加载
     * 查询账户所对应的的用户
     * FetchType.EAGER:立即加载
     *
     */
    @Select("select * from account")
    @Results(id = "accountMap", value={
            @Result(id = true, column = "id", property = "id"),
            @Result(column = "uid", property = "uid"),
            @Result(column = "money", property = "money"),
            @Result(column = "uid", property = "user", one = @One(select = "com.llb.dao.UserMapper.findUserById", fetchType = FetchType.EAGER)),

    })
    List<Account> findAllAccount();
}

2.2.3 测试一对一关联及延迟加载

package com.llb.test;
/**
 * 
 */
public class AccountCRUD {

    InputStream in ;
    SqlSessionFactory factory;
    SqlSession sqlSession;
    AccountMapper mapper;

    @Before
    public void init() throws IOException {
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        factory = new SqlSessionFactoryBuilder().build(in);
        sqlSession = factory.openSession();
        mapper = sqlSession.getMapper(AccountMapper.class);
    }

    @After
    public void destroy() throws IOException {
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }

    /**
     * 查询账户所对应的用户
     */
    @Test
    public void findAllAccount(){
        List<Account> accounts = mapper.findAllAccount();
        for (Account account: accounts) {
            System.out.println(account);
        }
    }
}

3. 使用注解实现一对多复杂关系映射

需求：查询用户信息时，也要查询他的账户列表。使用注解方式实现。
分析：一个用户具有多个账户信息，所以形成了用户(User)与账户(Account)之间的一对多关系。

3.1 User实体类加入List<Account>

package com.llb.domain;

import java.io.Serializable;
import java.util.Date;
import java.util.List;

/**
 * 
 */
public class User implements Serializable {

    private Integer userId;
    private String userName;
    private String userAddress;
    private String userSex;
    private Date userBirthday;
　　//一对多关系映射：主表方法应该包含一个从表方的集合引用
private List<Account> accounts;

}

##3.2 编写用户的持久层接口并使用注解配置

package com.llb.dao;

import com.llb.domain.User;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.mapping.FetchType;

import java.util.List;

/**
 * 针对crud有四个注解
 * @Select, @Insert， @Update, @Delete
 * 
 */

//开启二级缓存
@CacheNamespace(blocking = true)
public interface UserMapper {

    /**
     * 查询所有用户
     * @return
     */
    @Select("select * from user")
    @Results(id = "userMap", value ={
            @Result(column = "id", property = "userId"),
            @Result(column = "username", property = "userName"),
            @Result(column = "sex", property = "userSex"),
            @Result(column = "birthday", property = "userBirthday"),
            @Result(column = "address", property = "userAddress"),
            @Result(column = "id", property = "accounts",
            many = @Many(select = "com.llb.dao.AccountMapper.findAccountByUid", fetchType = FetchType.LAZY)
            )
    })
    List<User> findAll();

    /**
     * 根据id查询用户
     */
    @Select("select * from user where id = #{id}")
    @ResultMap(value = {"userMap"})
    User findUserById(Integer id);

    /**
     * 根据姓名模糊查询
     */
//    @Select("select * from user where username like #{username}")
    @Select("select * from user where username like '%${value}%'")
    List<User> findUserByUsername(String username);

}

3.3 编写账户的持久层接口并使用注解配置

package com.llb.dao;

import com.llb.domain.Account;
import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.mapping.FetchType;

import java.util.List;

/**
 * 
 */
public interface AccountMapper {
/**
     * 根据用户id查询账户
     * @return
     */
    @Select("select * from account where uid = #{uid}")
    List<Account> findAccountByUid(Integer uid);

}

3.4 添加测试方法

package com.llb.test;


/**
 * 
 */
public class AnnotationCRUD {

    InputStream in ;
    SqlSessionFactory factory;
    SqlSession sqlSession;
    UserMapper mapper;

    @Before
    public void init() throws IOException {
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        factory = new SqlSessionFactoryBuilder().build(in);
        sqlSession = factory.openSession();
        mapper = sqlSession.getMapper(UserMapper.class);
    }

    @After
    public void destroy() throws IOException {
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }

    /**
     * 查询所有
     */
    @Test
    public void testFindAll(){
        List<User> users = mapper.findAll();
        for (User user:users) {
            System.out.println(user);
        }
    }

}

像大多数的持久化框架一样，Mybatis 也提供了缓存策略，通过缓存策略来减少数据库的查询次数，从而提高性能。Mybatis 中缓存分为一级缓存，二级缓存

1. Mybatis一级缓存

image.png

1.1 证明一级缓存的存在
　　　　一级缓存是session级别的缓存，只要sqlSession没有flush或者close，它就存在。无需配置

1.1.1 编写用户持久层接口

/**
 * 用户的持久层接口
 * 
 */
public interface UserMapper {
    /**
     * 根据id查询用户
     * @return
     */
    User findUserById(int id);

}

1.1.2 编写用户持久层映射文件

<?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.llb.dao.UserMapper">
    <!--useCache-->
    <select id="findUserById" resultType="user" parameterType="int" useCache="true">
        select * from user where id = #{id}
    </select>
</mapper>

1.1.3 编写测试方法

package com.llb.test;

/**
 * 
 */
public class UserTest {

    InputStream in = null;
    UserMapper mapper = null;
    SqlSession sqlSession = null;
    SqlSessionFactory factory = null;
    /**
     * 在测试方法执行前执行
     * @throws IOException
     */
    @Before
    public void init() throws IOException {
        //1.读取配置文件，生成字节流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取sqlSessionFactory对象
        factory = new SqlSessionFactoryBuilder().build(in);
        //3.获取sqlSession对象
        sqlSession = factory.openSession();
        //4.获取dao的代理对象
        mapper = sqlSession.getMapper(UserMapper.class);
    }

    /**
     * 测试方法执行后执行
     * @throws IOException
     */
    @After
    public void destory() throws IOException {
        sqlSession.commit();
        //6.释放资源
        sqlSession.close();
        in.close();
    }
    /**
     * 根据id查询用户，sqlSession一级缓存:
     *  当调用sqlSession的修改、添加、删除，commit() ,close()，clear()等方法时，会清空缓存
     */
    @Test
    public void findUserById(){
        User user = mapper.findUserById(41);

        User user2 = mapper.findUserById(41);

        System.out.println(user == user2);
    }

}

image.png

我们虽然查询了两次，但最后只查询了一次数据库，这就是Mybatis提供给我们得一级缓存起作用。因为一级缓存的存在，导致第二次查询id为41的记录时，并没有发出sql语句从数据库中查询数据，而是从一级缓存中查询。

1.1.2 一级缓存的分析

一级缓存是SqlSession范围的缓存，当调用SqlSession的修改、添加、删除时、commit、close等方法就会清空缓存。

image.png

第一次发起查询用户 id 为 1 的用户信息，先去找缓存中是否有 id 为 1 的用户信息，如果没有，从数据库查询用户信息。
　　得到用户信息，将用户信息存储到一级缓存中。
　　如果 sqlSession 去执行 commit 操作（执行插入、更新、删除），清空 SqlSession 中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。
　　第二次发起查询用户 id 为 1 的用户信息，先去找缓存中是否有 id 为 1 的用户信息，缓存中有，直接从缓存中获取用户信息。

2.1.3 测试一级缓存的清空

/**
     * 根据id查询用户，sqlSession一级缓存:
     *  当调用sqlSession的修改、添加、删除，commit() ,close()，clear()等方法时，会清空缓存
     */
    @Test
    public void findUserById(){
        User user = mapper.findUserById(41);

        //关闭sqlSession会清空缓存
        sqlSession.close();
        sqlSession = factory.openSession();
        mapper = sqlSession.getMapper(UserMapper.class);

        //直接对sqlSession进行清空
//        sqlSession.clearCache();

        User user2 = mapper.findUserById(41);

        System.out.println(user == user2);
    }

image.png

当执行sqlSession.close()后，再次获取sqlSession并查询id=41的User对象时，又重新执行了sql 语句，从数据库进行了查询操作。导致两个用户的地址不一致。

2. Mybatis二级缓存（XML方式）

二级缓存是mapper映射级别的缓存，多个sqlSession去操作同一个mapper映射的sql语句，多个sqlSession可以共用二级缓存，二级缓存是跨sqlSession的。

2.1 二级缓存的结构图

image.png

首先开启Mybatis的二级缓存。
　　　　sqlSession1去查询用户信息，查询到用户信息会将查询数据存储到二级缓存中。
　　　　当sqlSession2去查询同个用户信息时，首先会去二级缓存中查找是否存在数据，如果存在直接从缓存中取出数据。
　　　　如果sqlSession3去执行相同mapper映射下sql，执行commit提交，将会清空该mapper映射下的二级缓存区域的数据。

2.2 二级缓存的开启与关闭

###2.2.1 第一步：在SqlMapConfig.xml文件开启二级缓存

<!--开启二级缓存,默认值为true，默认开启-->
    <settings>
        <setting name="cacheEnabled" value="true"/>
    </settings>
　###2.2.2 第二部：配置相关的Mapper映射文件
<cache>标签表示当前这个mapper映射将使用二级缓存，区分就看namespace的值<?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.llb.dao.UserMapper">

    <!--开启user支持二级缓存-->
    <cache/>
</mapper>

2.2.3 第三步：配置statement上面的useCache属性

Mybatis缓存

<?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.llb.dao.UserMapper">

    <!--开启user支持二级缓存-->
    <cache/>
    <!--useCache，对该方法使用二级缓存-->
    <select id="findUserById" resultType="user" parameterType="int" useCache="true">
        select * from user where id = #{id}
    </select>
</mapper>　　注意：针对每次查询都需要最新数据的sql，要设置成useCache=false，禁用二级缓存。

2.2.3 二级缓存测试

package com.llb.test;
/**
 * 
 */
public class SecondLevelCache {

    InputStream in = null;
    SqlSessionFactory factory = null;
    /**
     * 在测试方法执行前执行
     * @throws IOException
     */
    @Before
    public void init() throws IOException {
        //1.读取配置文件，生成字节流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取sqlSessionFactory对象
        factory = new SqlSessionFactoryBuilder().build(in);
    }

    /**
     * 测试方法执行后执行
     * @throws IOException
     */
    @After
    public void destory() throws IOException {

        in.close();
    }


    /**
     * 根据id查询用户，二级缓存：
     *      存放的是数据，而不是对象
     */
    @Test
    public void findUserById(){

        SqlSession sqlSession = factory.openSession();
        UserMapper mapper1 = sqlSession.getMapper(UserMapper.class);

        User user1 = mapper1.findUserById(41);

        System.out.println(user1);

        //关闭缓存
        sqlSession.close();

        SqlSession sqlSession2 = factory.openSession();
        UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);

        User user2 = mapper2.findUserById(41);

        System.out.println(user2);

        System.out.println(user1 == user2);
    }
}

image.png

　经过上面测试，我们发现执行了两次查询，并且在第一次查询后关闭了一级缓存，再去执行二级缓存时，我们发现并没有对数据库发出SQL语句，所以此时的数据就只能来自二级缓存

2.2.4 二级缓存注意事项

当我们在使用二级缓存时，所缓存的类一定要实现java.io.Serializable接口，这种就可以使用序列化方式保存对象package com.llb.domain;
import java.io.Serializable;

/**
 * 
 */
public class User implements Serializable{

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

3. 使用注解实现二级缓存

##3.1 在SqlMapConfig中开启二级缓存支持

<!-- 配置二级缓存 --> <settings>
<!-- 开启二级缓存的支持 --> 　　<setting name="cacheEnabled" value="true"/>
</settings>

3.2 在持久层接口中使用注解配置二级缓存

package com.llb.dao;
import java.util.List;

//开启二级缓存
@CacheNamespace(blocking = true)
public interface UserMapper {

}