目录
连接池
事务
动态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)可以设置成自动提交事务,自动提交不安全。
userDao.java
/**
* 根据传入的参数条件查询
* @param user 查询的条件,有可能有用户名,有可能有性别,有可能有地址……
* 可能全部条件都有,可能一个都没有,可能只有一部分
* @return
*/
ListfindUserByCondition(User user);
UserDao.xml
如果参数条件很多的话,用if标签就显得很复杂,用where标签把我们刚才写的if标签的代码包围起来可以省略掉where 1=1
UserDao.xml
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】
我们可以用sql标签抽取重复的sql语句
表之间的关系有以下几种:
一对多
多对一
一对一
多对多
举例(一):
一个用户可以下多个订单,多个订单属于同一个用户
(用户和订单就是一对多的关系,订单和用户就是多对一的关系)
举例(二):
一个人只能有一个身份证号码,一个身份证号码只属于一个人
(人和身份证号码就是一对一的关系)
举例(三):
一个学生可以被多个老师教过,一个老师可以教多个学生
(学生和老师就是多对多的关系)
特例:
如果拿出每一个订单,它都只能属于一个用户
那么mybatis会把多对一看成一对一
示例:用户和账户
一个用户可以有多个账户,一个账户只能属于一个用户
步骤:
(让用户表和账户表之间具备一对多的关系,需要在账户表中添加外键)
(让用户和账户的实体类能体现出一对多的关系)
当我们查询用户时,可以同时得到用户下所包含的账户信息
当我们查询账户时,可以同时得到账户的所属用户信息
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.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属性
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());
}
}
结果:
实例:用户和角色
一个用户可以有多个角色,一个角色可以赋予多个用户
所以说用户和角色之间是多对多的关系
步骤:
让用户表和角色表具有多对多的关系,需要使用中间表,中间表中包含各自的主键,在中间表中是外键
让用户和角色的实体类能体现出多对多的关系
(各自包含对方一个集合引用)
当我们查询用户时,可以同时得到用户下所包含的角色信息
当我们查询角色时,可以同时得到角色的所赋予的用户信息
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());
}
}
结果:
步骤和之前类似