MyBatis-Day3
外层应该建一个empty project,然后里面new maven工程
第1章 Mybatis 连接池与事务深入 （原理部分了解，应用部分会用
1.mybatis中连接池使用及分析
1、连接池：
我们在实际开发中都会使用连接池。
因为它可以减少我们获取连接所消耗的时间。
连接池就像一个容器，即取即用，释放后回到队尾。容器其实就是一个集合对象，该集合必须是线程安全的，不能两个线程拿到同一个连接。该集合还必须实现队列的特性：先进先出。
Mybatis关于连接池的配置在main/resources目录下的主配置文件sqlMapconfig.xml中：
<envriment>标签里面
<dataSource type> = "POOLED">
type属性的取值有3种：
1.POOLED（我们用这种）：采用传统的javax.sql.DataSource规范中的连接池（有加synchronized保证线程安全），mybatis中有针对规范的实现。 PooledDataSource连接池分为空闲池与活动池，若空闲池中没有连接，会从活动池中取最先开始活动的连接。
2.UNPOOLED（也了解一下）：采用传统的获取连接的方式(需要手动释放资源的那种？就是我们写jdbc连接那种)，不使用连接池。UnPooledDataSource
3.JNDI（扩展学习）：采用服务器提供的JNDI技术实现，来获取DataSource对象，不同服务器不同。不是web或maven的war工程，不能使用。
新建maven工程day03_eesy_01datasource&Tx!!!
复制day02的main和test到这个工程的src，然后复制pom.xml的dependence,这次竟然只需要右边选中maven刷新就好了
然后观察SqlMapConfig.xml中的连接池配置，分别在<datasource>标签type=pooled和=unpooled运行测试类查看日志对比。
pooled方式关于连接池的使用流程源码和流程图：
2.mybatis事务控制的分析
事务的四大特性ACID 原子性，持久性，一致性，隔离性
不考虑隔离性会产生的3个问题 幻读，脏读，不可重复读
解决办法：四种隔离级别 忘了，300集讲过，有空复习再说。。。
以上3个是常见面试题
mybatis中是通过sqlsession对象的commit方法和rollback方法实现事务的提交和回滚
openSession(这里写true)也可以自动提交，就不用释放资源前sqlSession.commit()手动提交，但不推荐用。因为只有每次执行一个对数据库的crud操作才可以自动提交，若是遇到转账这种在一个方法里多次同数据库交互，每个方法独立自动提交就控制不住事务。
第2章 Mybatis基于XML配置的动态SQL语句使用 （会用即可
新建一个maven模块day03_eesy_02dynamicSQL!!! 虽然上一个啥也没干就看了看源码和运行log。
复制day03_01的main和test到这个工程的src，然后复制pom.xml的dependence，把dao接口和dao.xml中增删改和查询条数方法注释掉，怕影响。
mappers配置文件dao.xml中的几个标签：
1.<if>
IUserDao接口增加方法
/**
* 根据传入参数条件查询
* @param user 查询的条件有可能是姓名，有可能是性别等等不确定
* 怎么有点像上面的vo在xml中配置输入#{user.name}啥的...但vo好像不能根据多个？只是比较方便改设置某个属性当条件?
* 不过这里好像是if user参数的属性有name，则用name的意思？后来还加了sex这里也不用改的。
* @return
*/
List<User> findUserByCondition(User user);
IUserDao.xml
<!--根据条件查询 这里要注意是sql语句里的则不需要区分大小写，但if标签里的不在语句里，则需要对应属性对应写清楚-->
<select id="findUserByCondition" resultMap="userMap" parameterType="user">
select * from user where 1=1
<if test="userName != null">
and username = #{userName}
</if>
<if test="userSex != null">
and sex = #{userSex}//橘色部分是sql语句 感觉很生疏...忘得好快。。。
</if>//绿色部分是xml配置动态sql，使sql执行根据if条件查询
</select>
如果if条件不止给定姓名性别，太多条件的话也可以用下面这种写where标签，不用写where 1=1了，but我感觉没区别...
2.<where>
<select id="findUserByCondition" resultMap="userMap" parameterType="user">
SELECT *FROM USER
<where>
<if test="userName != null">
and username = #{userName}
</if>
<if test="userSex != null">
and sex = #{userSex}
</if>
</where>
</select>
MybatisTest中写测试
@Test
public void testFindByCondition(){
User u = new User();
u.setUserName("老王");
u.setUserSex("女");
//5.执行查询所有方法
List<User> users = userDao.findUserByCondition(u);
for(User user : users){
System.out.println(user);
}
}
运行结果：找到叫老王的女的，输出这条数据
3.<foreach>
需求
传入多个 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实体类 中加入一个 List 集合用于封装参数
private List<Integer> ids;
我理解的是这个vo类就是一个总的条件查询类 比如有某一列作为查询条件就像day2第三章的dao.xml是找#{User.某列}。
(这里因为用了具体列的多个，所以把具体列的多个设为一个集合作为属性。用的时候就这个#{ids.索引}遍历取值？哦不是，是用foreach标签把id加入集合的形式了，具体见dao.xml。）
然后对其生成set,get方法
第二步：
持久层 IUserDao 接口 增加对应根据vo对象的属性查询数据的抽象方法
/**
* 根据 id 集合查询用户
* @param vo 传入的vo对象是总的查询条件对象
* @return
*/
List<User> findUserInIds(QueryVo vo);
第三步：
持久层 IUserDao.xml 映射配置
<!-- select * from user where id in (1,2,3,4,5); -->
这个sq中的in就由foreach标签来完成，<foreach>标签用于遍历集合，它的属性：
collection:代表要遍历的集合元素，注意编写时不要写#{}
open:代表语句的开始部分
close:代表结束部分
item:代表遍历集合的每个元素，生成的变量名
sperator:代表分隔符
<!-- 根据queryvo中的Id集合实现查询用户列表 --> <select id="findUserInIds" resultMap="userMap" 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>
第四步：
在MybatisTest中编写测试类
/** * 测试foreach标签的使用 */ @Test public void testFindInIds(){ QueryVo vo = new QueryVo(); List<Integer> list = new ArrayList<Integer>(); list.add(41); list.add(42); list.add(46); vo.setIds(list); //5.执行查询所有方法 List<User> users = userDao.findUserInIds(vo); for(User user : users){ System.out.println(user); } }
运行结果：取出了41,42,46号id的user整行数据
4.<sql> （了解即可）
Sql 中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的。
定义代码片段 ：
<!-- 抽取重复的语句代码片段 -->
<sql id="defaultSql"> select * from user </sql>
引用代码片段 ：
<!-- 比如配置查询所有操作 -->
<select id="findAll" resultType="user">
<include refid="defaultSql"></include> （就不用写sql了
</select>
第3章 mybatis中的多表操作（掌握应用，重要
表之间的关系有几种：
一对多，多对一，一对一，多对多
举例：
用户和订单就是一对多
订单和用户就是多对一
一个用户可以下多个订单
多个订单属于同一个用户（特例：如果拿出每一个订单，他都只能属于一个用户，所以Mybatis就把多对一看成了一对一。
人和身份证号就是一对一
一个人只能有一个身份证号
一个身份证号只能属于一个人
老师和学生之间就是多对多
一个学生可以被多个老师教过
一个老师可以交多个学生
mybatis中的多表查询：
示例：用户和账户（用这个示例讲mybatis的多表操作）
一个用户可以有多个账户
一个账户只能属于一个用户（多个账户也可以属于同一个用户）
步骤：
1、建立两张表：用户表user，账户表account（语句在资料里，还是use eesy;数据库中建表
让用户表和账户表之间具备一对多的关系：需要使用外键在账户表中添加
2、建立两个实体类：用户实体类User和账户实体类Account
让用户和账户的实体类能体现出来一对多的关系
3、建立两个数据库操作接口和映射配置文件
用户的数据库操作接口IUserDao和映射配置文件IUserDao.xml
账户的数据库操作接口IAccountDao和映射配置文件IAccountDao.xml
4、实现配置：
当我们查询用户时，可以同时得到用户下所包含的账户信息
当我们查询账户时，可以同时得到账户的所属用户信息
创建模块day03_eesy_03one2many，拷贝上一个工程中的main和test到src中，包括pom.xml文件
IUsedao接口和对应的映射文件xml修改，只留下查询一个和查询所有
把User实体类的属性根数据库列名写对应了，就不用resultMap或是起别名省事儿。
由于我们sqlmapconfig.xml里面设的<package>标签所以不用再增改sqlmapconfig.xml的配置
编写测试类AccountTest测试查询账户表所有记录，测试成功
运行结果：
--------每个account的信息------------
Account{id=1, uid=46, money=1000.0}
--------每个account的信息------------
Account{id=2, uid=45, money=1000.0}
--------每个account的信息------------
一对一查询（一个账户找一个用户）
在获取账户信息的同时，想要增加该账户的用户信息
SELECT * FROM account a,USER u WHERE u.`id`= a.`uid`; -- 叫做uid因为你列名就叫uid啊我晕搜半天uid是啥。。是自己建的外键名啊
简练一些，重复信息不要
SELECT account.*,user.username, user.address FROM account,USER WHERE account.uid = user.id
我们现在的工程里account类的信息无法获取用户信息，所以新建AccountUser类，该类继承account（因为是从账户找用户）,添加username和address属性
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中添加从账户找用户的方法
List<AccountUser> findAllAccount();
IAccounrDao.xml中添加配置
<!--查询所有账户同时包含用户名和地址信息-->
<select id="findAllAccount" resultType="accountuser">
select a.*,u.username,u.address from account a , user u where u.id = a.uid;
</select>
AccountTest测试
/**
* 测试查询所有账户，同时包含用户名称和地址
*/
@Test
public void testFindAllAccountUser(){
List<AccountUser> aus = accountDao.findAllAccount();
for(AccountUser au : aus){
System.out.println(au);
}
}
运行结果：
Account{id=1, uid=46, money=1000.0} AccountUser{username='老王', address='北京'}
Account{id=2, uid=45, money=1000.0} AccountUser{username='传智播客', address='北京金燕龙'}
Account{id=3, uid=46, money=2000.0} AccountUser{username='老王', address='北京'}
上面这种用账户查询用户信息，即用子类查询实际很少用。主要是为了讲如何把sql语句
select a.*,u.username,u.address from account a , user u where u.id = a.uid;
实现。
我们应该让用户和账户的实体类能体现出来一对多的关系，不是这样新建AccountUser类,而是在Account类即从表实体中包含一个主表实体对象的引用。
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 + '\'' + '}'; } }
AccountDao接口类中方法不用改，（？虽然显示返回account类但是实际是xml中的resultMap决定？
/**
* 查询所有账户，同时还要获取到当前账户的所属用户信息
* @return
*/
List<Account> findAll();
然后在映射配置文件AccountDao.xml中,就不能使用之前AccountUser类作为返回类型了，但是也不能用单纯的resultType=account因为user信息出不来。（？为啥不用tostring。哦哦哦因为会这样Account{id=1, uid=46, money=1000.0, user=null} ）。
这时候就要借助resultMap了！！！把两个实体类的信息都显示出来！其中association标签关联另一个类
<!-- 一对一的关系映射：配置封装user的内容-->
<association property="user" column="uid" javaType="user">
还有sql语句重要!!!a的id主键起个别名为aid。其他列名对应属性名写到resultMap的pro标签
select u.*,a.id as aid,a.uid,a.money from account a , user u where u.id = a.uid;
<?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.xxw.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> <!--<!–查询所有账户同时包含用户名和地址信息–>--> <!--<select id="findAllAccount" resultType="accountuser">--> <!--select a.*,u.username,u.address from account a , user u where u.id = a.uid;--> <!--</select>--> </mapper>
AccountTest类中测试
/** * @author 黑马程序员 * @Company * * 测试mybatis的crud操作 */ 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); // } // } }
运行结果：
--------每个account的信息------------
Account{id=1, uid=46, money=1000.0}
User{id=46, username='老王', address='北京', sex='女', birthday=Wed Mar 07 17:37:26 CST 2018}
--------每个account的信息------------
Account{id=2, uid=45, money=1000.0}
User{id=45, username='传智播客', address='北京金燕龙', sex='男', birthday=Sun Mar 04 12:04:06 CST 2018}
--------每个account的信息------------
Account{id=3, uid=46, money=2000.0}
User{id=46, username='老王', address='北京', sex='女', birthday=Wed Mar 07 17:37:26 CST 2018}
以上就是一对一的查询实现，主要是在从表实体类引用主表实体类，返回结果借助resultMap!!!!
一对多查询（一个用户，多个账号）
主表实体应该包含从表的集合
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 + '}'; } }
Dao接口类的findAll方法也是不用改
主要是IUserDao.xml中的sql语句和结果集封装
这个关联的是账户集合，用<collection >标签封装集合不再是之前的<association
<!-- 配置user对象中accounts!!!集合!!!的映射 -->
<collection property="accounts" ofType="account">
sql语句： SELECT * FROM USER u LEFT OUTER JOIN account a ON u.id = a.uid;
<?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.xxw.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> <select id="findById" parameterType="INT" resultType="com.xxw.domain.User"> select * from user where id = #{uid} </select> </mapper>
UserTest测试类：
public class UserTest { private InputStream in; private SqlSession sqlSession; private IUserDao userDao; @Before//用于在测试方法执行之前执行（把那些重复的构建工厂获取代理的代码放到@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(); //4.获取dao的代理对象 userDao = sqlSession.getMapper(IUserDao.class); } @After//用于在测试方法执行之后执行（重复的释放资源操作） public void destroy()throws Exception{ //提交事务!不然sava没有提交就会自动回滚 sqlSession.commit(); //6.释放资源 sqlSession.close(); in.close(); } /** * 测试查询所有 */ @Test public void testFindAll(){ //5.执行查询所有方法 List<User> users = userDao.findAll(); for(User user : users){ System.out.println("---每个用户信息和用户对应的账户信息----"); System.out.println(user); System.out.println(user.getAccounts()); } } /** * 测试根据id查询用户信息操作 */ @Test public void testFindOne(){ //5.执行查询一个方法 User user = userDao.findById(49); System.out.println(user); } }
运行结果：
---每个用户信息和用户对应的账户信息----
User{id=45, username='传智播客', address='北京金燕龙', sex='男', birthday=Sun Mar 04 12:04:06 CST 2018}
[Account{id=null, uid=45, money=1000.0}]
---每个用户信息和用户对应的账户信息----
User{id=46, username='老王', address='北京', sex='女', birthday=Wed Mar 07 17:37:26 CST 2018}
[Account{id=null, uid=46, money=1000.0}, Account{id=null, uid=46, money=2000.0}] 这里可以看到mybatis自动识别到两次id为46的是同一个，把帐户信息封装到了同一个list给id46的用户。
---每个用户信息和用户对应的账户信息----
User{id=48, username='小马宝莉', address='北京修正', sex='女', birthday=Thu Mar 08 11:44:00 CST 2018}
[] id48的用户没有账户
多对多
示例：用户和角色
一个用户可以有多个角色
一个角色可以赋予多个用户
步骤：
1、建立两张表：用户表，角色表
让用户表和角色表具有多对多的关系(各自引入对方类做属性)。需要使用中间表，中间表中包含各自的主键，在中间表中是外键。
2、建立两个实体类：用户实体类和角色实体类 Role.java User.java
让用户和角色的实体类能体现出来多对多的关系--->各自包含对方一个集合引用
3、建立两个配置文件
用户的配置文件 IUser.xml
角色的配置文件 IRole.xml
4、实现配置：
当我们查询用户时，可以同时得到用户所包含的角色信息
当我们查询角色时，可以同时得到角色的所赋予的用户信息
创建模块day03_eesy_04many2many，拷贝上一个工程的代码，删减代码，只留下与用户相关的信息即可（IUserDao接口和映射文件，User实体类）
数据库中增加表role,表user_role(中间表），我们的需求是查询所有的角色，同时获取角所赋予的用户。
应该复习一下多表查询的sql：左外连接是内连接的基础上保证左表数据全出现(这里把角色放左边
先从user表中查出有角色的人，再从中查出对应的身份：
然后要去掉中间表的信息（这个语句的逻辑没太看懂。。。qwq...但是意思大概明白是保留u和r表...但是为什么可以执行？？？拆开看select u.*,r.* from role r这一句就是无法执行的啊？
明白了。。。先是后面的执行可能 最后在后面形成的表里选u.*和r.* 前面的也是这个，因为要加上select * from才能显示
r表的id起别名为rid再来一次
sql语句达成：
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;
完善IRole.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.xxw.dao.IRoleDao"> <!-- 定义User的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> <!-- 配置role对象中users!!!集合!!!的映射 --> <collection property="users" ofType="user"> <id column="id" property="id"></id> <result column="username" property="username"></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>
编写测试类RoleTest：
public class RoleTest { private InputStream in; private SqlSession sqlSession; private IRoleDao roleDao; @Before//用于在测试方法执行之前执行（把那些重复的构建工厂获取代理的代码放到@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(); //4.获取dao的代理对象 roleDao = sqlSession.getMapper(IRoleDao.class); } @After//用于在测试方法执行之后执行（重复的释放资源操作） public void destroy()throws Exception{ //提交事务!不然sava没有提交就会自动回滚 sqlSession.commit(); //6.释放资源 sqlSession.close(); in.close(); } /** * 测试查询所有 */ @Test public void testFindAll(){ //5.执行查询所有方法 List<Role> roles = roleDao.findAll(); for(Role role : roles){ System.out.println("---每个角色的信息----"); System.out.println(role); System.out.println(role.getUsers()); } } }
运行结果：
---每个角色的信息----
Role{roleId=1, roleName='院长', roleDesc='管理整个学院'}
[User{id=41, username='老王', address='null', sex='男', birthday=Tue Feb 27 17:47:08 CST 2018}, User{id=45, username='传智播客', address='null', sex='男', birthday=Sun Mar 04 12:04:06 CST 2018}]
---每个角色的信息----
Role{roleId=2, roleName='总裁', roleDesc='管理整个公司'}
[User{id=41, username='老王', address='null', sex='男', birthday=Tue Feb 27 17:47:08 CST 2018}]
---每个角色的信息----
Role{roleId=3, roleName='校长', roleDesc='管理整个学校'}
[]
反过来写User表左联Role表也是一样的步骤和操作:(从每一个用户获取他对应的角色信息
sql: 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;
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 + '}'; } }
public interface IUserDao { /** * 查询所有用户 * @return */ List<User> findAll(); /** * 根据id查询用户信息 * @param userId * @return */ User findById(Integer userId); }
<?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.xxw.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> <!-- 配置角色集合的映射 --> <collection property="roles" ofType="role"> <id property="roleId" column="rid"></id> <result property="roleName" column="role_name"></result> <result property="roleDesc" column="role_desc"></result> </collection> </resultMap> <!-- 查询所有 --> <select id="findAll" resultMap="userMap"> select u.*,r.id as rid,r.role_name,r.role_desc from user u left outer join user_role ur on u.id = ur.uid left outer join role r on r.id = ur.rid </select> <select id="findById" parameterType="INT" resultType="com.xxw.domain.User"> select * from user where id = #{uid} </select> </mapper>
public class UserTest { private InputStream in; private SqlSession sqlSession; private IUserDao userDao; @Before//用于在测试方法执行之前执行（把那些重复的构建工厂获取代理的代码放到@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(); //4.获取dao的代理对象 userDao = sqlSession.getMapper(IUserDao.class); } @After//用于在测试方法执行之后执行（重复的释放资源操作） public void destroy()throws Exception{ //提交事务!不然sava没有提交就会自动回滚 sqlSession.commit(); //6.释放资源 sqlSession.close(); in.close(); } /** * 测试查询所有 */ @Test public void testFindAll(){ //5.执行查询所有方法 List<User> users = userDao.findAll(); for(User user : users){ System.out.println("---每个用户信息和用户对应的账户信息----"); System.out.println(user); System.out.println(user.getRoles()); } } /** * 测试根据id查询用户信息操作 */ @Test public void testFindOne(){ //5.执行查询一个方法 User user = userDao.findById(49); System.out.println(user); } }
findAll方法测试运行结果：
---每个用户信息和用户对应的账户信息----
User{id=41, username='老王', address='北京', sex='男', birthday=Tue Feb 27 17:47:08 CST 2018}
[Role{roleId=1, roleName='院长', roleDesc='管理整个学院'}, Role{roleId=2, roleName='总裁', roleDesc='管理整个公司'}]
---每个用户信息和用户对应的账户信息----
User{id=42, username='小二王', address='北京金燕龙', sex='女', birthday=Fri Mar 02 15:09:37 CST 2018}
[]
---每个用户信息和用户对应的账户信息----
User{id=45, username='传智播客', address='北京金燕龙', sex='男', birthday=Sun Mar 04 12:04:06 CST 2018}
[Role{roleId=1, roleName='院长', roleDesc='管理整个学院'}]
---每个用户信息和用户对应的账户信息----
成功。
补充知识：JNDI
就昨天那个连接池第3种TYPE
JNDI：java命名和目录接口，作用是模仿windows系统的注册表。注册表是map结构的
