Mybatis就把 多对一看成了一对一。
一对一操作
public class Account implements Serializable {
private Integer id;
private Integer uid;
private Double money;
private User user; 从表实体应该包含一个主表实体的对象引用}
<mapper namespace="com.wyc.Dao.AccountDao">
<resultMap id="accountUserMap" type="account"> 定义封装account和user的resultMap
<id property="id" column="aid"></id> aid为sql语句别名
<result property="uid" column="uid"></result>
<result property="money" column="money"></result>
指定 account 的uid 为外键
<association property="user" column="uid" javaType="user"> 一对一的关系映射:配置封装user的内容
<id property="id" column="id"></id>
<result column="username" property="username"></result>
<result column="address" property="address"></result>
<result column="sex" property="sex"></result>
<result column="birthday" property="birthday"></result>
</association>
</resultMap>
<!--查询所有-->
<select id="findAll" resultMap="accountUserMap"> 对应定义的结果集 名
select u.*,a.id as aid,a.uid,a.money from account a , user u where u.id = a.uid;
</select>
@Test 查询账户所有 并且含有用户的名字
public void testFindAll(){
List<Account> accounts = accountDao.findAll();
for(Account account : accounts){
System.out.println("--------每个account的信息------------");
System.out.println(account);
System.out.println(account.getUser()); account包含user信息
}}
一对多
查询所有用户 并且包括账户信息 用户不一定有账户 所有需要用 外连接查询
1.查询user表的用户信息 包括 account 表的账户信息 是一对多的关系 并且可能没有 ,所以用外连接
select * from user u left outer join account a on u.id = a.uid 查询user from user 表 加入 账户表
public class User implements Serializable { 可序列化的 类
private Integer id;
private String username;
private String address;
private String sex;
private Date birthday;
private List<Account> accounts; 一对多关系映射:主表实体应该包含从表实体的集合引用
select * from user u left outer join account a on u.id = a.uid
<mapper namespace="com.wyc.Dao.UserDao">
<resultMap id="userAccountMap" type="user"> 定义User的resultMap
<id property="id" column="id"></id>
<result property="username" column="username"></result>
<result property="address" column="address"></result>
<result property="sex" column="sex"></result>
<result property="birthday" column="birthday"></result>
<collection property="accounts" ofType="account"> 配置user对象中accounts集合的映射
<id column="aid" property="id"></id> 防止与user id重复起别名
<result column="uid" property="uid"></result>
<result column="money" property="money"></result>
</collection>
</resultMap>
<select id="findAll" resultMap="userAccountMap"> 查询所有用户 并且包括账户信息
select * from user u left outer join account a on u.id = a.uid
</select>
@Test 查询所有 用户所有并且含有账户的信息
public void testFindAll(){
List<User> users = userDao.findAll();
for(User user : users){
System.out.println(user);
System.out.println(user.getAccounts());
}}
多对多
1、建立两张表:用户表,角色表
让用户表和角色表具有多对多的关系。需要使用中间表,中间表中包含各自的主键,在中间表中是外键。
2、建立两个实体类: 用户实体类和角色实体类 让用户和角色的实体类能体现出来多对多的关系 各自包含对方一个集合引用
3、建立两个配置文件 用户的配置文件 角色的配置文件
4、实现配置: 当我们查询用户时,可以同时得到用户所包含的角色信息
一.从角色到用户
当我们查询角色时,可以同时得到角色的所赋予的用户信息
2.查询角色表的信息 包括 用户表的角色 信息 是多对多的关系 需要另一张表关联 所以需要 两个外连接 连接这个关系表
role _user 表 列 uid 参考表user id 列 rid 参考表 role id
select * from role r 查询角色 from role
left outer join user_role ur on r.id = ur.rid 加入关系表
left outer join user u on u.id = ur.uid; 加入用户表
public class Role implements Serializable { 角色表
private Integer roleId;
private String roleName;
private String roleDesc;
private List<User> users; 多对多的关系映射:一个角色可以赋予多个用户}
<mapper namespace="com.wyc.Dao.RoleDao">
<resultMap id="roleMap" type="role"> 定义role表的ResultMap
<id property="roleId" column="rid"></id>
<result property="roleName" column="role_name"></result>
<result property="roleDesc" column="role_desc"></result>
<collection property="users" ofType="user">
<id column="id" property="id"></id>
<result column="username" property="username"></result>
<result column="address" property="address"></result>
<result column="sex" property="sex"></result>
<result column="birthday" property="birthday"></result>
</collection>
</resultMap>
查询所有 用户 并且包括用户的角色
<select id="findAll" resultMap="roleMap">
select u.*,r.id as rid,r.role_name,r.role_desc from role r
left outer join user_role ur on r.id = ur.rid
left outer join user u on u.id = ur.uid
</select>
@Test 查询所有 用户 并且包括用户的角色
public void testFindAll(){
List<Role> roles = roleDao.findAll();
for(Role role : roles){
System.out.println("---每个角色的信息----");
System.out.println(role);
System.out.println(role.getUsers());
}}
二.从用户到角色
当我们查询用户表时,可以同时得到用户的所赋予的角色信息
查询user 表的信息 包括 role 表的角色 信息 是多对多的关系 需要另一张表关联 所以需要 两个外连接 连接这个关系表
role _user 表 列 uid 参考表user id 列 rid 参考表 role id
select * from user u 从user 到 role 是from user
left outer join user_role ur on u.id = ur.uid 先将 关系表 加入到 user表
left outer join role r 在将role表 加入到 关系表和user表
public class User implements Serializable {//可序列化的 类
private Integer id;
private String username;
private String address;
private String sex;
private Date birthday;
private List<Role> roles; 多对多的关系映射:一个用户可以具备多个角色}
定义User的resultMap
<resultMap id="userMap" type="user">
<id property="id" column="id"></id>
<result property="username" column="username"></result>
<result property="address" column="address"></result>
<result property="sex" column="sex"></result>
<result property="birthday" column="birthday"></result>
<collection property="roles" ofType="role"> 配置角色集合的映射
<id property="roleId" column="rid"></id>
<result property="roleName" column="role_name"></result>
<result property="roleDesc" column="role_desc"></result>
</collection>
</resultMap>
查询所有 用户包括他的角色信息
<select id="findAll" resultMap="userMap">
select u.*,r.id as rid,r.role_name,r.role_desc from user u
left outer join user_role ur on u.id = ur.uid
left outer join role r on r.id = ur.rid
</select>
@Test
public void testFindAll(){
List<User> users = userDao.findAll();
for(User user : users){
System.out.println(user);
System.out.println(user.getRoles());
}}
总结外连接
就是在多表查询中 将多张表的信息 关联起来 并查询关联后的大表 展示出来
查询谁的 就是from 谁 再加其他的表信息
一对一 不需要外连接 直接 where 一个表的主键id = 被关联的表的 关联键 被关联表是 多的一方
一对多 直接加另一张表 多对多 先将关系表加入 再加另一张表