Mybatis--03

最新推荐文章于 2024-07-15 22:27:18 发布

DarkADays

最新推荐文章于 2024-07-15 22:27:18 发布

阅读量121

点赞数

分类专栏： Mybatis 文章标签： java mybatis

本文链接：https://blog.csdn.net/LLturn/article/details/106557881

版权

Mybatis 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章目录

1.Mybatis连接池
2.Mybatis的动态sql语句
3.Mybatis多表查询

1.Mybatis连接池

涉及到对数据库的操作，我们就不得不提到连接池技术，同样在Mybatis中也存在连接池技术，在SqlMapConfig.xml配置文件中，通过 <dataSource type="POOLED">来实现Mybatis中连接池的配置。

上面type=POOLED就代表一种数据源类型，在Mybatis中共提供了三种数据源类型

type属性的取值	描述
POOLED	采用传统的javax.sql.DataSource规范中的连接池
UNPOOLED	采用传统的获取连接的方式，虽然也实现了javax.sql.DataSource接口，但是并没有用到池的思想
JNDI	采用服务器提供的JNDI技术实现，来获取DataSource对象，不同服务器所拿到的DataSource是不一样的（了解即可）

在以上三种数据源中，我们一般采用POOLED数据源（即我们常用的连接池技术）
如果想要修改数据源，直接修改type的值即可。

下面我们分别用POOLED和UNPOOLED来测试

在这里插入图片描述

从上面两张图中我们可以看到当type为POOLED时，日志信息有 Returned connection的字样，说明它使用的是连接池的技术。

通过查看POOLED的实现类PooleDataSource的源代码，我们得到这样的一个过程

它会有两个连接池，一个空闲池和一个活动池
当要获取连接时，首先从空闲池中找，如果空闲池没有，就到活动池中
若活动池中连接的数量没有达到最大数量，就创建一个新的连接，如果达到了就从活动池中取出一个最老的来使用。

2.Mybatis的动态sql语句

在前面我们写的sql语句都是比较简单的，实际开发中经常有业务逻辑比较复杂的时候，我们的SQL是动态变化的，这也是Mybatis的强大特性之一。

2.1 动态Sql之if标签

需求：根据传入的是实体类，判断哪些属性不为空，并以此作为查询条件。

接口方法：

    /**
     * 根据传入的查询条件，进行多条件查询
     * @param user  包含查询的条件，可能是username，sex，birthday，address等条件
     * @return
     */
    List<User> listUserByCondition(User user);

映射文件：

<select id="listUserByCondition" resultType="user" parameterType="user">
	select * from user where 1=1
	<if test="username!=null and username != '' ">
	and username like #{username}	
	</if>
 	<if test="address != null">
	and address like #{address}
	</if>
</select>

这里where 1=1是为了防止出现拼接sql出错的情况，即所有条件都为空的情况
<if></if>标签中test属性是必须的，表示判断的条件

2.2动态Sql之 where 标签

为了简化上面where 1=1 的条件拼装，可以采用where标签来简化开发。
映射配置：

<select id="listUserByCondition" parameterType="User" resultType="User">
        select * from user
        <where>
            <if test="username != null">
                and username = #{username}
            </if>
            <if test="sex != null">
                and sex = #{sex}
            </if>
        </where>
    </select>

where标签只会在至少有一个子元素的条件返回SQL语句的情况下才去插入where字句。若语句的开头为AND或者OR where也会把它们去掉。

2.3 动态Sql之foreach标签

在我们进行范围查询的时候，需要将一个集合的值，作为参数动态传递进来，这是该如何进行参数的传递呢？
这时就要用上我们的foreach标签了。

首先编写一个QueryVo实体类，用来封装查询条件。

/**
 * 用于封装查询条件
 */
public class QueryVo {
    private User user;
    //如果还有其他的查询条件，就可以一并封住出来

    private List<Integer> ids;

    public List<Integer> getIds() {
        return ids;
    }

    public void setIds(List<Integer> ids) {
        this.ids = ids;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}

添加接口方法：

    /**
     * 根据id集合，查询用户
     * @param vo
     * @return
     */
    List<User> listUserByIds(QueryVo vo);

映射配置文件：

    <!-- 根据id集合查询用户 -->
    <select id="listUserByIds" parameterType="QueryVo" resultType="User">
        select * from user
        <where>
            <if test="ids != null and ids.size > 0">
                <foreach collection="ids" open="and id in (" close=")" item="id" separator=",">
                    #{id}
                </foreach>
            </if>
        </where>
    </select>

foreach标签用来遍历集合，它的每个属性的作用如下：
collection：代表要遍历的集合元素，注意编写是不要写#{}，这个属性是必须的。
open：代表语句开始的部分
close：代表语句结束的部分
item：代表遍历集合时的每个元素，相当于一个临时变量
separator：代表分隔符

sql语句#{id}应该和item=“id”保持一致。

3.Mybatis多表查询

表之间的关系有下面这几种：
- 一对一：一个人对应一个身份账号，一个身份证号对应一个人
- 一对多（多对一）：一个班级有很多学生，一个学生只有一个班级
- 多对多：一个学生有很多个老师，一个老师也有很多个学生

3.1一对一查询

以用户和账户为例，查询所有账户信息，关联查询下单用户信息。
注意：一个账户信息对应一个用户，所以从查询账户信息出发关联查询用户信息为一对一查询；如果从用户信息出发查询用户下的账户则为一对多的查询，因为一个用户可以有多个账户。

先建立所需的数据库表：

# 创建用户表
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(11) NOT NULL auto_increment,
  `username` varchar(32) NOT NULL COMMENT '用户名称',
  `birthday` datetime default NULL COMMENT '生日',
  `sex` char(1) default NULL COMMENT '性别',
  `address` varchar(256) default NULL COMMENT '地址',
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
# 导入用户数据
insert  into `user`(`id`,`username`,`birthday`,`sex`,`address`) values (41,'老王','2018-02-27 17:47:08','男','北京'),(42,'小二王','2018-03-02 15:09:37','女','北京金燕龙'),(43,'小二王','2018-03-04 11:34:34','女','北京金燕龙'),(45,'传智播客','2018-03-04 12:04:06','男','北京金燕龙'),(46,'老王','2018-03-07 17:37:26','男','北京'),(48,'小马宝莉','2018-03-08 11:44:00','女','北京修正');
# 创建账户表，外键为uid，关联用户表的id
DROP TABLE IF EXISTS `account`;
CREATE TABLE `account` (
  `id` int(11) NOT NULL COMMENT '编号',
  `uid` int(11) default NULL COMMENT '用户编号',
  `money` double default NULL COMMENT '金额',
  PRIMARY KEY  (`id`),
  KEY `FK_Reference_8` (`uid`),
  CONSTRAINT `FK_Reference_8` FOREIGN KEY (`uid`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
# 导入账户数据
insert  into `account`(`id`,`uid`,`money`) values (1,46,1000),(2,45,1000),(3,46,2000);

添加账户实体类：

/**
 * 账户的实体类
 */
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 +
                ", user=" + user +
                '}';
    }
}

定义账户的持久层Dao层：

public interface IAccountDao {
    /**
     * 查询所有账户,同时还要获取当前账户的所有信息（一对一）
     * @return
     */
    List<Account> findAll();
}

添加账户对应的映射配置文件：

<mapper namespace="com.zut.dao.IAccountDao">

    <!-- 定义可以封装带有User的Account的 resultMap -->
    <resultMap id="AccountUserMap" type="Account">
        <id property="id" column="id"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!-- 关联User对象 -->
        <association property="user" javaType="User">
            <id property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="sex" column="sex"></result>
            <result property="birthday" column="birthday"></result>
            <result property="address" column="address"></result>
        </association>
    </resultMap>

    <select id="findAll" resultMap="AccountUserMap">
       SELECT * FROM account,USER WHERE user.id=account.uid
    </select>
</mapper>

association标签用于一对一映射，其中property属性表示要关联的属性，javaType表示关联的实体类的全限定类名。

编写测试代码：

public class AccountTest {

    private IAccountDao iAccountDao;
    private SqlSession session;

    //初始化
    @Before
    public void init() throws Exception{
        //1.读取配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        //3.使用工厂生产sqlSessino对象
        session = factory.openSession();
        //4.使用SqlSession创建Dao的代理对象
        iAccountDao = session.getMapper(IAccountDao.class);
    }
    @After
    public void destory(){
        session.commit();
        //释放资源
        session.close();
    }
    /**
     *测试查询所有账户,同时还要获取当前账户的所有信息
     * @throws Exception
     */
    @Test
    public void findAll(){
        //5.使用代理对象执行方法
        List<Account> accounts = iAccountDao.findAll();
        for (Account account:accounts){
            System.out.println(account);
        }
    }
}

运行测试代码，可以看到以下结果：

3.2一对多查询

上面一对一是从查询账户信息出发，而一对多是从查询用户信息出发来关联账户
由于有的用户没有账户，为了防止出现把没有账户的用户给漏掉，我们的sql语句应该采用外连接的方式。

编写User类

public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

    //一对多关系映射，主表实体应该包含从表实体的集合引用
    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;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

编写User的持久层接口：

public interface IUserDao {
    /**
     * 查找所有用户,同时获取到用户下所有账户的信息（一对多）
     * @return
     */
    List<User> findAll();

    /**
     * 根据id查找用户
     * @param id
     * @return
     */
    User getUserById(Integer id);
}

编写User对应的映射配置文件：

<mapper namespace="com.zut.dao.IUserDao">

    <!-- 配置User的resultMap -->
    <resultMap id="UserAccountMap" type="User">
        <id property="id" column="id"></id>
        <result property="username" column="username"></result>
        <result property="sex" column="sex"></result>
        <result property="birthday" column="birthday"></result>
        <result property="address" column="address"></result>
        <!-- 配置user对象中accounts集合的映射 -->
        <collection property="accounts" ofType="Account">
            <id property="id" column="aid"></id>
            <result property="uid" column="uid"></result>
            <result property="money" column="money"></result>
        </collection>
    </resultMap>

    <select id="findAll" resultMap="UserAccountMap">
       SELECT u.*, a.id AS aid, a.uid, a.money FROM USER u LEFT OUTER JOIN account a ON u.id = a.uid
    </select>

    <select id="getUserById" parameterType="java.lang.Integer" resultType="User">
        select * from user where id=#{aa}
    </select>
</mapper>

collection标签用于配置一对多的映射，其中property标签用于表示要关联的集合，ofType表示集合中的实体类全限定类名。
这里column写为aid而不是id是因为在sql语句中我们给account表中的id起了表明aid，所以上面的cloumn=aid

编写测试代码：

public class UserTest {

    private IUserDao iUserDao;
    private SqlSession session;

    //初始化
    @Before
    public void init() throws Exception{
        //1.读取配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        //3.使用工厂生产sqlSessino对象
        session = factory.openSession();
        //4.使用SqlSession创建Dao的代理对象
        iUserDao = session.getMapper(IUserDao.class);
    }

    @After
    public void destory(){
        session.commit();
        //释放资源
        session.close();
    }

    /**
     * 测试查找所有
     * @throws Exception
     */
    @Test
    public void findAll(){
        //5.使用代理对象执行方法
        List<User> users = iUserDao.findAll();
        for (User user:users){
            System.out.println("----------每个用户的信息----------");
            System.out.println(user);
            System.out.println(user.getAccounts());
        }
    }


    /**
     * 测试根据id获取用户
     */
    @Test
    public void getUserById(){
        User user = iUserDao.getUserById(45);
        System.out.println(user);
    }

}

测试结果如下：

3.3 多对多查询

以用户和角色的关系为例，一个用户可以有多个角色，而一个角色也可以有多个用户。
需求：
- 1.查询用户的时候把用户所拥有的角色信息展示出来。
- 2.查询角色的时候把用户的信息给展示出来。
它们的关系模型图如图所示：
第一步，先建立所需要的表：

# 创建角色表
DROP TABLE IF EXISTS `role`;
CREATE TABLE `role` (
  `id` int(11) NOT NULL COMMENT '编号',
  `role_name` varchar(30) default NULL COMMENT '角色名称',
  `role_desc` varchar(60) default NULL COMMENT '角色描述',
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
# 添加角色数据
insert  into `role`(`ID`,`ROLE_NAME`,`ROLE_DESC`) values (1,'院长','管理整个学院'),(2,'总裁','管理整个公司'),(3,'校长','管理整个学校');
# 创建用户角色表，也就是中间表
# uid 和 rid是复合主键，同时也是外键
DROP TABLE IF EXISTS `user_role`;
CREATE TABLE `user_role` (
  `uid` int(11) NOT NULL COMMENT '用户编号',
  `rid` int(11) NOT NULL COMMENT '角色编号',
  PRIMARY KEY  (`uid`,`rid`),
  KEY `FK_Reference_10` (`rid`),
  CONSTRAINT `FK_Reference_10` FOREIGN KEY (`rid`) REFERENCES `role` (`id`),
  CONSTRAINT `FK_Reference_9` FOREIGN KEY (`uid`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
# 添加用户角色数据
insert  into `user_role`(`uid`,`rid`) values (41,1),(45,1),(41,2);

创建User实体类和Role实体类：

public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

    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;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

public class Role implements Serializable {
    private Integer roleId;
    private String roleName;
    private String roleDesc;

    //多对多的关系映射，一个角色可以赋予多个用户
    private List<User> users;

    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }

    public Integer getRoleId() {
        return roleId;
    }

    public void setRoleId(Integer roleId) {
        this.roleId = roleId;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public String getRoleDesc() {
        return roleDesc;
    }

    public void setRoleDesc(String roleDesc) {
        this.roleDesc = roleDesc;
    }

    @Override
    public String toString() {
        return "Role{" +
                "roleId=" + roleId +
                ", roleName='" + roleName + '\'' +
                ", roleDesc='" + roleDesc + '\'' +
                '}';
    }
}

先编写User 的接口层和映射文件：

public interface IUserDao {
    List<User> findAll();

<mapper namespace="com.zut.dao.IUserDao">

    <!-- 配置User的resultMap -->
    <resultMap id="UserRoleMap" type="User">
        <id property="id" column="id"></id>
        <result property="username" column="username"></result>
        <result property="sex" column="sex"></result>
        <result property="birthday" column="birthday"></result>
        <result property="address" column="address"></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="UserRoleMap">
       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 ur.rid = r.id
    </select>
</mapper>

运行测试代码，可以看到结果如下所示：
- 编写Role的接口层和映射文件：

public interface IRoleDao {
    /**
     * 查询所有角色,并显示角色所对应的用户信息
     * @return
     */
    List<Role> findAll();
}


<mapper namespace="com.zut.dao.IRoleDao">

    <!-- 配置Role表的resultMap -->
    <resultMap id="RoleUserMap" type="Role">
        <id property="roleId" column="rid"></id>
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
        <!-- 配置Role对象中User集合的映射 -->
        <collection property="users" ofType="User">
            <id property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="sex" column="sex"></result>
            <result property="birthday" column="birthday"></result>
            <result property="address" column="address"></result>
        </collection>
    </resultMap>

    <select id="findAll" resultMap="RoleUserMap">
       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 ur.uid = u.id
    </select>
</mapper>

运行测试代码，结果如图所示：

其实多对多的查询和一对多的查询类似，多对多的查询相当于两个一对多的查询，需要分别在两个实体类中创建对方的集合对象。

DarkADays

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mybatis--03

文章目录1.Mybatis连接池与事务1.1Mybatis的连接池2.Mybatis的动态sql语句3.Mybatis多表查询1.Mybatis连接池与事务1.1Mybatis的连接池涉及到对数据库的操作，我们就不得不提到连接池技术，同样在Mybatis中也存在连接池技术，在SqlMapConfig.xml配置文件中，通过 <dataSource type="POOLED">来实现Mybatis中连接池的配置。上面type=POOLED就代表一种数据源类型，在Mybatis中共提
复制链接

扫一扫