Mybatis2

目录

• 大纲
• 连接池：
• 1、mybatis中连接池使用及分析
  • • 日志输出对比
    • POOLED 部分原理实现
• 2、mybatis事务控制的分析
• 3、mybatis基于XML配置的动态SQL语句使用
  • • if
    • set
    • where
    • foreach
    • trim
    • sql （了解）
• 4、mybatis中的多表查询
  • • 一对一查询(多对一)
    • 一对多查询
    • 多对多查询
      • 查询所有的角色，及对应的用户信息
      • 查询所有的用户，及对应的角色信息
• 5 补充 JNDI

大纲

mybatis中的连接池以及事务控制			原理部分了解，应用部分会用
	1 mybatis中连接池使用及分析
	2 mybatis事务控制的分析
3、mybatis基于XML配置的动态SQL语句使用		会用即可
	mappers配置文件中的几个标签：
		<if>
		<where>
		<foreach>
		<sql>
4、mybatis中的多表操作				掌握应用
	一对多
	一对一（？）
	多对多
5 JNDI

---

连接池：

我们在实际开发中都会使用连接池。
因为它可以减少我们获取连接所消耗的时间。

1、mybatis中连接池使用及分析

mybatis连接池提供了3种方式的配置：
	配置的位置：
		主配置文件SqlMapConfig.xml中的dataSource标签，type属性就是表示采用何种连接池方式。
	type属性的取值：
		POOLED	 采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现  （一般用这个）
		UNPOOLED 采用传统的获取连接的方式，虽然也实现Javax.sql.DataSource接口，但是并没有使用池的思想。
		JNDI	 采用服务器提供的JNDI技术实现，来获取DataSource对象，不同的服务器所能拿到DataSource是不一样。
			 注意：如果不是web或者maven的war工程，是不能使用的。
			 我们课程中使用的是tomcat服务器，采用连接池就是dbcp连接池。

创建工程->Maven ->不勾create from ->com.yu -> day03_eesy_01datasourceAndTx（初始代码和day02_eesy_01mybatisCRUD一样）

日志输出对比

POOLED 部分原理实现

2、mybatis事务控制的分析

什么是事务
事务的四大特性ACID
不考虑隔离性会产生的3个问题
解决办法：四种隔离级别

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

在MybatisTest.java中，测试方法执行之后需要提交事务

可以改为自动提交：（事务自动提交commit）（用的不多）

        //3 获取SqlSession对象
        sqlSession = factory.openSession(true);

这样就可以删去 sqlSession.commit();
这样依然可以实现增删改

3、mybatis基于XML配置的动态SQL语句使用

用于查询中

mappers配置文件中的几个标签：
	<if>
	<where>
	<foreach>
	<sql> 

if

IUserDao.java

    /**
     * 根据传入参数条件查询
     * @param user 查询的条件，可能有用户名，有可能有性别。。。还有可能是都有
     * @return
     */
    List<User> findUserByCondition(User user);

IUserDao.xml

    <!--根据传入参数条件查询 if-->
    <select id="findUserByCondition" resultType="user" parameterType="user">
        SELECT * FROM USER WHERE 1=1
        <if test="username != null">
            and username = #{username}
        </if>
        <if test="sex != null">
            and sex = #{sex}
        </if>
    </select>

MybatisTest.java

    /**
     * 根据传入参数条件查询
     */
    @Test
    public void findUserByCondition() {

        User u = new User();
        u.setUsername("老王");
        u.setSex("女");
        //5 执行查询所有方法
        List<User> users = userDao.findUserByCondition(u);
        for (User user:users){
            System.out.println(user);
        }
    }

set

用于动态更新语句的类似解决方案叫做 set。set 元素可以用于动态包含需要更新的列，忽略其它不更新的列。比如：

<update id="updateAuthorIfNecessary">
  update Author
    <set>
      <if test="username != null">username=#{username},</if>
      <if test="password != null">password=#{password},</if>
      <if test="email != null">email=#{email},</if>
      <if test="bio != null">bio=#{bio},</if>
    </set>
  where id=#{id}
</update>

这个例子中，set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）。

where

where可以省去 1=1
IUserDao.java

List<User> findUserByCondition(User user);

IUserDao.xml

    <!--根据传入参数条件查询 where-->
    <select id="findUserByCondition" resultType="user" parameterType="user">
        SELECT * FROM USER
        <where>
            <if test="username != null">
                and username = #{username}
            </if>
            <if test="sex != null">
                and sex = #{sex}
            </if>
        </where>

    </select>

MybatisTest.java

    /**
     * 根据传入参数条件查询
     */
    @Test
    public void findUserByCondition() {

        User u = new User();
        u.setUsername("老王");
        u.setSex("女");
        //5 执行查询所有方法
        List<User> users = userDao.findUserByCondition(u);
        for (User user:users){
            System.out.println(user);
        }
    }

foreach

QueryVo.java

package com.yu.domain;

import java.util.List;

public class QueryVo {
    private User user;
    private List<Integer> ids;

    public List<Integer> getIds() {
        return ids;
    }

    public void setIds(List<Integer> ids) {
        this.ids = ids;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}

IUserDao.java

    /**
     * 根据QueryVo中提供的id集合，查询用户信息
     * @param vo
     * @return
     */
    List<User> findUserInIds(QueryVo vo);

IUserDao.xml

    <!--根据QueryVo中提供的id集合，查询用户信息-->
    <select id="findUserInIds" resultType="user" parameterType="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>

foreach标签用于遍历集合，它的属性：

      collection:代表要遍历的集合元素，注意编写时不要写#{}
      open:代表语句的开始部分
      close:代表结束部分
      item:代表遍历集合的每个元素，生成的变量名
      sperator:代表分隔符

注：#{uid}要与item="uid"中的uid相对应

MybatisTest.java

    /**
     * 根据QueryVo中提供的id集合，查询用户信息
     */
    @Test
    public void findUserInIds() {

        QueryVo vo = new QueryVo();
        List<Integer> list = new ArrayList<Integer>();
        list.add(41);
        list.add(49);
        list.add(50);
        list.add(52);
        vo.setIds(list);

        //5 执行查询所有方法
        List<User> users = userDao.findUserInIds(vo);
        for (User user:users){
            System.out.println(user);
        }
    }

trim

mybatis的trim标签一般用于去除sql语句中多余的and关键字，逗号，或者给sql语句前拼接 “where“、“set“以及“values(“ 等前缀，或者添加“)“等后缀，可用于选择性插入、更新、删除或者条件查询等操作。

属性	描述
prefix	给sql语句拼接的前缀
suffi	给sql语句拼接的后缀
prefixOverrides	去除sql语句前面的关键字或者字符，该关键字或者字符由prefixOverrides属性指定，假设该属性指定为"AND"，当sql语句的开头为"AND"，trim标签将会去除该"AND"
suffixOverrides	去除sql语句后面的关键字或者字符，该关键字或者字符由suffixOverrides属性指定

<!--增加用户信息-->
    <insert id="save" parameterType="com.example.demo.entity.User" >
        insert into user
        <trim prefix="(" suffix=")" suffixOverrides="," >
            <if test="id != null" >
                id,
            </if>
            <if test="userName != null" >
                userName,
            </if>
            <if test="passWord != null" >
                passWord,
            </if>
 
            <if test="realName != null" >
                realName,
            </if>
        </trim>
        <trim prefix="values (" suffix=")" suffixOverrides="," >
            <if test="id != null" >
                #{id,jdbcType=INTEGER},
            </if>
            <if test="userName != null" >
                #{userName,jdbcType=VARCHAR},
            </if>
            <if test="passWord != null" >
                #{passWord,jdbcType=VARCHAR},
            </if>
            <if test="realName != null" >
                #{realName,jdbcType=VARCHAR},
            </if>
        </trim>
    </insert>

sql （了解）

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

IUserDao.xml

    <!--了解的内容，抽取重复的sql语句-->
    <sql id="defaultUser">
        SELECT * FROM USER
    </sql>


    <!--查询所有-->
    <select id="findAll" resultType="com.yu.domain.User">
        <include refid="defaultUser"></include>
    </select>




    <!--根据QueryVo中提供的id集合，查询用户信息-->
    <select id="findUserInIds" resultType="user" parameterType="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>

4、mybatis中的多表查询

表之间的关系有几种：
	一对多
	(多对一
	一对一
	多对多
举例：
	用户和订单就是一对多
	订单和用户就是多对一
		一个用户可以下多个订单
		多个订单属于同一个用户
	人和身份证号就是一对一
		一个人只能有一个身份证号
		一个身份证号只能属于一个人
	老师和学生之间就是多对多
		一个学生可以被多个老师教过
		一个老师可以教多个学生
特例：
	如果拿出每一个订单，他都只能属于一个用户。
	所以Mybatis就把多对一看成了一对一。

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

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

创建工程->Maven ->不勾create from ->com.yu -> day03_eesy_03one2many（初始代码和day03_eesy_02dynamicSQL一样，只留 查所有和根据id查询）

一对一查询(多对一)

查询所有账户信息，关联查询下单用户信息。
Account.java

package com.yu.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 +
                '}';
    }
}

AccountUser.java(一般不常用)

package com.yu.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 + '\'' +
                '}';
    }
}

IAccountDao.java(接口)

package com.yu.dao;

import com.yu.domain.Account;
import com.yu.domain.AccountUser;

import java.util.List;

public interface IAccountDao {
    /**
     * 查询所有账户及对应的用户信息
     * @return
     */
    List<Account> findAll();

    /**
     * 查询所有账户,并且带有用户名称和地址信息
     */
    List<AccountUser> findAllAccount();
}

IAccountDao.xml
collection和association的区别
association是用于一对一和多对一，而collection是用于一对多的关系

<?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.yu.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的内容 -->
         <!--javaType：封装到哪个对象-->
        <association property="user" javaType="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>
        </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="accountUser">
        SELECT a.*,u.username,u.address FROM account a,user u WHERE u.id = a.UID
    </select>

</mapper>

AccountTest.java

package com.yu.test;

import com.yu.dao.IAccountDao;
import com.yu.dao.IUserDao;
import com.yu.domain.Account;
import com.yu.domain.AccountUser;
import com.yu.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.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());
        }
    }
    /**
     *测试查询所有账户,并且带有用户名称和地址信息
     */
    @Test
    public void testFindAllAccountUser(){

        List<AccountUser> aus = accountDao.findAllAccount();
        for(AccountUser au:aus){
            System.out.println(au);
        }
    }

}

一对多查询

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

User.java

package com.yu.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 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 +
                '}';
    }
}

IUserDao.java

package com.yu.dao;

import com.yu.domain.User;

import java.util.List;

/**
 * 用户的持久层接口
 */
public interface IUserDao {
    /**
     * 查询所有的用户，及对应的账户信息
     */
    List<User> findAll();
    

}

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

    <!--定义User的resultMap-->
    <resultMap id="userAccountMap" 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>
        <!--配置user对象中accounts集合的映射-->
        <collection property="accounts" ofType="account">
            <id column="aid" property="id"></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>

    <!--根据id查询用户-->
    <select id="findById" parameterType="INT" resultType="com.yu.domain.User">
        SELECT * FROM USER where id = #{uid}
    </select>


</mapper>

UserTest.java

package com.yu.test;

import com.yu.dao.IUserDao;
import com.yu.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());
        }
    }
}

多对多查询

创建工程->Maven ->不勾create from ->com.yu -> day03_eesy_04many2many（初始代码和day03_eesy_03one2many一样，删除account有关内容）

查询所有的角色，及对应的用户信息

Role.java

package com.yu.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 + '\'' +
                '}';
    }
}

IRoleDao.java(接口)

package com.yu.dao;

import com.yu.domain.Role;

import java.util.List;

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="com.yu.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="birthday" property="birthday"></result>
            <result column="sex" property="sex"></result>
            <result column="address" property="address"></result>
        </collection>
    </resultMap>
    <!--查询所有的角色，及对应的用户信息-->
    <!--长sql语句换行时记得加空格-->
    <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>

RoleTest.java

package com.yu.test;

import com.yu.dao.IRoleDao;
import com.yu.domain.Role;
import com.yu.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 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());
        }
    }
}

查询所有的用户，及对应的角色信息

User.java

package com.yu.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 String address;
    private String sex;
    private Date birthday;

    //多对多的关系映射：一个用户可以具备多个角色
    private List<Role> roles;

    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

    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 +
                '}';
    }
}

IUserDao.java

package com.yu.dao;

import com.yu.domain.User;

import java.util.List;

/**
 * 用户的持久层接口
 */
public interface IUserDao {
    /**
     * 查询所有的用户，及对应的角色信息
     */
    List<User> findAll();

}

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

    <!--定义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>
        <!--配置user对象中roles集合的映射-->
        <collection property="roles" ofType="role">
            <id property="roleId" column="rid"></id>
            <result property="roleName" column="role_name"></result>
            <result property="roleDesc" column="roleDesc"></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>

</mapper>

UserTest

package com.yu.test;

import com.yu.dao.IUserDao;
import com.yu.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.getRoles());
        }
    }

}

5 补充 JNDI

JNDI：Java Naming and Directory Interface。
是SUN公司推出的一套规范，属于JavaEE技术之一。
目的是模仿windows系统中的注册表。
在服务器中注册数据源：

创建maven的war工程

创建工程->Maven ->勾create from -> maven-archetype-webapp ->com.yu -> day03_eesy_05jndi

通过new directory的方式复刻day03_eesy_01datasourceAndTx\src下的目录结构
java->右键 -> mark directory as -> sources root
resources->右键 -> mark directory as ->resources root
test->java->右键 -> mark directory as ->test sources root
把day03_eesy_01datasourceAndTx\src下的main和test分别拷贝到day03_eesy_05jndi相应位置下

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.yu</groupId>
  <artifactId>day03_eesy_05jndi</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>day03_eesy_05jndi Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.5</version>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.6</version>
    </dependency>

    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.12</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.10</version>
    </dependency>

    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
    </dependency>

    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.0</version>
    </dependency>
  </dependencies>

  <build>
    <finalName>day03_eesy_05jndi</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

在webapp下new directory -> META-INF
在META-INF下新建 context.xml

<?xml version="1.0" encoding="UTF-8"?>
<Context>
<!-- 
<Resource 
name="jdbc/eesy_mybatis"						数据源的名称
type="javax.sql.DataSource"						数据源类型
auth="Container"								数据源提供者
maxActive="20"									最大活动数
maxWait="10000"									最大等待时间
maxIdle="5"										最大空闲数
username="root"									用户名
password="1234"									密码
driverClassName="com.mysql.jdbc.Driver"			驱动类
url="jdbc:mysql://localhost:3306/eesy_mybatis"	连接url字符串
/>
 -->
<Resource 
name="jdbc/eesy_mybatis"
type="javax.sql.DataSource"
auth="Container"
maxActive="20"
maxWait="10000"
maxIdle="5"
username="root"
password="root"
driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/eesy"
/>
</Context>

SqlMapConfig.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 resource="jdbcConfig.properties">

    </properties>
    <typeAliases>
        <package name="com.yu.domain"/>
        <package name="其它包"/>
    </typeAliases>
    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql的环境-->
        <environment id="mysql">
            <!--配置事务-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置连接数据库的必备信息 type属性表示是否使用数据源（连接池）-->
            <dataSource type="JNDI">
                <property name="data_source" value="java:comp/env/jdbc/eesy_mybatis"/>
            </dataSource>
        </environment>
    </environments>
    <!--配置映射文件的位置-->
    <mappers>
        <!--<mapper resource="com/yu/dao/IUserDao.xml"></mapper>-->
        <!--package标签是用于指定dao接口所在的包，当指定了之后就不需要再写mapper以及resource或者class了-->
        <package name="com.yu.dao"></package>
    </mappers>
</configuration>

index.jsp

<%@ page import="java.io.InputStream" %>
<%@ page import="org.apache.ibatis.io.Resources" %>
<%@ page import="org.apache.ibatis.session.SqlSessionFactoryBuilder" %>
<%@ page import="org.apache.ibatis.session.SqlSessionFactory" %>
<%@ page import="org.apache.ibatis.session.SqlSession" %>
<%@ page import="com.yu.dao.IUserDao" %>
<%@ page import="com.yu.domain.User" %>
<%@ page import="java.util.List" %>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<html>
<body>
<h2>Hello World!</h2>
<%
    //1 读取配置文件
    InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
    //2 创建SqlSessionFactory工厂
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    SqlSessionFactory factory = builder.build(in);
    //3 使用工厂生产 SqlSession对象
    SqlSession sqlSession = factory.openSession();
    //4 使用SqlSession创建Dao接口的代理对象
    IUserDao userDao = sqlSession.getMapper(IUserDao.class);
    //5 使用代理对象执行方法
    List<User> users = userDao.findAll();
    for (User user:users){
        System.out.println(user);
    }
    //6 释放资源
    sqlSession.close();
    in.close();
%>
</body>
</html>

配置tomcat
Edit configuration -> 左上 + -> Tomcat Server ->local ->命名，完成configure配置 ->Deployment-> + ->Artifact