黑马就业班——mybatis框架：part3 -- mybatis的深入和多表
- 本文参考文档：《Mybatis第三天讲义.pdf》
- 本文代码项目：mybatis_day02_datasource、mybatis_day03_dynamicSQL、mybatis_day03_one2many、mybatis_day03_many2many、mybatis_day03_jndi（路径：G:\idea_java_project\）
今日内容
1. mybatis中的连接池以及事务控制原理部分了解
1）mybatis中连接池使用及分析；
2）mybatis事务控制的分析
2. mybatis基于XML配置的动态SQL语句使用
1）mappers配置文件中的几个标签：、、 、
3. mybatis中的多表操作
1) 一对多
2) 一对一
3) 多对多
1、Mybatis 连接池与事务深入
1.1 连接池
连接池：我们在实际开发中都会使用连接池。因为它可以减少我们获取连接所消耗的时间。
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连接池。
MyBatis 内部分别定义了实现了 java.sql.DataSource 接口的 UnpooledDataSource，
PooledDataSource 类来表示 UNPOOLED、 POOLED 类型的数据源。MyBatis 在初始化时， 根据的 type 属性来创建相应类型的的数据源 DataSource，即：
type="POOLED"： MyBatis 会创建 PooledDataSource 实例
type="UNPOOLED" ： MyBatis 会创建 UnpooledDataSource 实例
type="JNDI"： MyBatis 会从 JNDI 服务上查找 DataSource 实例，然后返回使用
- 在IDEA中，可以使用CTRL+N的方式来搜索想要显示的类。
MyBatis 是 通 过 工 厂 模 式 来 创 建 数 据 源 DataSource 对 象 的 ， MyBatis 定 义了抽象的工厂接口:org.apache.ibatis.datasource.DataSourceFactory,通过其 getDataSource()方法返回数据源DataSource。（具体分析过程见文档——1.1.3 Mybatis 中 DataSource 的存取）
Mybatis 中连接的获取过程分析（文档—1.1.4 Mybatis 中连接的获取过程分析，视频4,5。这部分比较重要，注意原理以及源码的分析！）
设置POOLED属性时的源码分析：
其实连接池分为空闲池以及活动池，线程会先从空闲池中获取，如果空闲池没有连接，会再去活动池中获取，如果活动池中连接的数量小于我们设置的最大数量，会创建一个新的连接放到活动池，这样线程就可以获取新的连接。如果活动池中连接的数量等于我们设置的最大数量，就会获取最老的那个连接，判断这个最老的连接是否失效，失效了就对他进行一定的设置，然后返回给线程使用。（失效就是前面使用这个连接的线程已经不再使用）
MYbatis不使用C3P0或者DBCP等连接池技术，而是使用DataSource接口，自己实现了连接池技术。
当我们需要创建 SqlSession 对象并需要执行 SQL 语句时，这时候 MyBatis 才会去调用 dataSource 对象来创建java.sql.Connection对象。也就是说， java.sql.Connection对象的创建一直延迟到执行SQL语句的时候。
1.2 事务
参考文档——1.2 Mybatis 的事务控制
关于事务，我们需要注意的是：什么是事务，事务的四大特性ACID，不考虑隔离性会产生的3个问题，解决办法：四种隔离级别。（这些是在面试中需要注意的！）
事务：是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作； 这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行；事务是一组不可再分割的操作集合（工作逻辑单元）。
参考文章：添加链接描述
mybatis中的事务是通过sqlsession对象的commit方法和rollback方法实现事务的提交和回滚。我们每次执行方法的时候，都会取消自动提交，导致我们每次执行数据库DML操作的时候，都需要手动提交事务，我们可以在获取sqlSession对象的时候，设置可以自动提交：
sqlSession = factory.openSession(true);
当然，只有在每次只执行一个数据库的DML操作的时候，才可以自动提交，如果我们的事务有多个DML操作，设置自动提交，每一个DML语句都会自动提交执行，这样事务就无法控制。一般都会手动提交事务。
2、Mybatis中的动态SQL语句
2.1 if标签与where标签
我们根据实体类的不同取值，使用不同的 SQL 语句来进行查询。比如在 id 如果不为空时可以根据 id 查询，如果 username 不同空时还要加入用户名作为条件。这种情况在我们的多条件组合查询中经常会碰到。（具体见代码–mybatis_day03_dynamicSQL，文档以及视频的解析）
2.2 foreach标签与sql标签
需求
传入多个 id 查询用户信息，用下边两个 sql 实现：
SELECT * FROM USERS WHERE username LIKE '%张%' AND (id =10 OR id =89 OR id=16)
SELECT * FROM USERS WHERE username LIKE '%张%' AND id IN (10,89,16)
这样我们在进行范围查询时，就要将一个集合中的值，作为参数动态添加进来。这样我们将如何进行参数的传递？
这里使用到QueryVo包装对象，在QueryVo增加一个存储id属性的List集合属性，并添加getter与setter方法：（具体见代码–mybatis_day03_dynamicSQL，文档以及视频的解析）
private List<Integer> ids;
可以使用sql标签定义使用频次较多的sql语句，后面需要使用的时候进行引入即可。后面使用这条语句的时候，可以使用标签引入。（具体见代码–mybatis_day03_dynamicSQL，文档以及视频的解析）
3、Mybatis的多表关联查询——一对多/多对一
具体来说，表之间的关系有4种：一对多、多对一、一对一、多对多。
//一对多与多对一
用户和订单就是一对多，订单和用户就是多对一。因为一个用户可以下多个订单，多个订单属于同一个用户。
如果拿出每一个订单，他都只能属于一个用户，所以Mybatis就把多对一看成了一对一。既Mybatis认为订单中的其中一个与用户之间是一对一的关系。
mybatis中的多表查询（参考项目：mybatis_day03_one2many）：
示例：用户和账户
一个用户可以有多个账户，一个账户只能属于一个用户（多个账户也可以属于同一个用户）
步骤：
1、建立两张表：用户表，账户表。让用户表和账户表之间具备一对多的关系，需要使用外键在账户表中添加；
2、建立两个实体类：用户实体类和账户实体类，让用户和账户的实体类能体现出一对多的关系；
3、建立两个配置文件，用户的配置文件账户的配置文件；
4、实现配置：当我们查询用户时，可以同时得到用户下所包含的账户信息；当我们查询账户时，可以同时得到账户的所属用户信息息
这部分具体见代码分析，视频12视频分析 ，及相关文档信息。
1、一对一查询（多对一）
需求
查询所有账户信息，关联查询下单用户信息。
注意：
因为一个账户信息只能供某个用户使用，所以从查询账户信息出发关联查询用户信息为一对一查询。如
果从用户信息出发查询用户下的账户信息则为一对多查询，因为一个用户可以有多个账户。
完成account表的一对一操作
account表的一对一操作，比如我们在AccountDao的findAllAccountUser方法中，查询所有账户，并且带有用户名称与地址信息（一个account账户对应一个user用户）。
通过写Account子类的方式查询（不常用）
1、我们在AccountDao中添加一个查询所有账户，并且带有用户名称与地址信息的方法
/**
* 查询所有账户，并且带有用户名称与地址信息
* @return
*/
List<AccountUser> findAllAccountUser();
2、我们发现，直接使用如下代码：
<select id="findAllAccountUser" resultType="account">
SELECT a.* , u.username , u.address FROM USER u,account a WHERE u.id = a.uid;
</select>
findAllAccountUser查询出来的结果是User与Account的信息，Account类是无法封装用户信息的。因此我们创建一个AccountUser类，继承Account，包含了username以及address2个属性，使得AccountDao的findAllAccountUser方法返回的结果是AccountUser类。
3、我们在Account.xml中添加查询标签如下：
<!--查询所有账户，并且带有用户名称与地址信息-->
<select id="findAllAccountUser" resultType="accountuser">
SELECT a.* , u.username , u.address FROM USER u,account a WHERE u.id = a.uid;
</select>
这样，findAllAccountUser方法查询出来的结果包含User的username与address信息，还有account表的所有信息，将这些信息封装到AccountUser的时候，由于AccountUser继承Account，因此account的信息可以封装到AccountUser的父类Account，而User的username与address信息可以封装到AccountUser的username与address属性中。这样，查询出来的Account与User的信息就可以封装到结果！！！
4、接下来我们测试：
@Test
public void testFindAllAccountUser()
{
List<AccountUser> allAccountUser = accountDao.findAllAccountUser();
for (AccountUser accountUser : allAccountUser)
{
System.out.println(accountUser);
}
}
结果是：
建立实体类关系的方式
1、我们在AccountDao有查询所有账户的方法findAll，同时还要获取到当前账户的所属用户信息。最后查询出来的数据封装到Account类中
List<Account> findAll();
2、我们之前提过，如果要实现多表查询，必须要让用户和账户的实体类能体现出一对多的关系。因此，从表（多，既account表）实体应该包含一个主表（一，user）实体的对象引用。
因此，我们在从表account表对应的实体类Account中，创建主表user的实体类User类的对象引用，并创建getter与setter方法。
private User user;
3、我们在AccountDao.xml中，设置一个查询标签
<select id="findAll" resultType="account">
SELECT u.* , a.id AS aid , a.uid , a.money FROM USER u,account a WHERE u.id = a.uid;
</select>
现在查询出来的结果包含account与user的信息，只能将查询出来的account表的信息封装到Account类的普通属性中，如果我们想让查询出来的对应User的数据封装到Account类的User属性，需要进行resultMap配置。
4、resultMap的配置：
<!-- 定义封装查询出来的 account和user 信息的resultMap -->
<!--
1、前面已经定义 com.lkj.domain 包下的所有实体类按其类名起别名，这里不需要再写 com.lkj.domain.Account ，直接写account，
type="account" 表示要将结果封装到com.lkj.domain.Account类
2、注意，在这个resultMap中，出现了2个id，为了避免冲突，我们给account表的id取一个别名aid。
因为我们是在<id>标签里面设置，我们直接写 column="aid" ，系统会自动将account表的id属性起别名为aid。
如果下面的SQL语句已经给id起别名为aid，那么这里必须强制起别名为aid。如果下面SQL语句没有起别名，那么这里可以取，也可以不取！！！
（只有id可以这样起别名，其他属性都是在<result>标签中设置，不可以这样起别名，而且其他属性一般不会冲突，不需要起别名）
补充：property 是实体类的属性，column 是数据库表的属性
-->
<resultMap id="accountUserMap" type="account">
<!--首先，Account类中配置封装account表查询出来的内容-->
<id property="id" column="aid"></id>
<result property="uid" column="uid"></result>
<result property="money" column="money"></result>
<!-- 一对一的关系映射：配置封装user的内容-->
<!--
1、使用<association>标签来将user表中查询出来的数据封装到Account类的user属性中。
2、property="user" 表示查询出来的user表的信息封装到Account对象的user属性
3、column="uid"，表示user表的信息要通过account表的uid对应查询
column="uid" ， 表示通过account表的 uid 属性（外键），可以确定uid对应user表中id，既可以确定user表查询出来的内容。
这样我们就可以知道查询出来的账户信息所对应的用户信息。（这里的column一般是从表的外键属性）
这里也可以理解为，我们要将查询出来的user表的信息封装到Account类的user属性，首先要通过account表的uid属性来查询user表的信息。
4、javaType属性：表示Account类中user属性的类型
我们这里将查询出来的account表的信息的uid对应的user表的信息封装到com.lkj.domain.User类，
前面已经定义 com.lkj.domain 包下的所有实体类按其类名起别名，这里不需要再写 com.lkj.domain.User ，直接写user
-->
<association property="user" column="uid" javaType="user">
<!--里面写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>
5、查询的标签定义为：
<!-- 查询所有账户，并且带有用户名称与地址信息 -->
<!--
我们将返回的结果设置为 resultMap="accountUserMap"
-->
<select id="findAll" resultMap="accountUserMap">
SELECT u.* , a.id AS aid , a.uid , a.money FROM USER u,account a WHERE u.id = a.uid;
</select>
6、测试：
/**
* 查询所有账户account,并且带有用户名称与地址信息
*/
@Test
public void testFindAll()
{
List<Account> accountList = accountDao.findAll();
for (Account account : accountList)
{
System.out.println("--------每个account的信息------------");
System.out.println(account);//只会打印Account类原有的属性，因为Account的toString只打印了它原有的属性
/*
我们查询出来的user表的信息封装到了Account类的user属性，因此我们这里需要打印Account类的user属性，
这样才会打印查询出来的user表的信息。
*/
System.out.println(account.getUser());//打印出查询出来的user表的信息
}
}
2、一对多查询
需求：
查询所有用户信息及用户关联的账户信息。
分析：
用户信息和他的账户信息为一对多关系，并且查询过程中如果用户没有账户信息，此时也要将用户信息
查询出来，我们想到了左外连接查询比较合适。（账户一定有对应的用户，但是用户不一定有对应的账户）如果不使用左外连接，那些没有账户信息的用户信息就无法查询出来。
完成user表的一对多操作
user表的一对多操作，比如我们在UserDao的findAll方法中，查询所有用户，并且获取该用户下的所有账户信息（一个user用户对应一个/多个/0个account账户，）。
1、在UserDao下有一个方法：
//查询所有用户，同时获取该用户下的所有账户信息
List<User> findAll();
2、我们想通过主表查询到对应从表的信息（一对多关系映射），此时主表实体应该包含从表实体的集合引用
private List<Account> account;//注意生成getter与setter
注意区别于从表到主表查询的一对一，一对一从表实体应该包含一个主表实体的对象引用。（因为User可能对应多个Account，而Account只能对应一个User）
3、resultMap的设置：
<!--同样，先定义封装查询出来的user（一）和account（多）信息的resultMap-->
<!--
1、查询出来的信息封装到com.lkj.domain.User中，已经起别名，使用user表示
-->
<resultMap id="userAccountMap" type="user">
<!--首先是配置User对象原有属性的映射。信息从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集合的映射。信息从account表查询-->
<!--
1、这里一对多使用的是 collection 标签，一对一使用的是<association>标签
2、property="accounts" 表示查询出来的account表的信息封装到User对象的accounts属性
3、ofType="account" 表示User类中accounts集合中元素的类型（前面SqlMapConfig.xml已经取别名，否则使用全限定类名）
4、前面在Account类中查询user属性，需要指定 column="uid" ，既通过account表的 uid 属性去查询user表，才能查询出账户对应的用户信息
但是在这里，我们在User类中查询accounts属性，则不需要指定通过user表的哪一个属性可以查询account表的信息
注意区分，主表对从表查询（一对多）配置resultMap的collection的时候不需要指定 column
-->
<collection property="accounts" ofType="account">
<!--
1、注意，在这个resultMap中，出现了2个id，为了避免冲突，我们给account表的id取一个别名aid。
因为我们是在<id>标签里面设置，我们直接写 column="aid" ，系统会自动将account表的id属性其别名为aid。
（只有id可以这样起别名，其他属性都是在<result>标签中设置，不可以这样起别名，，而且其他属性一般不会冲突，不需要起别名）
补充：property 是实体类的属性，column 是数据库表的属性
-->
<id property="id" column="aid"></id>
<result property="uid" column="uid"></result>
<result property="money" column="money"></result>
</collection>
</resultMap>
4、 查询用户信息的标签如下：
<!-- 询所有用户，同时获取该用户下的所有账户信息 -->
<!--
1、这里需要查询所有用户的信息，不管有没有账户信息，用户信息都得有。
但是想之前那样使用隐式内连接查询，没有账户的用户信息查询不到，因此使用左外链接
-->
<select id="findAll" resultMap="userAccountMap">
select * from user u left outer join account a on u.id = a.uid
</select>
5、测试
/**
* 查询所有用户，同时获取该用户下的所有账户信息
*/
@Test
public void testFindAll()
{
List<User> list = userDao.findAll();
for (User user : list)
{
System.out.println("------每个用户信息------");
System.out.println(user);
System.out.println(user.getAccounts());
}
//结果，发现所有的用户信息都打印出来，包括有账户信息以及没有账户信息的
// 对于重复的用户信息（因为一个用户有2个账户，出现对应2个账户的2个用户），mybatis会自动识别并将所有账户信息封装到一个用户中
}
注意：
collection：部分定义了用户关联的账户信息。表示关联查询结果集。
property="accounts"：关联查询的结果集存储在 User 对象的上哪个属性。
ofType="account"：指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名。
4、Mybatis 多表查询之多对多
示例：用户和角色
一个用户可以有多个角色， 一个角色可以赋予多个用户
步骤：
1、建立两张表：用户表，角色表：让用户表和角色表具有多对多的关系。需要使用中间表，中间表中包含各自的主键，在中间表中是外键。
2、建立两个实体类：用户实体类和角色实体类。让用户和角色的实体类能体现出来多对多的关系——各自包含对方一个集合引用。
3、建立两个配置文件：用户的配置文件角色的配置文件。
4、实现配置：当我们查询用户时，可以同时得到用户所包含的角色信息；当我们查询角色时，可以同时得到角色的所赋予的用户信息。
准备工作见视频15、16分析（项目：mybatis_day03_many2many）
多对多查询操作
准备
1）创建3张表并插入数据：用户表user、角色表role、中间表user_role。3张表之间的关系如下图。
2）创建role表的实体类（属性名与role表的属性名不相同），同时创建role的DAO接口：RoleDao，既其相应的xml文件RoleDao.xml。
由于我们在SqlMapConfig.xml中使用 <package name="com.lkj.dao"></package> 配置所有 com.lkj.dao 包下面的dao.xml文件的映射，因此这里不需要再在SqlMapConfig.xml中导入RoleDao.xml。
- 下面我们将多对多分解为2个反向的一对多，既一个用户对应多个角色，一个角色对应多个用户，我们可以从用户与角色2个角度进行查询。在
查询角色，获取角色下所属用户信息
1、在Role的实体类中，创建多对多的关系映射，既一个角色可以赋予多个用户。我们在Role中创建一个返回User类型集合的users属性。
private List<User> users;
2、RoleDao中的查询所有角色以及角色所属用户信息的方法为：
/**
* 查询所有角色，获取角色下所属用户信息
* @return
*/
List<Role> findAll();
3、查询的SQL语句的分析（见视频15分析，这部分是难点）
我们查询的时候，不仅要将角色信息全部查询出来，还要将角色对应的用户信息查询出来（不管角色有没有对应的用户，角色全部要显示）。此时应该利用中间表user_role。
首先，我们使用左外连接，先依据 role.id = user_role.rid ，将满足条件的role表中的信息全部查询出来。语句如下，查询出来的信息如下图1：
SELECT * FROM role r LEFT OUTER JOIN user_role ur ON r.id = ur.rid;
查询出来的是一个新的表。随后，我们根据新表中的所有uid对应user表的id，再去左外查询user表。语句如下，查询出来的信息如下图2：
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.rid;
此处结果含有多个id，为了区分，我们将role表的id命名为rid。这样，查询出来的表就包含所有role表的信息以及role表中角色对应的用户的信息（没有对应用户信息的角色也查询出来）
当然语句也可以写为下面的形式：
SELECT u.* , r_ur.id AS rid , r_ur.role_name , r_ur.role_desc FROM
(SELECT * FROM role r LEFT OUTER JOIN user_role ur ON r.id = ur.rid) r_ur
LEFT OUTER JOIN USER u ON u.id = r_ur.uid;
我们将第一次查询出来的信息命名为一个新的表r_ur，这个新的表再与user表进行左外连接的查询，我们获取user表的全部以及r_ur表的 id、role_name、role_desc 信息即可，中间表的信息不需要。（这种方法是比较容易理解的！ ）
4、resultMap的配置
<!--定义role表的resultMap-->
<!--
1、Windows系统下mysql不区分大小写，可以直接写role_desc，而不必写ROLE_DESC
2、为了避免结果id重复，将role表的id命名为rid
-->
<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>
<!--其次，配置Role对象中users集合的映射。信息从user表查询-->
<!--
1、同样，一对多使用<collection>标签；
2、property="users" 表示查询出来的user表的信息封装到Role对象的users属性
3、ofType="user" 表示Role类中users集合中元素的类型为com.lkj.domain.user（前面SqlMapConfig.xml已经取别名，否则使用全限定类名）
-->
<collection property="users" ofType="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>
</collection>
</resultMap>
5、查询语句
<!--查询所有角色，获取角色下所属用户信息-->
<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>
6、测试
/**
* 查询所有
*/
@Test
public void testFindAll()
{
List<Role> list = roleDao.findAll();
for (Role role : list)
{
System.out.println("------每个角色信息------");
System.out.println(role);
System.out.println(role.getUsers());
}
}
查询用户，获取用户所属角色信息（同样是一对多，一个用户对应多个角色）
1、查询所有用户以及用户所对应的角色信息，没有对应角色的用户信息也要查询出来。
2、SQL语句
其实把刚才的SQL语句的角色与用户调转一下即可，既先使用用户与user_role表进行查询，查询出来的表再与role表进行查询
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 u_ur.id , u_ur.username , u_ur.birthday, u_ur.sex , u_ur.address,
r.id AS rid , r.role_name , r.role_desc FROM
(SELECT * FROM USER u LEFT OUTER JOIN user_role ur ON u.id = ur.uid) u_ur
LEFT OUTER JOIN role r ON r.id = u_ur.rid; -- 起别名只在最后查询结果起作用，这里还是要使用r.id，而不是r.rid
3、同样，在User的实体类中，创建多对多的关系映射，既一个用户可以有多个角色。我们在User中创建一个返回Role类型集合的roles属性。
private List<Role> roles;
4、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>
5、查询语句
<!-- 查询所有用户以及用户包含的角色信息-->
<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>
6、测试
/**
* 查询所有用户，同时获取该用户下的所有账户信息
*/
@Test
public void testFindAll()
{
List<User> list = userDao.findAll();
for (User user : list)
{
System.out.println("------每个用户信息------");
System.out.println(user);
System.out.println(user.getRoles());
5、JNDI补充
这部分见视频17-19，以及资料中的JNDI文档。这部分不是主要内容，只对其中需要注意的部分进行说明。
JNDI：Java Naming and Directory Interface（java命名和目录接口）。是SUN公司推出的一套规范，属于JavaEE技术之一，目的是模仿windows系统中的注册表。在我们这里，JNDI是用来在Tomcat服务器中注册数据源。
下面是JNDI的结构，如下：
注意：
1、我们需要创建一个Maven的web工程来演示。（项目mybatis_day03_jndi）
2、需要在webapps下创建一个META-INF，里面放context.xml文件，内容如下，注意将数据库部分修改为我们自己的数据库内容。
<?xml version="1.0" encoding="UTF-8"?>
<Context>
<!--
<Resource
name="jdbc/eesy_mybatis" 数据源的名称（可以随便起）
type="javax.sql.DataSource" 数据源类型
auth="Container" 数据源提供者（这里指的是由Tomcat提供）
maxActive="20" 最大活动数
maxWait="10000" 最大等待时间
maxIdle="5" 最大空闲数
username="root" 用户名
password="root" 密码
driverClassName="com.mysql.jdbc.Driver" 驱动类
url="jdbc:mysql://localhost:3306/lkj_mybatis" 连接url字符串
/>
-->
<Resource
name="jdbc/lkj_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/lkj_mybatis"
/>
</Context>
3、修改SqlMapConfig.xml文件的内容，其实我们只修改了：
<!-- 配置连接数据库的必备信息 type属性表示是否使用数据源（连接池）-->
<dataSource type="JNDI">
<property name="data_source" value="java:comp/env/jdbc/lkj_mybatis"/>
</dataSource>
我们原来是自己制定数据库连接信息，或者提供jdbcComfig.properties来指定，现在是通过指定data_source 来制定，其中 value="java:comp/env/jdbc/lkj_mybatis" ，“java:comp/env/” 是固定的，而 jdbc/lkj_mybatis 是context.xml中的 name 属性的值。
4、在测试之前，需要给项目添加tomcat服务器，参考之前的黑马旅游网的文章，里面对tomcat服务器的添加做了详细的解析，我们可以使用maven自带的tomcat，也可以使用我们本地的tomcat。（这里使用本地的tomcat）
5、此时我们运行之前测试类MybatisTest中的 testFindAll 方法，发现无法运行，因为我们的测试类没有经过Tomcat服务器，也就是无法使用Tomcat服务器给我们准备的 连接数据库的JNDI的Map数据源（我们这里使用的是JNDI配置），无法连接到数据库，因此无法运行。
此时应该将测试类测试类的内容放到jsp的java代码块区域，由于jsp会经过服务器，这样它里面的java代码就会经过服务器，就可以使用JNDI准备的连接数据库的数据源Map，这样就可以访问数据库。我们访问服务器的index.jsp页面，控制台打印我们findAll方法查询的所有用户内容。
