22_5mybatis多表操作

1.表之间的关系

一对多
多对一
一对一
多对多
举例：

用户和订单就是一对多
订单和用户就是多对一
　　一个用户可以下多个订单
　　多个订单属于同一个用户

人和身份证号就是一对一
　　一个人只能有一个身份证号
　　一个身份证号只能属于一个人

老师和学生之间就是多对多
　　一个学生可以被多个老师教过
　　一个老师可以交多个学生

特例：
如果拿出每一个订单，他都只能属于一个用户。
所以Mybatis就把多对一看成了一对一。

示例：用户和账户
一个用户可以有多个账户
一个账户只能属于一个用户（多个账户也可以属于同一个用户）

步骤：
　　1、建立两张表：用户表，账户表
　　　　让用户表和账户表之间具备一对多的关系：需要使用外键在账户表中添加
　　2、建立两个实体类：用户实体类和账户实体类
　　　　让用户和账户的实体类能体现出来一对多的关系
　　3、建立两个配置文件
　　　　用户的配置文件
　　　　账户的配置文件
　　4、实现配置：
　　　　当我们查询用户时，可以同时得到用户下所包含的账户信息
　　　　当我们查询账户时，可以同时得到账户的所属用户信息

需求（一对一查询）
　　查询所有账户信息，关联查询下单用户信息。
注意：
　　因为一个账户信息只能供某个用户使用，所以从查询账户信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的账户信息则为一对多查询，因为一个用户可以有多个账户。

2.方式一（mybatis一对一查询）

2.1创建用户和账户表

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (

  `id` int(11) NOT NULL auto_increment,

  `username` varchar(32) NOT NULL COMMENT '用户名称',

  `birthday` datetime default NULL COMMENT '生日',

  `sex` char(1) default NULL COMMENT '性别',

  `address` varchar(256) default NULL COMMENT '地址',

  PRIMARY KEY  (`id`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert  into `user`(`id`,`username`,`birthday`,`sex`,`address`) values (41,'老王','2018-02-27 17:47:08','男','北京'),
(42,'小二王','2018-03-02 15:09:37','女','北京金燕龙'),(43,'小二王','2018-03-04 11:34:34','女','北京金燕龙'),
(45,'传智播客','2018-03-04 12:04:06','男','北京金燕龙'),(46,'老王','2018-03-07 17:37:26','男','北京'),
(48,'小马宝莉','2018-03-08 11:44:00','女','北京修正');

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;

insert  into `account`(`ID`,`UID`,`MONEY`) values (1,46,1000),(2,45,1000),(3,46,2000);

2.2定义账户的实体类

package com.itheima.domain;

import java.io.Serializable;

public class Account implements Serializable {

    private Integer id;

    private Integer uid;

    private Double money;

    //从表实体应该包含一个主表实体的对象引用

    private User user;

    public User getUser() {

        return user;

    }

    public void setUser(User user) {

        this.user = user;

    }

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public Integer getUid() {

        return uid;

    }

    public void setUid(Integer 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 +

                '}';

    }

}

2.3编写sql语句

SELECT

　　account.*,

　　user.username,

　　user.address

FROM

　　account,

　　user

WHERE account.uid = user.id

2.4定义AccountUser

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

package com.itheima.domain;

public class AccountUser extends Account {

    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 + '\'' +

                '}';

    }

}

2.5定义账户的持久层 Dao 接口

package com.itheima.dao;

import com.itheima.domain.Account;

import com.itheima.domain.AccountUser;

import java.util.List;

public interface IAccountDao {

    /**

     * 查询所有账户，同时获取账户的所属用户名称以及它的地址信息

     * @return

     */

    List<Account> findAll();

}

2.6定义AccountDao.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="com.itheima.dao.IAccountDao">

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

    <select id="findAll" resultType="accountuser">

select a.*,u.username,u.address from account a,user u where a.uid =u.id;

</select>

</mapper>

2.7创建 AccountTest测试类

package com.itheima.test;

import com.itheima.dao.IAccountDao;

import com.itheima.dao.IUserDao;

import com.itheima.domain.Account;

import com.itheima.domain.AccountUser;

import org.apache.ibatis.io.Resources;

import org.apache.ibatis.session.SqlSession;

import org.apache.ibatis.session.SqlSessionFactory;

import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import java.io.InputStream;

import java.util.List;

public class AccountTest {

    private InputStream in;

    private SqlSession sqlSession;

    private IAccountDao accountDao;

    @Before//用于在测试方法执行之前执行

    public void init() throws Exception {

        //1.读取配置文件，生成字节输入流

        in = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2.获取SqlSessionFactory

        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);

        //3.获取SqlSession对象

        sqlSession = factory.openSession(true);

        //4.获取dao的代理对象

        accountDao = sqlSession.getMapper(IAccountDao.class);

    }

    @After//用于在测试方法执行之后执行

    public void destroy() throws Exception {

        //提交事务

        // sqlSession.commit();

        //6.释放资源

        sqlSession.close();

        in.close();

    }

    /**

     * 测试查询所有账户，同时包含用户名称和地址

     */

    @Test

    public void testFindAllAccountUser() {

        List<AccountUser> aus = accountDao.findAllAccount();

        for (AccountUser au : aus) {

            System.out.println(au);

        }

    }

}

3.方式二（mybatis一对一查询）

　　使用 resultMap，定义专门的 resultMap 用于映射一对一查询结果。
　　通过面向对象的(has a)关系可以得知，我们可以在 Account 类中加入一个 User 类的对象来代表这个账户
是哪个用户的。

3.1修改Account类

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

package com.itheima.domain;

import java.io.Serializable;

public class Account implements Serializable {

    private Integer id;

    private Integer uid;

    private Double money;

    //从表实体应该包含一个主表实体的对象引用

    private User user;

    public User getUser() {

        return user;

    }

    public void setUser(User user) {

        this.user = user;

    }

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public Integer getUid() {

        return uid;

    }

    public void setUid(Integer 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 +

                '}';

    }

}

3.2修改 AccountDao

public interface IAccountDao {

    /**

     * 查询所有账户，同时还要获取到当前账户的所属用户信息

     * @return

     */

    List<Account> findAll();

}

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

3.3重新定义 AccountDao.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="com.itheima.dao.IAccountDao">

    <!-- 定义封装account和user的resultMap -->

    <resultMap id="accountUserMap" type="account">

        <id property="id" column="aid"></id>

        <result property="uid" column="uid"></result>

        <result property="money" column="money"></result>

        <!-- 一对一的关系映射：配置封装user的内容-->

        <association property="user" column="uid" javaType="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>

</mapper>

3.4测试类

package com.itheima.test;

import com.itheima.dao.IAccountDao;

import com.itheima.domain.Account;

import org.apache.ibatis.io.Resources;

import org.apache.ibatis.session.SqlSession;

import org.apache.ibatis.session.SqlSessionFactory;

import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import java.io.InputStream;

import java.util.List;

public class AccountTest {

    private InputStream in;

    private SqlSession sqlSession;

    private IAccountDao accountDao;

    @Before//用于在测试方法执行之前执行

    public void init() throws Exception {

        //1.读取配置文件，生成字节输入流

        in = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2.获取SqlSessionFactory

        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);

        //3.获取SqlSession对象

        sqlSession = factory.openSession(true);

        //4.获取dao的代理对象

        accountDao = sqlSession.getMapper(IAccountDao.class);

    }

    @After//用于在测试方法执行之后执行

    public void destroy() throws Exception {

        //提交事务

        // sqlSession.commit();

        //6.释放资源

        sqlSession.close();

        in.close();

    }

    /**

     * 测试查询所有

     */

    @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());

        }

    }

}

4.mybaits一对多查询

需求：

　　查询所有用户信息及用户关联的账户信息。
分析：

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

4.1 编写 SQL

SELECT

    u.*, acc.id id,

    acc.uid,

    acc.money

FROM

    USER u

LEFT JOIN account acc ON u.id = acc.uid

4.2User类加入 List<Account>

package com.itheima.domain;

import java.io.Serializable;

import java.util.Date;

import java.util.List;

/**

 * @author 黑马程序员

 * @Company http://www.ithiema.com

 */

public class User implements Serializable {

    private Integer id;

    private String username;

    private String address;

    private String sex;

    private Date birthday;

    //一对多关系映射：主表实体应该包含从表实体的集合引用

    private List<Account> accounts;

    public List<Account> getAccounts() {

        return accounts;

    }

    public void setAccounts(List<Account> accounts) {

        this.accounts = accounts;

    }

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    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;

    }

    public String getSex() {

        return sex;

    }

    public void setSex(String sex) {

        this.sex = sex;

    }

    public Date getBirthday() {

        return birthday;

    }

    public void setBirthday(Date birthday) {

        this.birthday = birthday;

    }

    @Override

    public String toString() {

        return "User{" +

                "id=" + id +

                ", username='" + username + '\'' +

                ", address='" + address + '\'' +

                ", sex='" + sex + '\'' +

                ", birthday=" + birthday +

                '}';

    }

}

4.3用户持久层 Dao 接口

package com.itheima.dao;

import com.itheima.domain.User;

import java.util.List;

/**

 * 用户的持久层接口

 */

public interface IUserDao {

    /**

     * 查询所有用户

     *

     * @return

     */

    List<User> findAll();

}

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

<?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.itheima.dao.IUserDao">

    <resultMap type="user" id="userMap">

        <id column="id" property="id"></id>

        <result column="username" property="username"/>

        <result column="address" property="address"/>

        <result column="sex" property="sex"/>

        <result column="birthday" property="birthday"/>

        <!-- collection 是用于建立一对多中集合属性的对应关系

        ofType 用于指定集合元素的数据类型

        -->

        <collection property="accounts" ofType="account">

            <id column="aid" property="id"/>

            <result column="uid" property="uid"/>

            <result column="money" property="money"/>

        </collection>

    </resultMap>

    <!-- 查询所有 -->

    <select id="findAll" resultMap="userMap">

      SELECT u.*, acc.id id,acc.uid, acc.money FROM USER u LEFT JOIN account acc ON u.id = acc.uid

    </select>

</mapper>

collection
　　部分定义了用户关联的账户信息。表示关联查询结果集
property="accList" ：
　　关联查询的结果集存储在 User 对象的上哪个属性。
ofType="account" ：
　　指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名。

4.5测试方法

package com.itheima.test;

import com.itheima.dao.IAccountDao;

import com.itheima.dao.IUserDao;

import com.itheima.domain.Account;

import com.itheima.domain.AccountUser;

import com.itheima.domain.User;

import org.apache.ibatis.io.Resources;

import org.apache.ibatis.session.SqlSession;

import org.apache.ibatis.session.SqlSessionFactory;

import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import java.io.InputStream;

import java.util.List;

public class UserTest {

    private InputStream in;

    private SqlSession sqlSession;

    private IUserDao userDao;

    @Before//用于在测试方法执行之前执行

    public void init() throws Exception {

        //1.读取配置文件，生成字节输入流

        in = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2.获取SqlSessionFactory

        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);

        //3.获取SqlSession对象

        sqlSession = factory.openSession(true);

        //4.获取dao的代理对象

        userDao = sqlSession.getMapper(IUserDao.class);

    }

    @After//用于在测试方法执行之后执行

    public void destroy() throws Exception {

        //提交事务

        // sqlSession.commit();

        //6.释放资源

        sqlSession.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());

        }

    }

}

5.mybatis中的多对多

示例：用户和角色
一个用户可以有多个角色
一个角色可以赋予多个用户
步骤：
　　1、建立两张表：用户表，角色表
　　　　让用户表和角色表具有多对多的关系。需要使用中间表，中间表中包含各自的主键，在中间表中是外键。
　　2、建立两个实体类：用户实体类和角色实体类
　　　　让用户和角色的实体类能体现出来多对多的关系
　　　　各自包含对方一个集合引用
　　3、建立两个配置文件
　　　　用户的配置文件
　　　　角色的配置文件
　　4、实现配置：
　　　　当我们查询用户时，可以同时得到用户所包含的角色信息
　　　　当我们查询角色时，可以同时得到角色的所赋予的用户信息

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;

insert  into `role`(`ID`,`ROLE_NAME`,`ROLE_DESC`) values (1,'院长','管理整个学院'),(2,'总裁','管理整个公司'),(3,'校长','管理整个学校');

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;

insert  into `user_role`(`UID`,`RID`) values (41,1),(45,1),(41,2);

需求：
　　实现查询所有对象并且加载它所分配的用户信息。
分析：
　　查询角色我们需要用到Role表，但角色分配的用户的信息我们并不能直接找到用户信息，而是要通过中间表(USER_ROLE 表)才能关联到用户信息。

5.1编写sql语句

SELECT

    r.*,u.id uid,

    u.username username,

    u.birthday birthday,

    u.sex sex,

    u.address address

FROM

    ROLE r

INNER JOIN

    USER_ROLE ur

ON ( r.id = ur.rid)

INNER JOIN

    USER u

ON (ur.uid = u.id);

5.2编写角色实体类

package com.itheima.domain;

import java.io.Serializable;

import java.util.List;

public class Role implements Serializable {

    private Integer roleId;

    private String roleName;

    private String roleDesc;

    //多对多的关系映射：一个角色可以赋予多个用户

    private List<User> users;

    public List<User> getUsers() {

        return users;

    }

    public void setUsers(List<User> users) {

        this.users = users;

    }

    public Integer getRoleId() {

        return roleId;

    }

    public void setRoleId(Integer roleId) {

        this.roleId = roleId;

    }

    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;

    }

    @Override

    public String toString() {

        return "Role{" +

                "roleId=" + roleId +

                ", roleName='" + roleName + '\'' +

                ", roleDesc='" + roleDesc + '\'' +

                '}';

    }

}

5.3编写 Role持久层接口

package com.itheima.dao;

import com.itheima.domain.Role;

import java.util.List;

public interface IRoleDao {

    /**

     * 查询所有角色

     * @return

     */

    List<Role> findAll();

}

5.4编写映射文件

<?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.itheima.dao.IRoleDao">

    <!--定义role表的ResultMap-->

    <resultMap id="roleMap" type="role">

        <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 r.*,u.id uid,u.username username,u.birthday birthday,u.sex sex,u.address address

      FROM ROLE r

      INNER JOIN USER_ROLE ur

      ON ( r.id = ur.rid)

      INNER JOIN USER u

      ON (ur.uid = u.id);

    </select>

</mapper>

5.5编写测试类

package com.itheima.test;

import com.itheima.dao.IRoleDao;

import com.itheima.dao.IUserDao;

import com.itheima.domain.Role;

import com.itheima.domain.User;

import org.apache.ibatis.io.Resources;

import org.apache.ibatis.session.SqlSession;

import org.apache.ibatis.session.SqlSessionFactory;

import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import java.io.InputStream;

import java.util.List;

/**

 * @author 黑马程序员

 * @Company http://www.ithiema.com

 */

public class RoleTest {

    private InputStream in;

    private SqlSession sqlSession;

    private IRoleDao roleDao;

    @Before//用于在测试方法执行之前执行

    public void init() throws Exception {

        //1.读取配置文件，生成字节输入流

        in = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2.获取SqlSessionFactory

        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);

        //3.获取SqlSession对象

        sqlSession = factory.openSession(true);

        //4.获取dao的代理对象

        roleDao = sqlSession.getMapper(IRoleDao.class);

    }

    @After//用于在测试方法执行之后执行

    public void destroy() throws Exception {

        //提交事务

        // sqlSession.commit();

        //6.释放资源

        sqlSession.close();

        in.close();

    }

    /**

     * 测试查询所有

     */

    @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());

        }

    }

}

巴特西

22_5mybatis多表操作

1.表之间的关系

2.方式一（mybatis一对一查询）

2.1创建用户和账户表

2.2定义账户的实体类

2.3编写sql语句

2.4定义AccountUser

2.5定义账户的持久层 Dao 接口

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

2.7创建 AccountTest测试类

3.方式二（mybatis一对一查询）

3.1修改Account类

3.2修改 AccountDao

3.3重新定义 AccountDao.xml文件

3.4测试类

4.mybaits一对多查询

4.1 编写 SQL

4.2User类加入 List<Account>

4.3用户持久层 Dao 接口

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

4.5测试方法

5.mybatis中的多对多

5.1编写sql语句

5.2编写角色实体类

5.3编写 Role持久层接口

5.4编写映射文件

5.5编写测试类

最新文章

热门文章

巴特西

22_5mybatis多表操作

1.表之间的关系

2.方式一（mybatis一对一查询）

2.1创建用户和账户表

2.2定义账户的实体类

2.3编写sql语句

2.4定义AccountUser

2.5定义 账户的持久层 Dao 接口

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

2.7创建 AccountTest测试类

3.方式二（mybatis一对一查询）

3.1修改Account类

3.2修改 AccountDao

3.3重新定义 AccountDao.xml文件

3.4测试类

4.mybaits一对多查询

4.1 编写 SQL

4.2User类加入 List<Account>

4.3用户持久层 Dao 接口

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

4.5测试方法

5.mybatis中的多对多

5.1编写sql语句

5.2编写角色实体类

5.3编写 Role持久层接口

5.4编写映射文件

5.5编写测试类

最新文章

热门文章

2.5定义账户的持久层 Dao 接口