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 {

}

mybatis注解开发

mybatis注解开发

1.Mybaits常用注解说明

1.1 使用Mybatis注解实现基本CRUD

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

1.4 编写测试方法

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

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

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

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

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

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

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

3.1 User实体类加入List<Account>

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

3.4 添加测试方法

1. Mybatis一级缓存

1.1.1 编写用户持久层接口

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

1.1.3 编写测试方法

1.1.2 一级缓存的分析

2.1.3 测试一级缓存的清空

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

2.1 二级缓存的结构图

2.2 二级缓存的开启与关闭

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

2.2.3 二级缓存测试

2.2.4 二级缓存注意事项

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

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