mybatis学习（四）连接池、事务、动态SQL、多表查询

最新推荐文章于 2022-08-03 11:27:40 发布

❤ζั什么名字好呢

最新推荐文章于 2022-08-03 11:27:40 发布

阅读量244

点赞数

分类专栏： mybatis

本文链接：https://blog.csdn.net/qq_44617005/article/details/105443777

版权

mybatis 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

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
*/
List<User> findUserByCondition(User user);

UserDao.xml

<select id="findUserByCondition" resultType="com.mybatis.domain.User" parameterType="com.mybatis.domain.User">
        SELECT * FROM t_user WHERE 1=1
        <if test="username!=null">
            AND username=#{username}
        </if>
        <if test="email!=null">
            AND email=#{email}
        </if>
    </select>

2、where标签

如果参数条件很多的话，用if标签就显得很复杂，用where标签把我们刚才写的if标签的代码包围起来可以省略掉where 1=1

UserDao.xml

<select id="findUserByCondition" resultType="com.mybatis.domain.User" parameterType="com.mybatis.domain.User">
        SELECT * FROM t_user
        <where>
            <if test="username!=null">
                AND username=#{username}
            </if>
            <if test="email!=null">
                AND email=#{email}
            </if>
        </where>
    </select>

3、foreach标签

select * from user where id in (2,5,7);

<foreach>标签用于遍历集合，它的属性如下：
collection：代表要遍历的集合元素
open：代表语句开始的部分
close：代表结束部分
item：代表遍历集合的每个元素，生成的变量名，要与#{ } 内的变量名保存一致
sperator：代表分隔符

 【QueryVo.class】
package com.mybatis.domain;
import java.util.List;

public class QueryVo {
   //根据ids查询用户
    private List<Integer> ids;
   
    public List<Integer> getIds() {
        return ids;
    }
    public void setIds(List<Integer> 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<User> findUserInIds(QueryVo vo);
}

============================================================================
【userDao.xml】
<!--根据queryvo 中ids条件查询-->
    <select id="findUserInIds" parameterType="com.mybatis.domain.QueryVo" resultType="com.mybatis.domain.User">
        SELECT * FROM t_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、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<Account> findAll();

    /*查询所有账户,并且带有用户名称和性别信息,
    * 通过新建一个AccountUser类，继承Account，保存用户名和性别信息*/
    List<AccountUser> findAllAccount();
}

AccountDao.xml：select * 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.mybatis.dao.AccountDao">

    <!--查询所有账户，包括用户名、性别-->
    <select id="findAllAccount" resultType="com.mybatis.domain.AccountUser">
       select * from account a,user u WHERE u.id=a.UID;
    </select>


</mapper>

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<AccountUser> 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<Account> findAll();

AccountDao.xml：需要定义定义封装account和user的resultMap

resultMap标签：
resultType可以把查询结果封装到pojo类型中，但必须pojo类的属性名和查询到的数据库表的字段名一致。
如果sql查询到的字段与pojo的属性名不一致，则需要使用resultMap将字段名和属性名对应起来。 
id：给resultMap起个名字，type：
<id  property="id" column="aid"></id> 定义主键 ,非常重要。如果是多个字段,则定义多个id 
 property：主键在pojo中的属性名 
 column：主键在数据库中的列名
<result property="uid" column="uid"></result> 定义主键之外其他

<association property="user" column="uid" javaType="com.mybatis.domain.User">

   Association：处理单一的关联对象

   property：包含的其他对象

   column：外键的列名，作为条件去查询关联的对象

javaType：封装给哪个类的对象，实体类的全限定路径

<association property="user" column="uid" javaType="user" select="com.itheima.dao.IUserDao.findById">

  select属性指定的内容：根据用户的唯一标志查询用户信息

<collection property="accounts" ofType="com.mybatis.domain.Account">

   collection:处理一对多

ofType：指集合中元素的类型

<?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.mybatis.dao.AccountDao">

    <!--定义封装account和user的resultMap-->
    <resultMap id="accountUserMap" type="com.mybatis.domain.Account"><!--type就是指定映射到哪一个pojo -->
        <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="com.mybatis.domain.User">
            <id property="id" column="id"></id>
            <result column="username" property="username"></result>
            <result column="birthday" property="birthday"></result>
            <result column="sex" property="sex"></result>
        </association>
    </resultMap>

<!--配置查询所有，id为方法的名称，resultMap返回值封装到哪个类-->
    <select id="findAll" resultMap="accountUserMap" >
        select u.*,a.id AS aid ,a.MONEY ,a.UID from account a,user u WHERE u.id=a.UID;
    </select>


</mapper>

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<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 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<User> findAll()

UserDao.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.mybatis.dao.UserDao">

    <!--定义User的resultMap-->
    <resultMap id="userAccountMap" type="com.mybatis.domain.User">
        <id property="id" column="id"></id>
        <result property="username" column="username"></result>
        <result property="birthday" column="birthday"></result>
        <result property="sex" column="sex"></result>
        <!--配置user对象中account集合的映射property指 ,ofType指集合中元素的类型-->
        <collection property="accounts" ofType="com.mybatis.domain.Account">
            <id property="id" column="aid"></id>
            <result property="uid" column="uid"></result>
            <result property="money" column="money"></result>
        </collection>
    </resultMap>

<!--配置查询所有，id为方法的名称,resultType返回值封装到哪个实体类，实体类的全限定类名-->
       <select id="findAll" resultMap="userAccountMap">
        SELECT * from user u LEFT OUTER JOIN account a on u.id=a.uid;
    </select>

 </mapper>

UserTest.java

 @Test//查询所有记录
    public  void testFindAll() throws IOException {
        //5.使用代理对象执行方法
        List<User> 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<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 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<User> findAll();

UserDao.xml: 配置 resultMap,多对多需要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.mybatis.dao.UserDao">
    <!--定义User的resultMap-->
    <resultMap id="userMap" type="com.mybatis.domain.User">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="birthday" column="birthday"/>
        <result property="sex" column="sex"/>
        <collection property="roles" ofType="com.mybatis.domain.Role">
            <id property="roleId" column="rid"/>
            <result property="roleName" column="role_name"/>
            <result property="roleDesc" column="role_desc"/>
        </collection>
    </resultMap>

<!--配置查询所有，id为方法的名称,resultType返回值封装到哪个实体类，实体类的全限定类名-->
    <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.java

 @Test//查询所有记录
    public  void testFindAll() throws IOException {
        //5.使用代理对象执行方法
        List<User> users=userDao.findAll();
        for (User user:users){
            System.out.println(user);
            System.out.println(user.getRoles());
        }
    }

结果：

2、查询角色时，同时得到角色的所赋予的用户信息

步骤和之前类似

结果：

❤ζั什么名字好呢

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
mybatis学习（四）连接池、事务、动态SQL、多表查询

连接池主配置文件SqlMapConfig.xml中的dataSource标签，type属性就是表示采用何种连接池方式type属性的取值：POOLED：采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现UNPOOLED：采用传统的获取连接的方式，虽然也实现了java.x.sql.DataSource接口，但是并没有使用池的思想；每次使用都重新...
复制链接

扫一扫