mybatis学习（四）连接池、事务、动态SQL、多表查询
目录
连接池
事务
动态SQL
1、if标签
2、where标签
3、foreach标签
4、sql标签
多表操作
（一）一对多、多对一 、一对一
1、查询所有账户，在账户信息后显示所属的用户的用户名和用户性别
方式一：写Account的子类AccountUser，继承Account另外添加用户名和用户性别
方式二：我们在从表实体类Account中添加一个主表实体类User的对象引用
2、查询所有用户，并显示用户拥有的所有账户的信息
一对多关系映射，主表实体类User应该包含从表实体类Account的集合引用
（二）多对多
1、查询用户，得到用户包含的所有角色信息
2、查询角色时，同时得到角色的所赋予的用户信息
连接池
主配置文件SqlMapConfig.xml中的dataSource标签，type属性就是表示采用何种连接池方式
type属性的取值：
POOLED：采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现
UNPOOLED：采用传统的获取连接的方式，虽然也实现了java.x.sql.DataSource接口，但是并没有使用池的思想；每次使用都重新获取一个连接
JNDI：采用服务器提供的JNDI技术实现，来获取DataSource对象，不同的服务器所能拿到的DataSource时不一样的
事务
mybatis是通过sqlsession对象的commit()方法和rollback()方法实现事务的提交和回滚
factory.openSession(true)可以设置成自动提交事务，自动提交不安全。
动态SQL
1、if标签
- 我们设想一个场景：
前端可能传来用户名，让后端查询用户
前端也可能传来用户名、用户地址，让后端查询用户
我们不确定有多少个参数条件，此时可以用动态SQL的if标签解决
userDao.java
/**
* 根据传入的参数条件查询
* @param user 查询的条件，有可能有用户名，有可能有性别，有可能有地址……
* 可能全部条件都有，可能一个都没有，可能只有一部分
* @return
*/
ListfindUserByCondition(User user);
UserDao.xml
2、where标签
如果参数条件很多的话，用if标签就显得很复杂，用where标签把我们刚才写的if标签的代码包围起来可以省略掉where 1=1
UserDao.xml
3、foreach标签
select * from user where id in (2,5,7);
collection：代表要遍历的集合元素
open：代表语句开始的部分
close：代表结束部分
item：代表遍历集合的每个元素，生成的变量名，要与#{ } 内的变量名保存一致
sperator：代表分隔符
【QueryVo.class】
package com.mybatis.domain;
import java.util.List;
public class QueryVo {
//根据ids查询用户
private List ids;
public List getIds() {
return ids;
}
public void setIds(List ids) {
this.ids = ids;
}
}
=================================================
【 UserDao接口】
package com.mybatis.dao;
import com.mybatis.domain.QueryVo;
import com.mybatis.domain.User;
import org.apache.ibatis.annotations.Select;
import java.util.List;
/**
* @Description: 用户持久层接口
*/
public interface UserDao {
/**
* @Description: 根据queryvo中提供的id集合查询用户信息
*/
List findUserInIds(QueryVo vo);
}
============================================================================
【userDao.xml】
4、sql标签
我们可以用sql标签抽取重复的sql语句
多表操作
表之间的关系有以下几种：
一对多
多对一
一对一
多对多
举例（一）：
一个用户可以下多个订单，多个订单属于同一个用户
（用户和订单就是一对多的关系，订单和用户就是多对一的关系）
举例（二）：
一个人只能有一个身份证号码，一个身份证号码只属于一个人
（人和身份证号码就是一对一的关系）
举例（三）：
一个学生可以被多个老师教过，一个老师可以教多个学生
（学生和老师就是多对多的关系）
特例：
如果拿出每一个订单，它都只能属于一个用户
那么mybatis会把多对一看成一对一
（一）一对多、多对一 、一对一
示例：用户和账户
一个用户可以有多个账户，一个账户只能属于一个用户
步骤：
- 先建两张表：用户表user和账户表account
（让用户表和账户表之间具备一对多的关系，需要在账户表中添加外键）
- 建立两个实体类，接口：用户实体类和账户实体类
（让用户和账户的实体类能体现出一对多的关系）
- 建立两个配置文件：用户的配置文件和账户的配置文件
- 实现配置：
当我们查询用户时，可以同时得到用户下所包含的账户信息
当我们查询账户时，可以同时得到账户的所属用户信息
1、查询所有账户，在账户信息后显示所属的用户的用户名和用户性别
方式一：写Account的子类AccountUser，继承Account另外添加用户名和用户性别
package com.mybatis.domain;
public class AccountUser extends Account{
//继承Account，另外添加用户名和用户性别，在toString方法中super.toString
private String username;
private String sex;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
return super.toString()+"AccountUser{" +
"username='" + username + '\'' +
", sex='" + sex + '\'' +
'}';
}
}AccountDao接口：
package com.mybatis.dao;
import com.mybatis.domain.Account;
import com.mybatis.domain.AccountUser;
import java.util.List;
public interface AccountDao {
/*查询所有账户*/
List findAll();
/*查询所有账户,并且带有用户名称和性别信息,
* 通过新建一个AccountUser类，继承Account，保存用户名和性别信息*/
List findAllAccount();
} AccountDao.xml：select * from account a,user u WHERE u.id=a.UID;
AccountTest.java
package com.mybatis;
/*Mybatis入门案例*/
public class AccountTest {
private InputStream in;
private SqlSession sqlSession;
private AccountDao accountDao;
@Before //测试方法之前执行
public void init()throws IOException{
//1.读取配置文件
in= Resources.getResourceAsStream("SqlMapConfig.xml");
//2.创建SqlSessionFactory工厂
SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
SqlSessionFactory factory=builder.build(in);
//3.使用工厂生产SqlSession对象
sqlSession =factory.openSession();
//4.使用SqlSession创建Dao接口的代理对象
accountDao=sqlSession.getMapper(AccountDao.class);
}
@After //测试方法之后执行
public void destroy() throws IOException {
//提交事务
sqlSession.commit();
//6.释放资源
sqlSession.close();
in.close();
}
@Test//查询所有记录,并且带有用户名称和性别
public void testfindAllAccount() throws IOException {
//5.使用代理对象执行方法
List accounts=accountDao.findAllAccount();
for (Account account:accounts){
System.out.println(account);
}
}
}
结果：
方式二：我们在从表实体类Account中添加一个主表实体类User的对象引用
Account.java
package com.mybatis.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 +
'}';
}
}
AccountDao: 查询所有账户 List
AccountDao.xml：需要定义定义封装account和user的resultMap
resultMap标签： resultType可以把查询结果封装到pojo类型中，但必须pojo类的属性名和查询到的数据库表的字段名一致。 如果sql查询到的字段与pojo的属性名不一致，则需要使用resultMap将字段名和属性名对应起来。id：给resultMap起个名字，type：
定义主键 ,非常重要。如果是多个字段,则定义多个id property：主键在pojo中的属性名 column：主键在数据库中的列名 <result property="uid" column="uid"> 定义主键之外其他
<association property="user" column="uid" javaType="com.mybatis.domain.User">
Association：处理单一的关联对象
property：包含的其他对象
column：外键的列名，作为条件去查询关联的对象
javaType：封装给哪个类的对象，实体类的全限定路径
select属性指定的内容：根据用户的唯一标志查询用户信息
<collection property="accounts" ofType="com.mybatis.domain.Account">
collection:处理一对多
ofType：指集合中元素的类型
AccountTest.java
用SELECT属性
2、查询所有用户，并显示用户拥有的所有账户的信息
一对多关系映射，主表实体类User应该包含从表实体类Account的集合引用
user.java
package com.mybatis.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 List accounts;
public List getAccounts() {
return accounts;
}
public void setAccounts(List 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 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;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", birthday=" + birthday +
", sex='" + sex + '\'' +
'}';
}
}
UserDao接口：查询所有 List
UserDao.xml:
UserTest.java @Test//查询所有记录
public void testFindAll() throws IOException {
//5.使用代理对象执行方法
List users=userDao.findAll();
for (User user:users){
System.out.println(user);
System.out.println(user.getAccounts());
}
} 结果：
（二）多对多
实例：用户和角色
一个用户可以有多个角色，一个角色可以赋予多个用户
所以说用户和角色之间是多对多的关系
步骤：
- 建立两张表：用户表和角色表
让用户表和角色表具有多对多的关系，需要使用中间表，中间表中包含各自的主键，在中间表中是外键
- 建立两个实体类：用户实体类和角色实体类
让用户和角色的实体类能体现出多对多的关系
（各自包含对方一个集合引用）
- 建立两个配置文件：用户的配置文件和角色的配置文件
- 实现配置：
当我们查询用户时，可以同时得到用户下所包含的角色信息
当我们查询角色时，可以同时得到角色的所赋予的用户信息
1、查询用户，得到用户包含的所有角色信息
User.java
package com.mybatis.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 List roles;
public List getRoles() {
return roles;
}
public void setRoles(List 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 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;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", birthday=" + birthday +
", sex='" + sex + '\'' +
'}';
}
}
UserDao接口：查找所有用户 List
UserDao.xml: 配置 resultMap,多对多需要collection
UserTest.java @Test//查询所有记录
public void testFindAll() throws IOException {
//5.使用代理对象执行方法
List users=userDao.findAll();
for (User user:users){
System.out.println(user);
System.out.println(user.getRoles());
}
} 结果：
2、查询角色时，同时得到角色的所赋予的用户信息
步骤和之前类似
结果：