MyBatis中的連接池及事物控制配置過程

更新時間：2022年01月23日 10:19:37 作者：程序員小徐同學(xué)

連接池就是用于存儲數(shù)據(jù)庫連接的一個容器,容器其實就是一個集合對象，本文給大家介紹MyBatis中的連接池以及事物控制的相關(guān)知識，感興趣的朋友一起看看吧

1.連接池

在實際開發(fā)中都會使用連接池
因為它可以減少我們獲取連接所消耗的時間

連接池就是用于存儲連接的一個容器，容器其實就是一個集合對象，該集合必須是線程安全的，不能兩個線程拿到統(tǒng)一連接，該集合還必須實現(xiàn)隊列特性：先進先出

Mybatis連接提供了.種方式的怕配置：

配置位置：主配置文件SqlMapConfig.xml中的dataSource標(biāo)簽，type屬性就是標(biāo)識采用何種連接池方式
type屬性的取值：POOLED：采用傳統(tǒng)的javax.sql.DataSource規(guī)范中的連接池，mybatis中有針對規(guī)范的實現(xiàn)UNPOOLED：采用傳統(tǒng)的獲取連接的方式，雖然也實現(xiàn)javax.sql.DataSource接口，但是并沒有使用池的思想JNDI：采用服務(wù)器提供的JNDI技術(shù)，來獲取DataSource對象，不同的服務(wù)器所能拿到DataSource是不一樣的
注意：如果不是web或者maven的wai工程是不能使用的，tomcat服務(wù)器，采用連接池就是dbcp連接池

2.mybatis中的事物

1.事物
什么是事物
事物的四大特性ACID
不考慮隔離性會產(chǎn)生的3個問題
解決辦法：四種隔離級別
它是通過sqlsession對象的commit方法和rollback方法實現(xiàn)事物的提交和回滾

1.if語句的設(shè)置

在IUserDao.xml設(shè)置
通過判斷條件進行查詢以及通過多個id進行查詢

 <!--根據(jù)條件查詢-->
    <!--<select id="findUserByCondition"  resultType="com.mybatisD.domain.User">
        select * from user where 1=1
        <if test="username != null">
        and username = #{username}
        </if>
        <if test="sex != null">
            and sex = #{sex}
        </if>
    </select>-->

     <select id="findUserByCondition"  resultType="com.mybatisD.domain.User">
        select * from user
        <where>
        <if test="username != null">
        and username = #{username}
        </if>
        <if test="sex != null">
            and sex = #{sex}
        </if>
        </where>
    </select>
    <!--根據(jù)queryvo中的id集合實現(xiàn)查詢用戶列表-->
    <select id="findUserInIds" resultType="com.mybatisD.domain.User" parameterType="com.mybatisD.domain.QueryVo">
        select * from user
        <where>
            <if test="ids != null and ids.size()>0">
                <foreach collection="ids" open="and id in (" close=" )" item="uid" separator=",">
                    #{uid}
                </foreach>
            </if>
        </where>
    </select>

設(shè)置QueryVo實現(xiàn)類

package com.mybatisD.domain;
import java.util.List;
/**
 * @author ：程序員徐大大
 * @description：TODO
 * @date ：2022-01-21 16:05
 */
public class QueryVo {
    private User user;
    private List<Integer> ids;
    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }
    public List<Integer> getIds() {
        return ids;
    }
    public void setIds(List<Integer> ids) {
        this.ids = ids;
    }
}

設(shè)置IUserDao實現(xiàn)類

package com.mybatisD.dao;
import com.mybatisD.domain.QueryVo;
import com.mybatisD.domain.User;
import org.apache.ibatis.annotations.Select;
import java.util.List;
/*
* 用戶持久層接口
* */
public interface IUserDao {
   // 查詢所有操作
   // @Select("select * from user") 這是用注解方法
    List<User> findAll();
    // 保存方法
    void saveUser(User user);
    //更新用戶
    void updateUser(User user);
    //根據(jù)ID刪除用戶
    void deleteUser(Integer userId);
    //根據(jù)查詢一個用戶
    User findById(Integer userId);
    //根據(jù)名稱模糊查詢用戶
    List<User> findByName(String username);
    //查詢用戶總數(shù)
    int findTotal();
    //根據(jù)queryVo中的條件查詢用戶
    List<User> findUserByVo(QueryVo vo);
    //根據(jù)條件查詢
   //查詢的條件，有可能有用戶名，有可能有性別 有可能有地址，也有可能都沒有
    List<User> findUserByCondition(User u);
    /*
    * 根據(jù)queryvo中提供的id集合查詢用戶信息
    * */
    List<User> findUserInIds(QueryVo vo);
}

測試方法

@Test
    public void testFindByCondition(){
        User u = new User();
        u.setUsername("王五");
        u.setSex("女");
        //執(zhí)行查詢條件
        List<User> users = userDao.findUserByCondition(u);
        for (User user: users) {
            System.out.println(user);
        }
    }
    //測試使用Query作為查詢條件
    @Test
    public void testFindInIds(){
        QueryVo vo = new QueryVo();
        List<Integer> list = new ArrayList<Integer>();
        list.add(2);
        list.add(5);
        list.add(10);
        vo.setIds(list);
        List<User> users = userDao.findUserInIds(vo);
        for (User u: users) {
            System.out.println(u);
        }
    }

全部代碼在文章最后展出

2.mybatis中的多表查詢

表之間的關(guān)系：

一對多
多對一
一對一
多對多

示例：用戶和賬戶

一個用戶可以有多個賬戶
一個賬戶只能屬于一個用戶（多個賬戶也可以屬于同一個用戶）

步驟：

先建立兩張表、用戶表，賬戶表，讓用戶表和賬戶表之間具備一對多的關(guān)系，需要使用外鍵在賬戶中添加
建立兩個實體類：用戶和賬戶實體類、讓用戶和賬戶實體類能體現(xiàn)出來一對多的關(guān)系
建立兩個配置文件：用戶配置文件。賬戶的配置文件
當(dāng)我們查詢用戶時，可以同時得到用戶下所包含的賬戶信息
當(dāng)我們查詢賬戶時，可以同時得到賬戶的所屬信息

1.簡單實現(xiàn)

表數(shù)據(jù)

在這里插入圖片描述

創(chuàng)建Account實現(xiàn)類

package com.mybatisD.domain;
import java.io.Serializable;
/**
 * @author ：程序員徐大大
 * @description：TODO
 * @date ：2022-01-22 16:02
 */
public class Account  implements Serializable {
    private  Integer id;
    private Integer uid;
    private double money;
    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 +
                '}';
    }
}

再創(chuàng)建與user進行連接的AccountUser實現(xiàn)類、其中toString去調(diào)用父類的toString

package com.mybatisD.domain;
/**
 * @author ：程序員徐大大
 * @description：TODO
 * @date ：2022-01-22 16:25
 */
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 + '\'' +
                '}';
    }
}

設(shè)置IAccountDao

package com.mybatisD.dao;
import com.mybatisD.domain.Account;
import com.mybatisD.domain.AccountUser;
import java.util.List;
public interface IAccountDao {
    //查詢所有賬戶
    List<Account> findAll();
    //查詢賬戶，并且?guī)в杏脩裘Q和地址信息
    List<AccountUser> findAllAccount();
}

配置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="com.mybatisD.dao.IAccountDao">
    <select id="findAll" resultType="com.mybatisD.domain.Account" >
        select * from account
    </select>
    <!--查詢所有同時包含用戶信息-->
    <select id="findAllAccount" resultType="com.mybatisD.domain.AccountUser">
         SELECT a.*,u.username,u.address FROM account a,USER u WHERE u.id = a.uid
    </select>
</mapper>

配置數(shù)據(jù)庫連接SqlMaoConfig.xml文件

<?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文件 可以在標(biāo)簽內(nèi)部配置數(shù)據(jù)庫的信息，也可以通過屬性引用外部配置信息
    resource屬性：用于指定配置文件的位置，是按照類路徑的寫法來寫平且必須存在與類路徑下
    -->
    <properties resource="jdbcConfig.properties">
        <!--<property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/newsql?characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value=""/>-->
    </properties>
    <!--配置環(huán)境-->
    <environments default="mysql">
        <!--配置mysql環(huán)境-->
        <environment id="mysql">
            <!--配置事物類型-->
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <!--配置連接數(shù)據(jù)庫的4個信息-->
                <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>
        <mapper resource="com/mybatisD/dao/IUserDao.xml"/>
        <mapper resource="com/mybatisD/dao/IAccountDao.xml"/>
    </mappers>
    <!--如果要是用注解來配置的話，此處應(yīng)該使用class屬性指定被注解的dao全限定類名-->
    <!--<mappers>
        <mapper class="com.mybatisD.dao.IUserDao"/>
    </mappers>-->
    <!--<mappers>
        &lt;!&ndash;package標(biāo)簽用于指定doa接口所在的包，當(dāng)指定了之后就不需要在寫mapper以及resource或者class了&ndash;&gt;
        <package name="com.mybatisD.domain"/>
    </mappers>-->
</configuration>

配置jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/newsql?characterEncoding=utf-8
jdbc.username=root
jdbc.password=

配置日志文件

log4j.rootCategory=debug,CONSOLE, LOGFILE
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
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
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

測試類

package com.mybatisJ.test;
import com.mybatisD.dao.IAccountDao;
import com.mybatisD.dao.IUserDao;
import com.mybatisD.domain.Account;
import com.mybatisD.domain.AccountUser;
import com.mybatisD.domain.QueryVo;
import com.mybatisD.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.ArrayList;
import java.util.Date;
import java.util.List;
/**
 * @author ：程序員徐大大
 * @description：TODO
 * @date ：2022-01-22 16:07
 */
public class AccountTest {
    private InputStream in;
    private SqlSession sqlSession;
    private IAccountDao  accountDao;
    @Before//用于在測試方法執(zhí)行之前執(zhí)行
    public void init()throws  Exception{
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        sqlSession = factory.openSession();
        //4.使用SqlSession創(chuàng)建Dao接口的代理對象
        accountDao = sqlSession.getMapper(IAccountDao.class);
    }
    @After//用于在測試方法之后執(zhí)行
    public void destory() throws Exception{
        //添加提交事物，不添加無法提交
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }
    @Test
    public  void testFindAll() throws  Exception{
        List<Account> accounts = accountDao.findAll();
        for (Account account: accounts) {
            System.out.println(account);
        }
    }
    @Test
    public void findAllAccount(){
        List<AccountUser> accountUsers = accountDao.findAllAccount();
        for (AccountUser au: accountUsers) {
            System.out.println(au);
        }
    }
}

在這里插入圖片描述

2.以上是沒有進行封裝，下面就是封裝一對一關(guān)系的映射

配置封裝IAcountDao.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.mybatisD.dao.IAccountDao">
    <!--定義封裝account的resultMap-->
    <resultMap id="accountUserMap" type="com.mybatisD.domain.Account">
        <id property="id" column="aid"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!--一對一的關(guān)系映射，配置封裝user內(nèi)容-->
        <association property="user"   column="uid" javaType="com.mybatisD.domain.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>
    <!--查詢所有同時包含用戶信息-->
    <select id="findAllAccount" resultType="com.mybatisD.domain.AccountUser">
         SELECT a.*,u.username,u.address FROM account a,USER u WHERE u.id = a.uid
    </select>
</mapper>

在Account實現(xiàn)類加入User方法

package com.mybatisD.domain;
import java.io.Serializable;
/**
 * @author ：程序員徐大大
 * @description：TODO
 * @date ：2022-01-22 16:02
 */
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 +
                '}';
    }
}

實現(xiàn)IAccountDao的接口

package com.mybatisD.dao;
import com.mybatisD.domain.Account;
import com.mybatisD.domain.AccountUser;
import java.util.List;
public interface IAccountDao {
    //查詢所有賬戶
    List<Account> findAll();
    //查詢賬戶，并且?guī)в杏脩裘Q和地址信息
    List<AccountUser> findAllAccount();
}

測試實現(xiàn)

package com.mybatisJ.test;

import com.mybatisD.dao.IAccountDao;
import com.mybatisD.dao.IUserDao;
import com.mybatisD.domain.Account;
import com.mybatisD.domain.AccountUser;
import com.mybatisD.domain.QueryVo;
import com.mybatisD.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.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @author ：程序員徐大大
 * @description：TODO
 * @date ：2022-01-22 16:07
 */
public class AccountTest {
    private InputStream in;
    private SqlSession sqlSession;
    private IAccountDao  accountDao;

    @Before//用于在測試方法執(zhí)行之前執(zhí)行
    public void init()throws  Exception{
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        sqlSession = factory.openSession();
        //4.使用SqlSession創(chuàng)建Dao接口的代理對象
        accountDao = sqlSession.getMapper(IAccountDao.class);
    }
    @After//用于在測試方法之后執(zhí)行
    public void destory() throws Exception{
        //添加提交事物，不添加無法提交
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }
    //查詢連接方法其中包括用戶的一些信息
    @Test
    public  void testFindAll() throws  Exception{

        List<Account> accounts = accountDao.findAll();
        for (Account account: accounts) {
            System.out.println("-----------------------");
            System.out.println(account);
           System.out.println(account.getUser());
        }
    }
    //查詢account的信息
    @Test
    public void findAllAccount(){
        List<AccountUser> accountUsers = accountDao.findAllAccount();
        for (AccountUser au: accountUsers) {
            System.out.println(au);
        }
    }
}

在這里插入圖片描述

3.一對多關(guān)系映射，主表實體應(yīng)該包含從表實體的集合引用

但是在User與Account的數(shù)據(jù)庫表中可以發(fā)現(xiàn)有的User數(shù)據(jù)中是沒有Account的數(shù)據(jù)，在下面就是一對多的關(guān)系映射
在user實現(xiàn)類進行增加Account類

package com.mybatisD.domain;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    private List<Account> account;
//一對多關(guān)系映射，主表實體應(yīng)該包含從表實體的集合引用
    public List<Account> getAccount() {
        return account;
    }
    public void setAccount(List<Account> account) {
        this.account = account;
    }
    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 Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date 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 + '\'' +
                '}';
    }
}

在配置IUserDao.xml加入一對多的關(guān)系

<?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.mybatisD.dao.IUserDao">
    <!--定義user的resultMap-->
    <resultMap id="userAccountMap" type="com.mybatisD.domain.User">
        <id property="id" column="id"></id>
        <id property="username" column="username"></id>
        <id property="sex" column="sex"></id>
        <id property="birthday" column="birthday"></id>
        <!--配置user對象中account集合的映射-->
        <collection property="account" ofType="com.mybatisD.domain.Account">
            <id column="aid" property="id"></id>
            <id column="uid" property="uid"></id>
            <id column="money" property="money"></id>
        </collection>
    </resultMap>
    <!--配置查詢所有-->
    <select id="findAll" resultMap="userAccountMap">
        select * from user u left outer join account a on u.id = a.uid
    </select>
</mapper>

測試類

package com.mybatisJ.test;
import com.mybatisD.dao.IAccountDao;
import com.mybatisD.dao.IUserDao;
import com.mybatisD.domain.Account;
import com.mybatisD.domain.AccountUser;
import com.mybatisD.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 ：程序員徐大大
 * @description：TODO
 * @date ：2022-01-22 16:07
 */
public class userTest {
    private InputStream in;
    private SqlSession sqlSession;
    private IUserDao userDao;
    @Before//用于在測試方法執(zhí)行之前執(zhí)行
    public void init()throws  Exception{
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        sqlSession = factory.openSession();
        //4.使用SqlSession創(chuàng)建Dao接口的代理對象
        userDao = sqlSession.getMapper(IUserDao.class);
    }
    @After//用于在測試方法之后執(zhí)行
    public void destory() throws Exception{
        //添加提交事物，不添加無法提交
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }
    //查詢連接方法其中包括用戶的一些信息
    @Test
    public  void testFindAll() throws  Exception{
        List<User> users = userDao.findAll();
        for (User user: users) {
            System.out.println(user);
            System.out.println(user.getAccount());
        }
        }
}

結(jié)果

在這里插入圖片描述

4.多對多

示例：用戶和角色

一個用戶可以有多個角色
一個角色可以賦予多個用戶

步驟：

先建立兩張表、用戶表，角色表，讓用戶表和角色表具備多對多的關(guān)系，需要使用中間表，中間表包含各自主鍵在中間表中是外鍵
建立兩個實體類：用戶和角色實體類、讓用戶和角色實體類能體現(xiàn)出來多對多的關(guān)系、各自包含對方一個集合引用
建立兩個配置文件：用戶配置文件。角色的配置文件
當(dāng)我們查詢用戶時，可以同時得到用戶下所包含的角色信息
當(dāng)我們查詢角色時，可以同時得到角色的賦予的用戶信息

role表

在這里插入圖片描述

多對多關(guān)系表user_role

在這里插入圖片描述

創(chuàng)建Role實體類
其中主要的是多對多的關(guān)系映射User

package com.mybatisD.domain;
import java.io.Serializable;
import java.util.List;
/**
 * @author ：程序員徐大大
 * @description：TODO
 * @date ：2022-01-22 20:07
 */
public class Role implements Serializable {
    private Integer roleId;
    private String roleName;
    private String roleDesc;
    //多對多的關(guān)系映射，一個角色可以賦予多個用戶
    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 + '\'' +
                '}';
    }
}

User實體類的關(guān)系映射Role

package com.mybatisD.domain;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    //多對多的關(guān)系映射，一個用戶可以具備多個角色
    private List<Role> roles;
    public List<Role> getRoles() {
        return roles;
    }
    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }
    private List<Account> account;
//一對多關(guān)系映射，主表實體應(yīng)該包含從表實體的集合引用
    public List<Account> getAccount() {
        return account;
    }
    public void setAccount(List<Account> account) {
        this.account = account;
    }
    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 Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date 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 + '\'' +
                '}';
    }
}

IROleDao的接口

package com.mybatisD.dao;

import com.mybatisD.domain.Role;

import java.util.List;

public interface IRoleDao {
    //查詢所有角色
    List<Role> findAll();
}

IUserDao的接口

package com.mybatisD.dao;
import com.mybatisD.domain.QueryVo;
import com.mybatisD.domain.User;
import org.apache.ibatis.annotations.Select;
import java.util.List;
/*
* 用戶持久層接口
* */
public interface IUserDao {
   // 查詢所有操作
   // @Select("select * from user") 這是用注解方法
    List<User> 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="com.mybatisD.dao.IRoleDao">
    <!--定義role表的ResultMap-->
    <resultMap id="roleMap" type="com.mybatisD.domain.Role">
        <id property="roleId" column="id"></id>
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
        <collection property="users" ofType="com.mybatisD.domain.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>
</mapper>

配置IUserDao.xml中的多對多Role

<?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.mybatisD.dao.IUserDao">
    <!--定義user的resultMap-->
    <resultMap id="userMap" type="com.mybatisD.domain.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="com.mybatisD.domain.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.rid
       left outer join role r on r.id = ur.uid;
    </select>
</mapper>

配置SqlMapConfig.xml文件
其中下面的配置包路徑名

<mappers >
        <!--package標(biāo)簽用于指定doa接口所在的包，當(dāng)指定了之后就不需要在寫mapper以及resource或者class了-->
        <package name="com.mybatisD.dao"/>
    </mappers>

<?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文件 可以在標(biāo)簽內(nèi)部配置數(shù)據(jù)庫的信息，也可以通過屬性引用外部配置信息
    resource屬性：用于指定配置文件的位置，是按照類路徑的寫法來寫平且必須存在與類路徑下
    -->
    <properties resource="jdbcConfig.properties">

        <!--<property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/newsql?characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value=""/>-->

    </properties>
    <!--配置環(huán)境-->
    <environments default="mysql">
        <!--配置mysql環(huán)境-->
        <environment id="mysql">
            <!--配置事物類型-->
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <!--配置連接數(shù)據(jù)庫的4個信息-->
                <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>
        <mapper resource="com/mybatisD/dao/IUserDao.xml"/>
     <mapper resource="com/mybatisD/dao/IAccountDao.xml"/>
    </mappers>-->
    <!--如果要是用注解來配置的話，此處應(yīng)該使用class屬性指定被注解的dao全限定類名-->
    <!--<mappers>
        <mapper class="com.mybatisD.dao.IUserDao"/>
    </mappers>-->
    <mappers >
        <!--package標(biāo)簽用于指定doa接口所在的包，當(dāng)指定了之后就不需要在寫mapper以及resource或者class了-->
        <package name="com.mybatisD.dao"/>
    </mappers>
</configuration>

測試role多對多User

package com.mybatisJ.test;
import com.mybatisD.dao.IRoleDao;
import com.mybatisD.dao.IUserDao;
import com.mybatisD.domain.Role;
import com.mybatisD.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 ：程序員徐大大
 * @description：TODO
 * @date ：2022-01-22 16:07
 */
public class roleTest {
    private InputStream in;
    private SqlSession sqlSession;
    private IRoleDao roleDao;
    @Before//用于在測試方法執(zhí)行之前執(zhí)行
    public void init()throws  Exception{
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        sqlSession = factory.openSession();
        //4.使用SqlSession創(chuàng)建Dao接口的代理對象
        roleDao = sqlSession.getMapper(IRoleDao.class);
    }
    @After//用于在測試方法之后執(zhí)行
    public void destory() throws Exception{
        //添加提交事物，不添加無法提交
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }
    //查詢角色的一些信息
    @Test
    public  void testFindAll() throws  Exception {
    List<Role> roles = roleDao.findAll();
        for (Role role: roles) {
            System.out.println(role);
            System.out.println(role.getUsers());
        }
    }
}

在這里插入圖片描述

測試User多對多Role

package com.mybatisJ.test;
import com.mybatisD.dao.IAccountDao;
import com.mybatisD.dao.IUserDao;
import com.mybatisD.domain.Account;
import com.mybatisD.domain.AccountUser;
import com.mybatisD.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 ：程序員徐大大
 * @description：TODO
 * @date ：2022-01-22 16:07
 */
public class userTest {
    private InputStream in;
    private SqlSession sqlSession;
    private IUserDao userDao;
    @Before//用于在測試方法執(zhí)行之前執(zhí)行
    public void init()throws  Exception{
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        sqlSession = factory.openSession();
        //4.使用SqlSession創(chuàng)建Dao接口的代理對象
        userDao = sqlSession.getMapper(IUserDao.class);
    }
    @After//用于在測試方法之后執(zhí)行
    public void destory() throws Exception{
        //添加提交事物，不添加無法提交
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }
    //查詢連接方法其中包括用戶的一些信息
    @Test
    public  void testFindAll() throws  Exception{
        List<User> users = userDao.findAll();
        for (User user: users) {
            System.out.println(user);
            System.out.println(user.getRoles());
        }
        }
}

在這里插入圖片描述