Mybatis框架学习笔记（04）_实验04 mybatis框架:注解方法

Mybatis基于注解的开发

• Mybatis 也可以使用注解开发方式，这样我们就可以减少编写 Mapper 映射文件了（即：IUserDao.xml和IAccountDao.xml）。

01Mybatis的常用注解

@Insert:实现新增
@Update:实现更新
@Delete:实现删除
@Select:实现查询
@Result:实现结果集封装
@Results:可以与@Result 一起使用，封装多个结果集
@ResultMap:实现引用@Results 定义的封装
@One:实现一对一结果集封装
@Many:实现一对多结果集封装
@SelectProvider: 实现动态 SQL 映射
@CacheNamespace:实现注解二级缓存的使用
1
2
3
4
5
6
7
8
9
10
11

• 其中对应CRUD的注解为：Insert，Update，Select，Delete

02使用Mybatis注解实现CRUD

• 我们再次做的是单表的 CRUD 操作
  

2.1 新建maven工程（Mybatis）

• 坐标

<packaging>jar</packaging>

    <dependencies>
        <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.6</version>
        </dependency>

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
    </dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

2.2 数据库还是使用之前的数据库

• 在第一次笔记里面创建的myMybatis数据库

2.3 编写实体类（User.java）

• 注意：此处的实体列属性和数据库字段不是一一对应的
• 实体类要是实现Serializable接口，生成set和get方法，重写toString方法

private Integer userId;
private String userName;
private Date userBirthday;
private String userSex;
private String userAddress;
1
2
3
4
5

2.4 编写 SqlMapConfig 配置文件

<?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 文件的位置 -->
	<properties resource="jdbcConfig.properties"></properties>
	<!-- 配置别名的注册 -->
	<typeAliases>
		<package name="com.itheima.domain"/>
	</typeAliases>
	<!-- 配置环境 -->
	<environments default="mysql">
		<!-- 配置 mysql 的环境 -->
		<environment id="mysql">
			<!-- 配置事务的类型是 JDBC -->
			<transactionManager type="JDBC"></transactionManager>
			<!-- 配置数据源 -->
			<dataSource type="POOLED">
				<property name="driver" value="${jdbc.driver}"/>
				<property name="url" value="${jdbc.url}"/>
				<property name="username" value="${jdbc.username}"/>
				<property name="password" value="${jdbc.password}"/>
			</dataSource>
		</environment>
	</environments>
	<!-- 配置映射信息 -->
	<mappers>
		<package name="com.itheima.dao"/>
	</mappers>
</configuration>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

• 配置 dao 接口的位置，它有两种方式
  第一种：使用 mapper 标签配置 class 属性
  第二种：使用 package 标签，直接指定 dao 接口所在的包
• 注意：resource是用来配置xml文件的，当使用注解形式进行开发的时候接口的映射配置文件（IUserDao.xml）是不能存在的，如果存在会报错，因为Mybatis会不知道你要使用哪种形式进行映射（即使不配置class属性也会报错）

2.5db.properties和log4j.properties

• db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/myMybatis
jdbc.username=root
jdbc.password=12345678
1
2
3
4

• log4j.properties

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.6 使用注解方式配置持久层接口（重点在这里）

• 通过注解方式，我们就不需要再去编写 UserDao.xml 映射文件了
• IUserDao接口

public interface IUserDao {

   /*查询所有用户*/
    @Select("select * from user")
    //实现对结果集封装的配置，和xml中的resultMap标签功能一样
    @Results(id="userMap",
            value= {
                    @Result(id=true,column="id",property="userId"),
                    @Result(column="username",property="userName"),
                    @Result(column="sex",property="userSex"),
                    @Result(column="address",property="userAddress"),
                    @Result(column="birthday",property="userBirthday")
            })
    List<User> findAll();

    /*根据 id 查询一个用户*/
    @Select("select * from user where id = #{uid} ")
    //实现引用@Results 定义的封装
    @ResultMap("userMap")
    User findById(Integer userId);

    /*保存操作*/
    //先保存后查询
    @Insert("insert into user(username, sex, birthday, address)values(#{userName},#{userSex},#{userBirthday},#{userAddress})")
    @SelectKey(keyColumn = "id", keyProperty = "userId", resultType = Integer.class, before = false, statement = {"select last_insert_id()"})
    int saveUser(User user);

    /*更新操作*/
    @Update("update user set username=#{userName}, address =#{userAddress}, sex =#{userSex}, birthday =#{userBirthday}where id =#{userId}")
    int updateUser(User user);

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

    /*查询使用聚合函数*/
    @Select("select count(*) from user ")
    int findTotal();

    /*模糊查询*/
    @Select("select * from user where username like #{userName} ")
    List<User> findByName(String name);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

• 注意：我们配置的Results只能用来映射接收结果集，查询的时候value中的内容应该是类属性名（可参考Inset操作）

2.7编写测试类（UserTest.java）

public class UserTest {
    private InputStream in;
    private SqlSessionFactory factory;
    private SqlSession session;
    private IUserDao userDao;
    @Before//junit 的注解
    public void init()throws Exception{
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        factory = builder.build(in);
        //3.创建 session
        session = factory.openSession();
        //4.创建代理对象
        userDao = session.getMapper(IUserDao.class);
    }
    @After//junit 的注解
    public void destroy()throws Exception {
        //提交事务
        session.commit();
        //释放资源
        session.close();
        //关闭流
        in.close();
    }

    /**
     * 测试查询所有
     */
    @Test
    public void testFindAll() {
        List<User> users = userDao.findAll();
        for(User user : users) {
            System.out.println(user);
        }
    }
    /**
     * 测试查询一个
     */
    @Test
    public void testFindById() {
        User user = userDao.findById(41);
        System.out.println(user);
    }

    /**
     * 测试保存
     */
    @Test
    public void testSave() {
        User user = new User();
        user.setUserName("mybatis annotation");
        user.setUserSex("男");
        user.setUserAddress("北京市顺义区");
        user.setUserBirthday(new Date());
        int res = userDao.saveUser(user);
        System.out.println("影响数据库记录的行数： "+res);
        System.out.println("插入的主键值： "+user.getUserId());
    }

    /**
     * 测试更新
     */
    @Test
    public void testUpdate() {
        User user = userDao.findById(41);
        user.setUserBirthday(new Date());
        user.setUserSex("女");
        int res = userDao.updateUser(user);
        System.out.println(res);
    }
    /**
     * 测试删除
     */
    @Test
    public void testDelete() {
        int res = userDao.deleteUser(63);
        System.out.println(res);
    }
    /**
     * 测试查询使用聚合函数
     */
    @Test
    public void testFindTotal() {
        int res = userDao.findTotal();
        System.out.println(res);
    }
    /**
     * 测试模糊查询
     */
    @Test
    public void testFindByName() {
        List<User> users = userDao.findByName("%m%");
        for(User user : users) {
            System.out.println(user);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

03使用注解完成复杂的映射关系以及实现延时加载

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

3.1复杂映射关系的说明

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

@Resutl 注解
代替了 <id>标签和<result>标签

@Result 中属性介绍：
id 是否是主键字段
column 数据库的列名
property 需要装配的属性名
one 需要使用的@One 注解（@Result（one=@One）（）））
many 需要使用的@Many 注解（@Result（many=@many）（）））

@One 注解（一对一）
代替了<assocation>标签，是多表查询的关键，在注解中用来指定子查询返回单一对象。
@One 注解属性介绍：
select 指定用来多表查询的 sqlmapper
fetchType 会覆盖全局的配置参数 lazyLoadingEnabled。。
使用格式：
@Result(column=" ",property="",one=@One(select=""))

@Many 注解（多对一）
代替了<Collection>标签,是是多表查询的关键，在注解中用来指定子查询返回对象集合。
注意：聚集元素用来处理“一对多”的关系。需要指定映射的 Java 实体类的属性，属性的 javaType（一般为 ArrayList）但是注解中可以不定义；

使用格式：
@Result(property="",column="",many=@Many(select=""))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

3.2 复杂映射关系之一对一

• 需求：加载账户信息时并且加载该账户的用户信息（多对一），根据情况可实现延迟加载。（注解方式实现）
• 多对一关系映射：从表方应该包含一个主表方的对象引用
• 注意：多对一查询和一对一查询是一样的
  

3.2.1前景提要

• 其中依赖关系，db.properties，log4j.properties，SqlMapConfig.xml内容和前面的一样，
• 我们只需要把IAccounDao接口，IUserDao接口，User实体类，Account实体类中的内容改写即可

3.2.2 Account实体类

 private Integer id;
 private Integer uid;
 private Double money;
 //多对一关系映射：从表方应该包含一个主表方的对象引用
 private User user;  
1
2
3
4
5

3.2.2 User实体类

private Integer userId;
private String userName;
private Date userBirthday;
private String userSex;
private String userAddress;
1
2
3
4
5

3.2.3IAccounDao接口（重点）

One:相当于association的配置
select 属性：代表将要执行的 sql 语句
fetchType 属性：代表加载方式，一般如果要延迟加载都设置为 LAZY 的值

public interface IAccountDao {

    /**
     * 查询所有账户，采用延迟加载的方式查询账户的所属用户
     * @return
     */
    @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.aismall.dao.IUserDao.findById",
                                    fetchType=FetchType.LAZY
                            )
                    )
            })
    List<Account> findAll();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3.2.4 IUserDao接口（重点）

public interface IUserDao {
 @Results(id="userMap",
         value= {
                 @Result(id=true,column="id",property="userId"),
                 @Result(column="username",property="userName"),
                 @Result(column="sex",property="userSex"),
                 @Result(column="address",property="userAddress"),
                 @Result(column="birthday",property="userBirthday")
         })
 /**
  * 根据 id 查询一个用户
  * @param userId
  * @return
  */
 @Select("select * from user where id = #{uid} ")
 //@ResultMap("userMap")
 User findById(Integer userId);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3.2.5 AccountTest.java 测试类

public class AccountTest {
    private InputStream in;
    private SqlSessionFactory factory;
    private SqlSession session;
    private IAccountDao accountDao;

    @Before//junit 的注解
    public void init()throws Exception{
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        factory = builder.build(in);
        //3.创建 session
        session = factory.openSession();
        //4.创建代理对象
        accountDao = session.getMapper(IAccountDao.class);
    }
    @After//junit 的注解
    public void destroy()throws Exception {
        //提交事务
        session.commit();
        //释放资源
        session.close();
        //关闭流
        in.close();
    }

    @Test
    public void testFindAll() {
        List<Account> accounts = accountDao.findAll();
        for (Account account:accounts){
            System.out.println("------------");
            System.out.println(account);
            System.out.println(account.getUser());
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

3.3复杂映射关系之一对多

• 需求：查询用户信息时，也要查询他的账户列表。使用注解方式实现。
• 分析：一个用户具有多个账户信息，所以形成了用户(User)与账户(Account)之间的一对多关系。
• 一对多关系映射：主表方法应该包含一个从表方的集合引用
• 在一对一的基础上进行改写

3.3.1在User实体类中添加accounts属性

//一对多关系映射：主表方法应该包含一个从表方的集合引用
private List<Account> accounts;
1
2

3.3.2在IUserDao接口中添加映射

@Many:相当于xml中的collection的配置
select 属性：代表将要执行的 sql 语句
fetchType 属性：代表加载方式，一般如果要延迟加载都设置为 LAZY 的值

1.添加在@Results标签中的value里面

@Result(column="id",property="accounts",
                 many=@Many(
                         select="com.aismall.dao.IAccountDao.findByUid",
                         fetchType=FetchType.LAZY
                 )
         )

2.查询语句
 @Select("select * from user")
 @ResultMap("userMap")
 List<User> findAll();
1
2
3
4
5
6
7
8
9
10
11
12
13

3.3.3在IAccountDao接口中添加映射

 @Select("select * from account where uid = #{uid} ")
 List<Account> findByUid(Integer userId);
1
2

3.3.4UserTest.java测试类

public class UserTest {
    private InputStream in;
    private SqlSessionFactory factory;
    private SqlSession session;
    private IUserDao userDao;
    @Before//junit 的注解
    public void init()throws Exception{
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        factory = builder.build(in);
        //3.创建 session
        session = factory.openSession();
        //4.创建代理对象
        userDao = session.getMapper(IUserDao.class);
    }
    @After//junit 的注解
    public void destroy()throws Exception {
        //提交事务
        session.commit();
        //释放资源
        session.close();
        //关闭流
        in.close();
    }
    /**
     * 测试查询所有
     */
    @Test
    public void testFindAll() {
        List<User> users = userDao.findAll();
             for(User user : users) {
             System.out.println("-----每个用户的内容-----");
             System.out.println(user);
             System.out.println(user.getAccounts());
             }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

04Mybatis基于注解的二级缓存

4.1如何开启二级缓存（主配置文件中开启）

• 在 SqlMapConfig 中开启二级缓存支持

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

4.2 如何使用注解配置二级缓存（在持久层接口中配置）

@CacheNamespace(blocking=true)//mybatis 基于注解方式实现配置二级缓存
public interface IUserDao {}
1
2