目录
第一章：Mybatis 连接池与事务
1.1-Mybatis连接池
Mybatis 连接池的分类
- UNPOOLED 不使用连接池的数据源
- POOLED 使用连接池的数据源
- JNDI 使用 JNDI 实现的数据源
三种数据源中，我们一般采用的是 POOLED 数据源
Mybatis 中数据源的配置
我们的数据源配置就是在 SqlMapConfig.xml 文件中，具体配置如下：
<!-- 配置数据源（连接池）信息 -->
<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>
MyBatis 在初始化时，根据的 type 属性来创建相应类型的的数据源 DataSource，即：
type=”POOLED”：MyBatis 会创建 PooledDataSource 实例
type=”UNPOOLED” ： MyBatis 会创建 UnpooledDataSource 实例
type=”JNDI”：MyBatis 会从 JNDI 服务上查找 DataSource 实例，然后返回使用
1.2-Mybatis 的事务控制
JDBC事务回顾
在 JDBC 中我们可以通过手动方式将事务的提交改为手动方式，通过 setAutoCommit()方法就可以调整。 通过 JDK 文档，我们找到该方法如下：
Mybatis 框架因为是对 JDBC 的封装，所以 Mybatis 框架的事务控制方式，本身也是用 JDBC 的 setAutoCommit()方法来设置事务提交方式的。
Mybatis事务控制
通过SqlSessionFactory工厂对象创建SqlSession对象时可以设置是否自动提交，设置如下：
SqlSession openSession(); // 不自动提交
SqlSession openSession(boolean var1); // 布尔值为true时，事务自动提交
SqlSession对象中提供方法实现提交事务
void commit(); // 提交事务
void rollback(); // 事务回滚
第二章：Mybatis 的动态 SQL 语句
Mybatis 的映射文件中，前面我们的 SQL 都是比较简单的。但有些时候业务逻辑复杂时，我们的 SQL 是动态变化的。此时Mybatis，也提供了相应的解决方案。需要我们在dao.xml配置文件中，通过指定的标签来实现sql语句的动态变化。
2.1-<if>标签
需求
我们根据实体类的不同取值，使用不同的 SQL 语句来进行查询。比如在 id 如果不为空时可以根据 id 查询， 如果 username 不同空时还要加入用户名作为条件。这种情况在我们的多条件组合查询中经常会碰到。
持久层 Dao 接口
/**
* 根据用户信息，查询用户列表
* @param user
* @return
*/
List<User> findByUser(User user);
持久层 Dao 映射配置
<select id="findByUser" resultType="user" parameterType="user">
select * from user where 1=1
<if test="username!=null and username != \'\' ">
and username like #{username}
</if>
<if test="address != null">
and address like #{address}
</if>
</select>
<!--注意：<if>标签的 test 属性中写的是对象的属性名，如果是包装类的对象要使用 OGNL 表达式的写法。
另外要注意 where 1=1 的作用~！-->
测试
public void testFindByUser() {
User u = new User();
u.setUsername("%王%");
u.setAddress("%北京%");
List<User> users = userDao.findByUser(u);
for(User user : users) {
System.out.println(user);
}
}
2.2-<where>标签
为了简化上面 where 1=1 的条件拼装，我们可以采用标签来简化开发。
<!-- 根据用户信息查询 -->
<select id="findByUser" resultType="user" parameterType="user">
select * from user
<where>
<if test="username!=null and username != \'\' ">
and username like #{username}
</if>
<if test="address != null">
and address like #{address}
</if>
</where>
</select>
2.3-<foreach>标签
需求
传入多个 id 查询用户信息，用下边两个 sql 实现： SELECT * FROM USERS WHERE username LIKE \'%张%\' AND (id =10 OR id =89 OR id=16) 或 SELECT * FROM USERS WHERE username LIKE \'%张%\' AND id IN (10,89,16) 这样我们在进行范围查询时，就要将一个集合中的值，作为参数动态添加进来。 这样我们将如何进行参数的传递？
在 QueryVo 中加入一个 List 集合用于封装参数
public class QueryVo {
private User user;
private List ids;
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public List getIds() {
return ids;
}
public void setIds(List ids) {
this.ids = ids;
}
}
持久层 Dao 接口
/**
* 根据 id 集合查询用户
* @param vo
* @return
*/
List<User> findInIds(QueryVo vo);
持久层 Dao 映射配置
<!-- 查询所有用户在 id 的集合之中 -->
<select id="findInIds" resultType="user" parameterType="queryvo">
<!-- select * from user where id in (1,2,3,4,5); -->
select * from user
<where>
<if test="ids != null and ids.size() > 0">
<foreach collection="ids" open="id in ( " close=")" item="uid" separator=",">
#{uid}
</foreach>
</if>
</where>
</select>
<!--
SQL 语句：
select 字段 from user where id in (?)
<foreach>标签用于遍历集合，它的属性：
collection:代表要遍历的集合元素，注意编写时不要写#{}
open:代表语句的开始部分
close:代表结束部分
item:代表遍历集合的每个元素，生成的变量名
sperator:代表分隔符
-->
测试
@Test
public void testFindInIds() {
QueryVo vo = new QueryVo();
List<Integer> ids = new ArrayList<Integer>();
ids.add(41);
ids.add(42);
ids.add(43);
ids.add(46);
ids.add(57);
vo.setIds(ids);
//6.执行操作
List<User> users = userDao.findInIds(vo);
for(User user : users) {
System.out.println(user);
}
}
2.4-Mybatis 编写的 SQL 片段
Sql 中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的
定义代码片段
<!-- 抽取重复的语句代码片段 -->
<sql id="defaultSql">
select * from user
</sql>
调用代码片段
<!-- 配置查询所有操作 -->
<select id="findAll" resultType="user">
<include refid="defaultSql"></include>
</select>
<!-- 根据 id 查询 -->
<select id="findById" resultType="UsEr" parameterType="int">
<include refid="defaultSql"></include>
where id = #{uid}
</select>
第三章：Mybatis 多表查询之多对一
3.1-需求
本次案例主要以最为简单的用户和账户的模型来分析 Mybatis 多表关系。用户为 User 表，账户为Account 表。一个用户（User）可以有多个账户（Account）。具体关系如下：
需求 查询所有账户信息，关联查询下单用户信息。
注意： 因为一个账户信息只能供某个用户使用，所以从查询账户信息出发关联查询用户信息为一对一查询。
如 果从用户信息出发查询用户下的账户信息则为一对多查询，因为一个用户可以有多个账户。
3.2-数据库脚本
/*
SQLyog Ultimate v12.09 (64 bit)
mysql - 5.5.40 : Database - db7
*********************************************************************
*/
CREATE DATABASE /*!32312 IF NOT EXISTS*/`db7` /*!40100 DEFAULT CHARACTER SET utf8 */;
USE `db7`;
/*Table structure for table `account` */
DROP TABLE IF EXISTS `account`;
CREATE TABLE `account` (
`ID` int(11) NOT NULL COMMENT \'编号\',
`UID` int(11) DEFAULT NULL COMMENT \'用户编号\',
`MONEY` double DEFAULT NULL COMMENT \'金额\',
PRIMARY KEY (`ID`),
KEY `FK_Reference_8` (`UID`),
CONSTRAINT `FK_Reference_8` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*Data for the table `account` */
insert into `account`(`ID`,`UID`,`MONEY`) values (1,1,111),(2,1,2222),(3,2,6666),(4,1,2321),(5,2,65656),(6,4,8888);
/*Table structure for table `user` */
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(32) DEFAULT NULL,
`birthday` date DEFAULT NULL,
`sex` varchar(22) DEFAULT NULL,
`address` varchar(32) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=19 DEFAULT CHARSET=utf8;
/*Data for the table `user` */
insert into `user`(`id`,`username`,`birthday`,`sex`,`address`) values (1,\'张三丰\',\'2018-12-12\',\'male\',\'海南\'),(2,\'李四\',\'2019-09-04\',\'female\',\'南京\'),(3,\'王五\',\'2020-02-12\',\'male\',\'北京\'),(4,\'赵六\',\'2020-01-01\',\'female\',\'上海\'),(18,NULL,NULL,NULL,NULL);
3.3-方式1
定义账户信息的实体类
public class Account implements Serializable {
private int id;
private int uid;
private double money;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getUid() {
return uid;
}
public void setUid(int uid) {
this.uid = uid;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", uid=" + uid +
", money=" + money +
\'}\';
}
}
编写 Sql 语句
# 实现查询账户信息时，也要查询账户所对应的用户信息。
SELECT
account.*,
user.username,
user.address
FROM
account,
USER
WHERE account.uid = user.id
在 MySQL 中测试的查询结果如下：
定义 AccountUser 类
为了能够封装上面 SQL 语句的查询结果，定义 AccountCustomer 类中要包含账户信息同时还要包含用户信 息，所以我们要在定义 AccountUser 类时可以继承 Account 类。
public class AccountUser extends Account implements Serializable {
private String username;
private String address;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return super.toString()+"AccountUser{" +
"username=\'" + username + \'\\\'\' +
", address=\'" + address + \'\\\'\' +
\'}\';
}
}
定义账户的持久层 Dao 接口
public interface IAccountDao {
/**
* 查询所有账户，同时获取账户的所属用户名称以及它的地址信息
* @return
*/
List<AccountUser> findAll();
}
定义 IAccountDao.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="cn.lpl666.dao.IAccountDao">
<select id="findAll" resultType="AccountUser">
SELECT account.*, user.username, user.address FROM account, USER WHERE account.uid = user.id
</select>
</mapper>
创建 AccountTest 测试类
public class AccountTest {
private static InputStream is;
private static SqlSession sqlSession;
private static IAccountDao dao;
@Before
public void init(){
// 读取配置文件
try {
is = Resources.getResourceAsStream("SqlMapConfig.xml");
// 创建工厂构建者对象
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
// 创建SqlSessionFactory工厂对象
SqlSessionFactory sqlSessionFactory = builder.build(is);
// 创建SqlSession对象
sqlSession = sqlSessionFactory.openSession();
// 创建dao代理对象
dao = sqlSession.getMapper(IAccountDao.class);
} catch (IOException e) {
e.printStackTrace();
}
}
@After
public void destroy() throws IOException {
sqlSession.commit();
is.close();
sqlSession.close();
}
/**
* 查询
*/
@Test
public void getAll() throws IOException {
List<AccountUser> all = dao.findAll();
for (AccountUser accountUser : all) {
System.out.println(accountUser);
}
}
}
定义专门的 po 类作为输出类型，其中定义了 sql 查询结果集所有的字段。此方法较为简单，企业中使用普 遍。
3.2-方式2
使用 resultMap，定义专门的 resultMap 用于映射一对一查询结果。 通过面向对象的(has a)关系可以得知，我们可以在 Account 类中加入一个 User 类的对象来代表这个账户 是哪个用户的。
修改 Account 类
在 Account 类中加入 User 类的对象作为 Account 类的一个属性
public class Account implements Serializable {
private int id;
private int uid;
private double money;
private User user;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getUid() {
return uid;
}
public void setUid(int uid) {
this.uid = uid;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", uid=" + uid +
", money=" + money +
", user=" + user.toString() +
\'}\';
}
}
修改 AccountDao 接口中的方法
public interface IAccountDao {
/**
* 查询所有账户，同时获取账户的所属用户名称以及它的地址信息
* @return
*/
List<Account> findAll();
}
// 注意：第二种方式，将返回值改 为了 Account 类型。
// 因为 Account 类中包含了一个 User 类的对象，它可以封装账户所对应的用户信息
重新定义 IAccountDao.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="cn.lpl666.dao.IAccountDao">
<!-- 建立对应关系 -->
<resultMap id="AccountMap" type="Account">
<id property="id" column="aid"></id>
<result property="uid" column="uid"></result>
<result property="money" column="money"></result>
<!-- 它是用于指定从表方的引用实体属性的 -->
<association property="user" javaType="User">
<id property="id" column="id"></id>
<result property="username" column="username"></result>
<result property="birthday" column="birthday"></result>
<result property="sex" column="sex"></result>
<result property="address" column="address"></result>
</association>
</resultMap>
<select id="findAll" resultMap="AccountMap">
SELECT a.`id` AS aid,a.`uid`,a.`money`,u.* FROM account AS a, USER AS u WHERE a.uid = u.id
</select>
</mapper>
在 AccountTest 类中加入测试方法
public class Account implements Serializable {
private int id;
private int uid;
private double money;
private User user;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getUid() {
return uid;
}
public void setUid(int uid) {
this.uid = uid;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", uid=" + uid +
", money=" + money +
", user=" + user.toString() +
\'}\';
}
}
第四章：Mybatis 多表查询之一对多
4.1-需求
需求： 查询所有用户信息及用户关联的账户信息。 分析： 用户信息和他的账户信息为一对多关系，并且查询过程中如果用户没有账户信息，此时也要将用户信息 查询出来，我们想到了左外连接查询比较合适。
数据库脚本同上
4.2-编写Sql语句
SELECT * FROM
USER
LEFT JOIN
account
ON user.`id`=account.`uid`
4.3-User实体类
public class User implements Serializable {
private int id;
private String username;
private String birthday;
private String sex;
private String address;
private List<Account> accountList;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getBirthday() {
return birthday;
}
public void setBirthday(String birthday) {
this.birthday = birthday;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username=\'" + username + \'\\\'\' +
", birthday=" + birthday +
", sex=\'" + sex + \'\\\'\' +
", address=\'" + address + \'\\\'\' +
\'}\';
}
public List<Account> getAccountList() {
return accountList;
}
public void setAccountList(List<Account> accountList) {
this.accountList = accountList;
}
}
4.4-IUserDao 接口中加入查询方法
public interface IUserDao {
/**
* 查询所有用户信息（包含用户所拥有的账户列表）
* @return
*/
List<User> findAll();
}
4.5-IUserDao 映射文件配置
<?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="cn.lpl666.dao.IUserDao">
<resultMap id="UserMap" type="User">
<id property="id" column="id"></id>
<result property="sex" column="sex"></result>
<result property="username" column="username"></result>
<result property="address" column="address"></result>
<result property="birthday" column="birthday"></result>
<result property="address" column="address"></result>
<!--
collection 是用于建立一对多中集合属性的对应关系
ofType 用于指定集合元素的数据类型
-->
<collection property="accountList" ofType="Account">
<id column="aid" property="id"></id>
<result column="money" property="money"></result>
<result column="uid" property="uid"></result>
</collection>
</resultMap>
<!--查询所有用户-->
<select id="findAll" resultMap="UserMap">
SELECT User.*,a.`id` AS aid,a.`money`,a.`uid` FROM USER LEFT OUTER JOIN account AS a ON user.`id`=a.`uid`
</select>
</mapper>
collection 部分定义了用户关联的账户信息。表示关联查询结果集
property="accountList"： 关联查询的结果集存储在 User 对象的上哪个属性。
ofType="Account"： 指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名。
4.6-测试类
public class UserTest {
private static InputStream is;
private static SqlSession sqlSession;
private static IUserDao dao;
@Before
public void init(){
// 读取配置文件
try {
is = Resources.getResourceAsStream("SqlMapConfig.xml");
// 创建工厂构建者对象
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
// 创建SqlSessionFactory工厂对象
SqlSessionFactory sqlSessionFactory = builder.build(is);
// 创建SqlSession对象
sqlSession = sqlSessionFactory.openSession();
// 创建dao代理对象
dao = sqlSession.getMapper(IUserDao.class);
} catch (IOException e) {
e.printStackTrace();
}
}
@After
public void destroy() throws IOException {
sqlSession.commit();
is.close();
sqlSession.close();
}
/**
* 查询
*/
@Test
public void getAll() throws IOException {
List<User> all = dao.findAll();
for (User user : all) {
System.out.println(user);
List<Account> list = user.getAccountList();
for (Account account : list) {
System.out.println(account);
}
System.out.println("-----------");
}
}
}
第五章： Mybatis 多表查询之多对多
5.1-数据表模型
多对多关系其实我们看成是双向的一对多 。
我们使用用户与角色的关系模型来演示
在 MySQL 数据库中添加角色表，用户角色的中间表。 角色表
5.2-数据库脚本
/*
SQLyog Ultimate v12.09 (64 bit)
MySQL - 5.5.40 : Database - db7
*********************************************************************
*/
CREATE DATABASE /*!32312 IF NOT EXISTS*/`db7` /*!40100 DEFAULT CHARACTER SET utf8 */;
USE `db7`;
/*Table structure for table `role` */
DROP TABLE IF EXISTS `role`;
CREATE TABLE `role` (
`id` int(11) NOT NULL COMMENT \'编号\',
`role_name` varchar(30) DEFAULT NULL COMMENT \'角色名称\',
`role_desc` varchar(60) DEFAULT NULL COMMENT \'角色描述\',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*Data for the table `role` */
insert into `role`(`id`,`role_name`,`role_desc`) values (1,\'院长\',\'管理整个学院\'),(2,\'总裁\',\'管理整个公司\'),(3,\'校长\',\'管理整个学校\');
/*Table structure for table `user` */
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(32) DEFAULT NULL,
`birthday` date DEFAULT NULL,
`sex` varchar(22) DEFAULT NULL,
`address` varchar(32) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=19 DEFAULT CHARSET=utf8;
/*Data for the table `user` */
insert into `user`(`id`,`username`,`birthday`,`sex`,`address`) values (1,\'张三丰\',\'2018-12-12\',\'male\',\'海南\'),(2,\'李四\',\'2019-09-04\',\'female\',\'南京\'),(3,\'王五\',\'2020-02-12\',\'male\',\'北京\'),(4,\'赵六\',\'2020-01-01\',\'female\',\'上海\'),(18,\'陈七\',\'2020-02-03\',\'male\',\'杭州\');
/*Table structure for table `user_role` */
DROP TABLE IF EXISTS `user_role`;
CREATE TABLE `user_role` (
`UID` int(11) NOT NULL COMMENT \'用户编号\',
`RID` int(11) NOT NULL COMMENT \'角色编号\',
PRIMARY KEY (`UID`,`RID`),
KEY `FK_Reference_10` (`RID`),
CONSTRAINT `FK_Reference_10` FOREIGN KEY (`RID`) REFERENCES `role` (`ID`),
CONSTRAINT `FK_Reference_9` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*Data for the table `user_role` */
insert into `user_role`(`UID`,`RID`) values (3,1),(4,1),(1,2),(2,3),(3,3);
/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
5.3-实现 Role 到 User 多对多
业务需求及实现sql
需求： 实现查询所有对象并且加载它所分配的用户信息。
分析： 查询角色我们需要用到Role表，但角色分配的用户的信息我们并不能直接找到用户信息，而是要通过中 间表(USER_ROLE 表)才能关联到用户信息。
SELECT
r.*,
u.id AS uid,
u.`address`,
u.`birthday`,
u.`sex`,
u.`username`
FROM
role AS r
LEFT JOIN
user_role AS ur
ON
r.`id`=ur.`RID`
LEFT JOIN
USER AS u
ON
ur.`UID`=u.`id`
角色实体类
public class Role {
private int id;
private String roleName;
private String roleDesc;
private List<User> users;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getRoleName() {
return roleName;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
public String getRoleDesc() {
return roleDesc;
}
public void setRoleDesc(String roleDesc) {
this.roleDesc = roleDesc;
}
public List<User> getUsers() {
return users;
}
public void setUsers(List<User> users) {
this.users = users;
}
@Override
public String toString() {
return "Role{" +
"id=" + id +
", roleName=\'" + roleName + \'\\\'\' +
", roleDesc=\'" + roleDesc + \'\\\'\' +
\'}\';
}
}
Role 持久层接口
public interface IRoleDao {
/**
* 获取所有角色（包含所有属于该角色的用户列表）
* @return
*/
List<Role> findAll();
}
映射配置文件
IRoleDao.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="cn.lpl666.dao.IRoleDao">
<resultMap id="roleMap" type="Role">
<id property="id" column="rid"></id>
<result property="roleName" column="role_name"></result>
<result property="roleDesc" column="role_desc"></result>
<collection property="users" ofType="User">
<id property="id" column="id"></id>
<result property="username" column="username"></result>
<result property="address" column="address"></result>
<result property="birthday" column="birthday"></result>
<result property="sex" column="sex"></result>
</collection>
</resultMap>
<!--查询所有角色信息（包含属于某一个角色的所有用户信息）-->
<select id="findAll" resultMap="roleMap">
SELECT u.*,r.id AS rid,r.role_desc,r.role_name FROM role AS r LEFT JOIN user_role AS ur ON r.id=ur.RID LEFT JOIN USER AS u ON ur.UID=u.id
</select>
</mapper>
测试类
public class RoleTest {
private static InputStream is;
private static SqlSession sqlSession;
private static IRoleDao dao;
@Before
public void init(){
// 读取配置文件
try {
is = Resources.getResourceAsStream("SqlMapConfig.xml");
// 创建工厂构建者对象
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
// 创建SqlSessionFactory工厂对象
SqlSessionFactory sqlSessionFactory = builder.build(is);
// 创建SqlSession对象
sqlSession = sqlSessionFactory.openSession();
// 创建dao代理对象
dao = sqlSession.getMapper(IRoleDao.class);
} catch (IOException e) {
e.printStackTrace();
}
}
@After
public void destroy() throws IOException {
sqlSession.commit();
is.close();
sqlSession.close();
}
/**
* 查询
*/
@Test
public void getAll() throws IOException {
List<Role> all = dao.findAll();
for (Role role : all) {
System.out.println(role);
List<User> list = role.getUsers();
for (User user : list) {
System.out.println(user);
}
System.out.println("-------------");
}
}
}