1.mybatis中的连接池

配置的位置:  主配置文件SqlMapConfig.xml中的dataSource标签,type属性就是用来表示采用何种连接方式

mybatis连接池提供了3种方式的配置:

  • UNPOOLED: 不使用连接池的数据源 (采用传统获取连接的方式,虽然也实现了javax.sql.DataSource接口,但是并没有使用池的思想)
  • POOLED  : 使用连接池的数据源  (采用传统的javax.sql.DataSource规范中的连接池,mybatis中有针对规范的实现)
  • JNDI : 使用 JNDI 实现的数据源  (采用服务器提供的JNDI技术实现,来获取DataSource对象,不同的服务器所能拿到的DataSource对象是不一样的,注意:如果不是web或者maven的war工程,是不能使用的)

2.mybatis中的事务

2.1.什么是事务

事务是数据库操作的最小工作单元,是作为单个逻辑工作单元执行的一系列操作;这些操作作为一个整体一起向系统提交,要么都执行、要么都不执行;事务是一组不可再

分割的操作集合(工作逻辑单元);

2.2.事物的四大特性ACID

事务具有四个特征,分别足原子性(Atomicity )、一致性(Consistency )、隔离性(Isolation) 和持久性(Durability),简称为事务的ACID特性。

2.2.1.原子性(Atomicity )

事务的原子性是指事务必须是一个原子的操作序列单元。事务中包含的各项操作在一次执行过程中,只允许出现以下两种状态之一。

•  全部成功执行。
•  全部不执行。

2.2.2.一致性(Consistency )

事务的一致性是指事务的执行不能破坏数据库数据的完整性和一致性,一个事务在执行之前和执行之后,数据库都必须处于一致性状态。也就是说,事务执行的结果必须是使

数据库从一个一致性状态转变到另一个一致性状态,因此当数据库只包含成功事务提交 的结果时,就能说数据库处于一致性状态。而如果数据库系统在运行过程中发生故障,

有些事务尚未完成就被迫中断,这些未完成的事务对数据库所做的修改有一部分已写入物理数据库,这时数据库就处于一种不正确的状态,或者说是不一致的状态。

2.2.3.隔离性(Isolation)

事务的隔离性是指在并发环境中,并发的事务是相互隔离的,一个事务的执行不能被其他事务干扰。也就是说,不同的事务并发操纵相同的数据时,每个事务都有各自完整的

数据空间,即一个事务内部的操作及使用的数据对其他并发事务是隔离的,并发执行的 各个事务之间不能互相干扰。

2.2.4.持久性(Durability)

事务的持久性也被称为永久性,是指一个事务一旦提交,它对数据库中对应数据的状态变更就应该是永久性的。换句话说,一旦某个事务成功结束,那么它对数据库所做的更

新就必须被永久保存下来——即使发生系统崩溃或机器宕机等故障,只要数据库能够重新启动,那么一定能够将其恢复到事务成功结束时的状态。

2.3.不考虑隔离性会产生的3个问题

当多个线程都开启事务操作数据库中的数据时,数据库系统要能进行隔离操作,以保证各个线程获取数据的准确性,如果不考虑事务的隔离性,会发生以下几种问题:

2.3.1脏读

脏读是指在一个事务处理过程里读取了另一个未提交的事务中的数据。

当一个事务正在多次修改某个数据,而在这个事务中这多次的修改都还未提交,这时一个并发的事务来访问该数据,就会造成两个事务得到的数据不一致。

2.3.2.不可重复读

不可重复读是指在对于数据库中的某个数据,一个事务范围内多次查询却返回了不同的数据值,这是由于在查询间隔,被另一个事务修改并提交了。

例如事务T1在读取某一数据,而事务T2立马修改了这个数据并且提交事务给数据库,事务T1再次读取该数据就得到了不同的结果,发送了不可重复读。

不可重复读和脏读的区别是,脏读是某一事务读取了另一个事务未提交的脏数据,而不可重复读则是读取了前一事务提交的数据。

在某些情况下,不可重复读并不是问题,比如我们多次查询某个数据当然以最后查询得到的结果为主。但在另一些情况下就有可能发生问题,例如对于同一个数据A和B依

次查询就可能不同,A和B就可能打起来了……

2.3.3.虚读(幻读)

幻读是事务非独立执行时发生的一种现象。例如事务T1对一个表中所有的行的某个数据项做了从“1”修改为“2”的操作,这时事务T2又对这个表中插入了一行数据项,而这

个数据项的数值还是为“1”并且提交给数据库。而操作事务T1的用户如果再查看刚刚修改的数据,会发现还有一行没有修改,其实这行是从事务T2中添加的,就好像产生幻觉一

样,这就是发生了幻读。

幻读和不可重复读都是读取了另一条已经提交的事务(这点就脏读不同),所不同的是不可重复读查询的都是同一个数据项,而幻读针对的是一批数据整体(比如数据的

个数)。

参考链接:https://www.cnblogs.com/songanwei/p/9387526.html

2.4.mybatis中的事务是通过sqlsession对象的commit方法和rollback方法实现事务的提交和回滚

两种提交方式:

手动提交:在关闭连接之前执行sqlsession.commit()方法手动提交

自动提交:

3.mybatis的动态SQL语句

3.1.动态SQL之<if>标签

我们根据实体类的不同取值,使用不同的 SQL 语句来进行查询。比如在 id 如果不为空时可以根据 id 查询, 如果 username 不同空时还要加入用户名作为条件。这种情

况在我们的多条件组合查询中经常会碰到。

3.1.1.持久层 Dao 接口

  1. /**
  2.  
  3. 根据用户信息,查询用户列表
  4.  
  5. @param user
  6.  
  7. @return
  8.  
  9. */
  10.  
  11. List<User> findByUser(User user);

3.1.2. 映射配置文件

  1. <select id="findByUser" resultType="user" parameterType="user">
  2. select * from user where 1=1
  3. <if test="username!=null and username != '' ">
  4. and username like #{username}
  5. </if>
  6. <if test="address != null">
  7. and address like #{address}
  8. </if>
  9. </select>

​注意:<if>标签的 test 属性中写的是对象的属性名,如果是包装类的对象要使用 OGNL 表达式的写法。 另外要注意 where 1=1 的作用~!

3.1.3.测试

  1. @Test
  2. public void testFindByUser() {

  3. User u = new User();
  4.  
  5. u.setUsername("%王%");
  6.  
  7. u.setAddress("%顺义%");
  8.  
  9. //执行操作
  10.  
  11. List<User> users = userDao.findByUser(u);
  12.  
  13. for(User user : users) {
  14.  
  15. System.out.println(user);
  16.  
  17. }
  18. }

3.2.动态 SQL 之<where>标签

为了简化上面 where 1=1 的条件拼装,我们可以采用<where>标签来简化开发。

3.2.1.持久层 Dao 映射配置

  1. <!-- 根据用户信息查询 -->

    <select id="findByUser" resultType="user" parameterType="user">

  2. <include refid="defaultSql"></include>

  3. <where>

  4. <if test="username!=null and username != '' ">

  5. and username like #{username}

  6. </if>

  7. <if test="address != null">

  8. and address like #{address}

  9. </if>

  10. </where>

  11. </select>

3.3.动态标签之<foreach>标签

3.3.1.实体类编写

  1. public class QueryVo implements Serializable {
  2.  
  3. private List<Integer> ids
  4.  
  5. public List<Integer> getIds() {
  6.  
  7. return ids;
  8.  
  9. }
  10.  
  11. public void setIds(List<Integer> ids) {
  12.  
  13. this.ids = ids;
  14.  
  15. }
  16.  
  17. }

3.3.2.持久层 Dao 接口

  1. List<User> findInIds(QueryVo vo);

3.3.3.持久层 Dao 映射配置

  1. <!-- 查询所有用户在 id 的集合之中 -->

  2. <select id="findInIds" resultType="user" parameterType="queryvo">

  3. <!-- select * from user where id in (1,2,3,4,5); -->

  4. <include refid="defaultSql"></include>

  5. <where>

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

  7. <foreach collection="ids" open="id in ( " close=")" item="uid" separator=","> #{uid}

  8. </foreach>

  9. </if>

  10. </where>

  11. </select>           

<foreach>标签用于遍历集合,它的属性:

collection:代表要遍历的集合元素,注意编写时不要写#{}

open:代表语句的开始部分

close:代表结束部分

item:代表遍历集合的每个元素,生成的变量名

sperator:代表分隔符

3.3.4.编写测试方法

  1. @Test
  2.  
  3. public void testFindInIds() {
  4.  
  5. QueryVo vo = new QueryVo();
  6.  
  7. List<Integer> ids = new ArrayList<Integer>();
  8.  
  9. ids.add(41);
  10.  
  11. ids.add(42);
  12.  
  13. ids.add(43);
  14.  
  15. ids.add(46);
  16.  
  17. ids.add(57);
  18.  
  19. vo.setIds(ids);
  20.  
  21. //执行操作
  22.  
  23. List<User> users = userDao.findInIds(vo);
  24.  
  25. for(User user : users) {
  26.  
  27. System.out.println(user);
  28.  
  29. }
  30. }

4.Mybatis 中简化编写的 SQL 片段

Sql 中可将重复的 sql 提取出来,使用时用 include 引用即可,最终达到 sql 重用的目的。

4.1定义代码片段

  1. <!-- 抽取重复的语句代码片段 -->
  2. <sql id="defaultSql">
  3. select * from user
  4. </sql>

4.2.引用代码片段

  1. <!-- 配置查询所有操作 -->

  2. <select id="findAll" resultType="user">

  3. <include refid="defaultSql"></include>

  4. </select>

  5. <!-- 根据 id 查询 -->

  6. <select id="findById" resultType="UsEr" parameterType="int">
  7.  
  8. <include refid="defaultSql"></include>

  9. where id = #{uid}

  10. </select>

5.mybatis的多表查询

表之间的关系严格来说有四种:一对多、多对一、一对一、多对多

举例:

用户和订单就是一对多

订单和用户就是多对一

一个用户可以下多个订单

多个订单属于同一个用户

人和身份证号就是一对一

一个人只能拥有一个省份证号

一个身份证号只能属于一个人

老师和学生就是多对多

一个学生可以被多个老师教过

一个老师可以教多个学生

特例:

如果拿出每一个订单,他都只能属于一个用户

所以mybatis就把多对一看成了一对一

一对多、多对一实例:用户和账户

一个用户可以有多个账户

一个账户只能属于一个用户(多个账户也可以属于同一个用户)

步骤:

  1. 建立两张表,用户表,账户表

让用户表和账户表之间具备一对一的关系:需要使用外键,在账户表中添加

  1. 建立两个实体类:用户实体类和账户实体类

让用户和账户的实体类也能体现出一对多的关系

3.建立两个配置文件

用户的配置文件和账户的配置文件

4.实现配置

当查询用户时,可以同时得到用户下所包含的账户信息

当查询账户时,可以同时得到账户的所属用户信息

多对多示例:用户和角色

一个用户可以有多个角色

一个角色可以赋予多个用户

步骤:

  1. 建立两张表,用户表,角色表

让用户表和角色表之间具备多对多的关系:需要使用中间表,中间表中包含各自的主键,在中间表是外键

  1. 建立两个实体类:用户实体类和账户实体类

让用户和角色的实体类也能体现出多对多的关系

各自包含对方一个集合引用

3.建立两个配置文件

用户的配置文件和角色的配置文件

4.实现配置

当查询用户时,可以同时得到用户下所包含的角色信息

当查询角色时,可以同时得到角色的所赋予用户信息

5.1.Mybatis 多表查询之多对一(一对一)

5.1.1.

需求:   查询所有账户信息,关联查询下单用户信息。

注意: 因为一个账户信息只能供某个用户使用,所以从查询账户信息出发关联查询用户信息为一对一查询。

如果从用户信息出发查询用户下的账户信息则为一对多查询,因为一个用户可以有多个账户。

5.1.2.方式一:

5.1.2.1.账户信息的实体类

  1. public class Account implements Serializable {
  2.  
  3. private Integer id;
  4.  
  5. private Integer uid;
  6.  
  7. private Double money;
  8.  
  9. public Integer getId() {
  10.  
  11. return id; }
  12.  
  13. public void setId(Integer id) {
  14.  
  15. his.id = id; }
  16.  
  17. public Integer getUid() {
  18.  
  19. return uid;
  20.  
  21. }
  22.  
  23. public void setUid(Integer uid) {
  24.  
  25. this.uid = uid;
  26.  
  27. }
  28.  
  29. public Double getMoney() {
  30.  
  31. return money;
  32.  
  33. }
  34.  
  35. public void setMoney(Double money) {
  36.  
  37. this.money = money;
  38.  
  39. }
  40.  
  41. @Override
  42. public String toString() {
  43.  
  44. return "Account [id=" + id + ", uid=" + uid + ", money=" + money + "]";
  45.  
  46. }
  47.  
  48. }

5.1.2.2.编写 Sql 语句

实现查询账户信息时,也要查询账户所对应的用户信息。

  1. SELECT
  2.  
  3. account.*,
  4.  
  5. user.username,
  6.  
  7. user.address
  8.  
  9. FROM
  10.  
  11. account,
  12.  
  13. user
  14.  
  15. WHERE account.uid = user.id

5.1.2.3.定义 AccountUser 类

为了能够封装上面 SQL 语句的查询结果,定义 AccountCustomer 类中要包含账户信息同时还要包含用户信息,所以我们要在定义 AccountUser 类时可以继承 User 类。

  1. public class AccountUser extends Account implements Serializable {
  2. private String username;
  3.  
  4. private String address;
  5.  
  6. public String getUsername() {
  7.  
  8. return username;
  9.  
  10. }
  11.  
  12. public void setUsername(String username) {
  13.  
  14. this.username = username;
  15.  
  16. }
  17.  
  18. public String getAddress() {
  19.  
  20. return address;
  21.  
  22. }
  23.  
  24. public void setAddress(String address) {
  25.  
  26. this.address = address;
  27.  
  28. }
  29.  
  30. @Override
  31.  
  32. public String toString() {
  33.  
  34. return super.toString() + " AccountUser [username=" + username + ", address=" + address + "]";
  35.  
  36. }
  37.  
  38. }

5.1.2.4.定义账户的持久层 Dao 接口

  1. public interface IAccountDao {
  2.  
  3. List<AccountUser> findAll();
  4.  
  5. }

5.1.2.5.定义配置文件AccountDao.xml 文件中的查询配置信息

  1. <?xml version="1.0" encoding="UTF-8"?>
  2.  
  3. <!DOCTYPE mapper
  4.  
  5. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  6.  
  7. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  8.  
  9. <mapper namespace="com.itheima.dao.IAccountDao">
  10.  
  11. <!-- 配置查询所有操作-->
  12. <select id="findAll" resultType="accountuser">
  13.  
  14. select a.*,u.username,u.address from account a,user u where a.uid =u.id;
  15.  
  16. </select>
  17. </mapper>

注意:因为上面查询的结果中包含了账户信息同时还包含了用户信息,所以我们的返回值类型 returnType 的值设置为 AccountUser 类型,这样就可以接收账户信息和用户信息了。

5.1.2.6.创建 AccountTest 测试类

  1. @Test
  2.  
  3. public void testFindAll() {
  4.  
  5. // 执行操作
  6.  
  7. List<AccountUser> accountusers = accountDao.findAll();

    for(AccountUser au : accountusers) {
  8.  
  9. System.out.println(au);
  10.  
  11. }

5.1.2.7.小结:

定义专门的 po 类作为输出类型,其中定义了 sql 查询结果集所有的字段。此方法较为简单,企业中使用普 遍。

5.1.3.方法二

使用 resultMap,定义专门的 resultMap 用于映射一对一查询结果。

通过面向对象的(has a)关系可以得知,我们可以在 Account 类中加入一个 User 类的对象来代表这个账户是哪个用户的

5.1.3.1修改 Account 类

在 Account 类中加入 User 类的对象作为 Account 类的一个属性。

  1. public class Account implements Serializable {
  2.  
  3. private Integer id;
  4.  
  5. private Integer uid;
  6.  
  7. private Double money;
  8.  
  9. private User user; //从表实体应该包含一个主表实体的对象引用
  10.  
  11. public User getUser() {
  12.  
  13. return user;
  14.  
  15. }
  16.  
  17. public void setUser(User user) {
  18.  
  19. this.user = user;
  20.  
  21. }
  22.  
  23. public Integer getId() {
  24.  
  25. return id;
  26.  
  27. }
  28.  
  29. public void setId(Integer id) {
  30.  
  31. this.id = id;
  32.  
  33. }
  34.  
  35. public Integer getUid() {
  36.  
  37. return uid;
  38.  
  39. }
  40.  
  41. public void setUid(Integer uid) {
  42.  
  43. this.uid = uid;
  44.  
  45. }
  46.  
  47. public Double getMoney() {
  48.  
  49. return money;
  50.  
  51. }
  52.  
  53. public void setMoney(Double money) {
  54.  
  55. this.money = money;
  56.  
  57. }
  58.  
  59. @Override
  60.  
  61. public String toString() {
  62.  
  63. return "Account [id=" + id + ", uid=" + uid + ", money=" + money + "]";
  64.  
  65. }
  66.  
  67. }

5.1.3.2.修改 AccountDao 接口中的方法

  1. public interface IAccountDao {
  2.  
  3. /**
  4.  
  5. 查询所有账户,同时获取账户的所属用户名称以及它的地址信息 * @return
  6.  
  7. */
  8.  
  9. List<Account> findAll();
  10. }

注意:第二种方式,将返回值改 为了 Account 类型。 因为 Account 类中包含了一个 User 类的对象,它可以封装账户所对应的用户信息。

5.1.3.3.重新定义 AccountDao.xml 文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2.  
  3. <!DOCTYPE mapper
  4.  
  5. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  6.  
  7. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  8.  
  9. <mapper namespace="com.itheima.dao.IAccountDao">
  10.  
  11. <!-- 建立对应关系 -->
  12.  
  13. <resultMap type="account" id="accountMap">
  14.  
  15. <id column="aid" property="id"/>
  16.  
  17. <result column="uid" property="uid"/>
  18.  
  19. <result column="money" property="money"/>
  20.  
  21. <!-- 它是用于指定从表方的引用实体属性的 -->
  22.  
  23. <association property="user" javaType="user">
  24.  
  25. <id column="id" property="id"/>
  26.  
  27. <result column="username" property="username"/>
  28.  
  29. <result column="sex" property="sex"/>
  30.  
  31. <result column="birthday" property="birthday"/>
  32.  
  33. <result column="address" property="address"/>
  34.  
  35. </association>
  36.  
  37. </resultMap>

  38. <select id="findAll" resultMap="accountMap">   

    select u.*,a.id as aid,a.uid,a.money from account a,user u where a.uid =u.id; 

    </select>
    </mapper> 

5.1.3.4.在 AccountTest 类中加入测试方法

  1. @Test
  2.  
  3. public void testFindAll() {
  4.  
  5. List<Account> accounts = accountDao.findAll();
  6.  
  7. for(Account au : accounts) {
  8.  
  9. System.out.println(au);
  10.  
  11. System.out.println(au.getUser());
  12.  
  13. }
  14.  
  15. }

5.2.多表查询之一对多查询

5.2.1.

需求: 查询所有用户信息及用户关联的账户信息。

分析: 用户信息和他的账户信息为一对多关系,并且查询过程中如果用户没有账户信息,此时也要将用户信息 查询出来,我们想到了左外连接查询比较合适。

5.2.2.编写 SQL 语句

  1. SELECT
  2. u.*, acc.id id,
  3. acc.uid,
  4. acc.money
  5. FROM
  6. user u
  7. LEFT JOIN account acc ON u.id = acc.uid

5.2.3.User 类加入 List<Account>

  1. public class User implements Serializable {
  2.  
  3. private Integer id;
  4.  
  5. private String username;
  6.  
  7. private Date birthday;
  8.  
  9. private String sex;
  10.  
  11. private String address;
  12.  
  13. //一对多关系映射:主表实体应该包含从表实体的集合引用
  14.  
  15. private List<Account> accounts;
  16.  
  17. public List<Account> getAccounts() {
  18.  
  19. return accounts;
  20.  
  21. }
  22.  
  23. public void setAccounts(List<Account> accounts) {
  24.  
  25. this.accounts = accounts;
  26.  
  27. }
  28.  
  29. public Integer getId() {
  30.  
  31. return id;
  32.  
  33. }
  34.  
  35. public void setId(Integer id) {
  36.  
  37. this.id = id;
  38.  
  39. }
  40.  
  41. public String getUsername() {
  42.  
  43. return username;
  44.  
  45. }
  46.  
  47. public void setUsername(String username) {
  48.  
  49. this.username = username;
  50.  
  51. }
  52.  
  53. public Date getBirthday() {
  54.  
  55. return birthday;
  56.  
  57. }
  58.  
  59. public void setBirthday(Date birthday) {
  60.  
  61. this.birthday = birthday;
  62.  
  63. }
  64.  
  65. public String getSex() {
  66.  
  67. return sex;
  68.  
  69. }
  70.  
  71. public void setSex(String sex) {
  72.  
  73. this.sex = sex;
  74.  
  75. }
  76.  
  77. public String getAddress() {
  78.  
  79. return address;
  80.  
  81. }
  82.  
  83. public void setAddress(String address) {
  84.  
  85. this.address = address;
  86.  
  87. }
  88.  
  89. @Override
  90.  
  91. public String toString() {
  92.  
  93. return "User [id=" + id + ", username=" + username + ", birthday=" + birthday + ", sex=" + sex + ", address=" + address + "]";
  94. }
  95.  
  96. }

5.2.4.用户持久层 Dao 接口中加入查询方法

  1. /**
  2.  
  3. 查询所有用户,同时获取出每个用户下的所有账户信息
  4.  
  5. * @return
  6.  
  7. */
  8.  
  9. List<User> findAll();

5.2.5.用户持久层 Dao 映射文件配置

  1. <?xml version="1.0" encoding="UTF-8"?>
  2.  
  3. <!DOCTYPE mapper
  4.  
  5. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  6.  
  7. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  8.  
  9. <mapper namespace="com.itheima.dao.IUserDao">
  10.  
  11. <resultMap type="user" id="userMap">
  12.  
  13. <id column="id" property="id"></id>
  14.  
  15. <result column="username" property="username"/>
  16.  
  17. <result column="address" property="address"/>
  18.  
  19. <result column="sex" property="sex"/>
  20.  
  21. <result column="birthday" property="birthday"/>
  22.  
  23. <!-- collection 是用于建立一对多中集合属性的对应关系 ofType 用于指定集合元素的数据类型 -->
  24.  
  25. <collection property="accounts" ofType="account">
  26.  
  27. <id column="aid" property="id"/>
  28.  
  29. <result column="uid" property="uid"/>
  30.  
  31. <result column="money" property="money"/>
  32.  
  33. </collection>

  34. </resultMap>
  35.  
  36. <!-- 配置查询所有操作 -->
  37.  
  38. <select id="findAll" resultMap="userMap">
  39.  
  40. select u.*,a.id as aid ,a.uid,a.money from user u left outer join account a on u.id =a.uid
  41.  
  42. </select>
  43. </mapper>

collection:

部分定义了用户关联的账户信息。表示关联查询结果集

property="accList" :

关联查询的结果集存储在 User 对象的上哪个属性。

ofType="account" :

指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名,也可以使用全限定名。

5.2.6.测试方法

  1. @Test
  2.  
  3. public void testFindAll() {
  4.  
  5. //执行操作
  6.  
  7. List<User> users = userDao.findAll();
  8.  
  9. for(User user : users) {
  10.  
  11. System.out.println("-------每个用户的内容---------");
  12. System.out.println(user);
  13.  
  14. System.out.println(user.getAccounts());
  15.  
  16. }
  17.  
  18. }

5.3.Mybatis 多表查询之多对多

通过前面的学习,我们使用 Mybatis 实现一对多关系的维护。多对多关系其实我们看成是双向的一对多关 系。

5.3.1.实现 Role 到 User 多对多

5.3.1.1.

需求: 实现查询所有对象并且加载它所分配的用户信息。

分析: 查询角色我们需要用到Role表,但角色分配的用户的信息我们并不能直接找到用户信息,而是要通过中 间表(USER_ROLE 表)才能关联到用户信息。

下面是实现的 SQL 语句:

  1. SELECT
  2. r.*,u.id uid,
  3. u.username username,
  4. u.birthday birthday,
  5. u.sex sex,
  6. u.address address
  7. FROM
  8. ROLE r
  9. INNER JOIN
  10. USER_ROLE ur
  11. ON ( r.id = ur.rid)
  12. INNER JOIN
  13. USER u
  14. ON (ur.uid = u.id);

5.3.1.2.编写角色实体类

  1. public class Role implements Serializable {
  2. private Integer roleId;
  3. private String roleName;
  4. private String roleDesc;
  5. //多对多的关系映射:一个角色可以赋予多个用户
  6. private List<User> users;
  7.  
  8. public List<User> getUsers() {
  9. return users; }
  10.  
  11. public void setUsers(List<User> users) {
  12. this.users = users; }
  13.  
  14. public Integer getRoleId() {
  15. return roleId; }
  16.  
  17. public void setRoleId(Integer roleId) {
  18. this.roleId = roleId; }
  19.  
  20. public String getRoleName() {
  21. return roleName; }
  22.  
  23. public void setRoleName(String roleName) {
  24. this.roleName = roleName; }
  25.  
  26. public String getRoleDesc() {
  27. return roleDesc; }
  28.  
  29. public void setRoleDesc(String roleDesc) {
  30. this.roleDesc = roleDesc; }
  31.  
  32. @Override public String toString() {
  33. return "Role{"+" roleId=" + roleId +", roleName='" + roleName + '\'' +", roleDesc='" + roleDesc + '\'' +'}';
  34. }
  35. }

5.3.1.3.编写 Role 持久层接口

  1. public interface IRoleDao {
  2. /**
  3. * 查询所有角色
  4. * @return
  5. */
  6. List<Role> findAll();
  7. }

5.3.1.4.编写映射文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper
  3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.itheima.dao.IRoleDao">
  6. <!--定义 role 表的 ResultMap-->
  7. <resultMap id="roleMap" type="role">
  8. <id property="roleId" column="rid"></id>
  9. <result property="roleName" column="role_name"></result>
  10. <result property="roleDesc" column="role_desc"></result>
  11. <collection property="users" ofType="user">
  12. <id column="id" property="id"></id>
  13. <result column="username" property="username"></result>
  14. <result column="address" property="address"></result>
  15. <result column="sex" property="sex"></result>
  16. <result column="birthday" property="birthday"></result>
  17. </collection>
  18. </resultMap>
  19.  
  20. <!--查询所有-->
  21. <select id="findAll" resultMap="roleMap">
  22. select u.*,r.id as rid,r.role_name,r.role_desc from role r
  23. left outer join user_role ur on r.id = ur.rid left outer join user u on u.id = ur.uid
  24. </select>
  25. </mapper>

5.3.1.5.编写测试类

  1. @Test
  2.  
  3. public void testFindAll(){
  4.  
  5. List<Role> roles = roleDao.findAll();
  6.  
  7. for(Role role : roles){
  8.  
  9. System.out.println("---每个角色的信息----");
  10.  
  11. System.out.println(role);
  12.  
  13. System.out.println(role.getUsers());
  14. }
  15. }
  16. }

5.3.2.实现 User 到 Role 的多对多

从 User 出发,我们也可以发现一个用户可以具有多个角色,这样用户到角色的关系也还是一对多关系。这样 我们就可以认为 User 与 Role 的多对多关系,可以被拆解成两个一对多关系来实现。

mybatis学习日记2的更多相关文章

  1. mybatis学习日记-day01

    Mybatis说明: MyBatis 使用简单的 XML或注解用于配置和原始映射,将接口和 Java 的POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的 ...

  2. MyBatis学习日记(一):拜见小主——MyBatis

    近日学习MyBatis,特将学习过程及一点心得记录于此. MyBatis为何物? MyBatis 是支持定制化SQL.存储过程以及高级映射的优秀的持久层框架.MyBatis 避免了几乎所有的 JDBC ...

  3. MyBatis学习日记(三):戏说MyBatis配置文件

    properties标签 properties标签可以用来加载别的配置文件,比如可以加载数据库的配置文件,jdbc.properties. 下面是jdbc.properties jdbc.driver ...

  4. MyBatis学习日记(二): MyBatis Say Hello

    首先在Eclipse中创建一个maven工程: 在maven工程下的pom.xml文件中添加MyBatis.MySQL.Junit依赖: <project xmlns="http:// ...

  5. Linux学习日记-使用EF6 Code First(四)

    一.在linux上使用EF 开发环境 VS2013+mono 3.10.0 +EF 6.1.0 先检测一下EF是不是6的 如果不是  请参阅 Linux学习日记-EF6的安装升级(三) 由于我的数据库 ...

  6. MyBatis学习总结(二)——使用MyBatis对表执行CRUD操作(转载)

    本文转载自:http://www.cnblogs.com/jpf-java/p/6013540.html 上一篇博文MyBatis学习总结(一)--MyBatis快速入门中我们讲了如何使用Mybati ...

  7. MyBatis学习总结(八)——Mybatis3.x与Spring4.x整合(转载)

      孤傲苍狼 只为成功找方法,不为失败找借口! MyBatis学习总结(八)--Mybatis3.x与Spring4.x整合 一.搭建开发环境 1.1.使用Maven创建Web项目 执行如下命令: m ...

  8. MyBatis学习总结(七)——Mybatis缓存(转载)

      孤傲苍狼 只为成功找方法,不为失败找借口! MyBatis学习总结(七)--Mybatis缓存 一.MyBatis缓存介绍 正如大多数持久层框架一样,MyBatis 同样提供了一级缓存和二级缓存的 ...

  9. (原创)mybatis学习二,spring和mybatis的融合

    mybatis学习一夯实基础 上文介绍了mybatis的相关知识,这一节主要来介绍mybaits和spring的融合 一,环境搭建 1,jar包下载,下载路径为jar包 2,将包导入到java工程中 ...

  10. (原创)mybatis学习一,夯实基础

    一,what?(是什么) MyBatis是一个支持普通SQL查询,存储过程和高级映射的优秀持久层框架.MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的检索封装.MyBatis可 ...

随机推荐

  1. Go语言核心36讲44

    今天,我们来讲另一个与I/O操作强相关的代码包bufio.bufio是"buffered I/O"的缩写.顾名思义,这个代码包中的程序实体实现的I/O操作都内置了缓冲区. bufi ...

  2. Seata 1.5.2 源码学习(Client端)

    在上一篇中通过阅读Seata服务端的代码,我们了解到TC是如何处理来自客户端的请求的,今天这一篇一起来了解一下客户端是如何处理TC发过来的请求的.要想搞清楚这一点,还得从GlobalTransacti ...

  3. oracle常用查看命令

    select sum(bytes/1024/1024/1024) from dba_segments;   #注:查看表空间大小,除以3个1024后的大小为GB du instance_name(实例 ...

  4. 记录下批处理bat脚本获取打包发布问题

    最近做了个Jenkins配合Gitlab自动部署Java项目到Windows Server服务器. Jenkins和Gitlab在Linux下,好一顿折腾,先记录下脚本,其余后续补充吧. 把Java项 ...

  5. 关于linux mint更改资源管理器的快捷键

    前言 首先要知道 linux mint 的默认资源管理器是 nemo 我很不习惯 ctrl+d 在nemo里面是 收藏到侧边栏 我习惯 ctrl+d 在windows上是删除文件 所以下面我就修改这个 ...

  6. [Kogel.Subscribe.Mssql]SQL Server增量订阅,数据库变更监听

    此框架是SQL Server增量订阅,用来监听增删改数据库数据变更 目前仅支持SQL Server,Nuget上可以下载安装 或者使用Nuget命令添加包 dotnet add package Kog ...

  7. elasticsearch 聚合之 date_histogram 聚合

    目录 1.背景 2.bucket_key如何计算 3.前置知识 4.日历和固定时间间隔 4.1 Calendar intervals 日历间隔 4.2 Fixed intervals 固定间隔 5.数 ...

  8. 【Flume】概述及组成、入门案例、进阶(事务、拓扑结构)、不同拓扑案例、自定义、数据流监控Ganglia

    一.概述 1.定义 日志采集.聚合.传输的系统,基于流式结构 即:读取本地磁盘数据,写入HDFS或kafka 2.架构 Agent:JVM进程,以事件形式将数据送到目的地. Agent由三部分组成:S ...

  9. 快速入门JavaScript编程语言

    目录 JS简介 JS基础 1.注释语法 2.引入js的多种方式 3.结束符号 变量与常量 let和var的区别 申明常量 const 严格模式 use strict 基本数据类型 1.数值类型(Num ...

  10. PyTorch复现GoogleNet学习笔记

    PyTorch复现GoogleNet学习笔记 一篇简单的学习笔记,实现五类花分类,这里只介绍复现的一些细节 如果想了解更多有关网络的细节,请去看论文<Going Deeper with Conv ...