MyBatis学习笔记（六）一对多的关联查询和传递多个参数

最新推荐文章于 2023-06-15 10:05:51 发布

和尚要吃肉

最新推荐文章于 2023-06-15 10:05:51 发布

阅读量3.1k

点赞数

分类专栏： MyBatis学习总结文章标签： MyBatis SSM 框架

本文链接：https://blog.csdn.net/qq_39707130/article/details/81459023

版权

MyBatis学习总结专栏收录该内容

7 篇文章 0 订阅

订阅专栏

本文介绍MyBatis框架中的一对多关联查询方法，包括传递多个参数、使用XML映射文件配置关联关系及通过左连接实现数据查询。同时提供了完整的示例代码，如Role和User类的设计、Mapper接口定义等。

摘要由CSDN通过智能技术生成

首发于我的博客和尚的博客
本文讲解一对多的关联查询，传递多个参数。

源码获取github

1.传递多个参数

当你的形参传递>1个的时候，parameterType不写，让其自动处理
#{值}，默认为arg0，arg1…..或param1，param2，，，
若在接口中注解了@Param(相当于指明了key值)，即也可以写xxx，默认的也可以写，相当于3个值

2.结构

3.数据库属性文件

同之前

4.核心配置文件

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--加载属性文件 -->
    <properties resource="jdbc.properties"/>
    <!--自定义设置类型的别名，也就是resultMap里的type，避免包名已修改，在映射文件里修改多处地方-->
    <typeAliases>
        <!-- 方式一、com.hs.model.Skill这个类设置了别名hs，之后要用这个的话，直接写hs -->
        <!--<typeAlias type="com.hs.model.Skill" alias="hs"/> -->
        <!-- 方式二、com.hs.model这个包下的类，要用的时候直接写类名，比如用com.hs.model.Skill，直接写Skill -->
        <package name="com.hs.model"/>
    </typeAliases>
    <!--配置数据库的环境-->
    <environments default="development">
        <environment id="development">
            <!--事务管理器:保证数据的完整性和一致性   关键信息  -->
            <!--框架：默认情况下CUD操作需要  手动提交事务
            （如同在Navicat中表中输入了数据，没有点那个小√，就是没有提交事务，
            但是输入insert语句，就自动提交事务了）  -->
            <transactionManager type="JDBC" />
            <!--使用的是连接池：百度java如何实行连接池的原理？  -->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.mysql.driver}" />  <!--获取值，${属性文件里的变量名}，也可以直接写值-->
                <property name="url" value="${jdbc.mysql.url}" />  <!--获取值，${属性文件里的变量名}，也可以直接写值-->
                <property name="username" value="${jdbc.mysql.username}" /> <!--获取值，${属性文件里的变量名}，也可以直接写值-->
                <property name="password" value="${jdbc.mysql.password}" /> <!--获取值，${属性文件里的变量名}，也可以直接写值-->
            </dataSource>
        </environment>
    </environments>

    <!--加载映射文件 ，也就是含sql语句的文件-->
    <mappers>
         <!--告知映射文件方式1，一个一个的配置-->
        <mapper resource="com/hs/model/UserMapper.xml"/>
        <mapper resource="com/hs/model/RoleMapper.xml"/>
        <!-- 告知映射文件方式2，自动扫描包内的Mapper接口与配置文件 -->
        <!--<package name="com.hs.model"/>-->
    </mappers>
</configuration>

5.持久化类

Role.java

package com.hs.model;

import java.util.List;

public class Role {

    private Integer role_id;
    private String role_name;
    private String role_key;
    private Integer status;

    //关联对象,一对多，一个角色可以有多个用户
    private List<User> userList;

    public List<User> getUserList() {
        return userList;
    }

    public void setUserList(List<User> userList) {
        this.userList = userList;
    }

    public Integer getRole_id() {
        return role_id;
    }

    public void setRole_id(Integer role_id) {
        this.role_id = role_id;
    }

    public String getRole_name() {
        return role_name;
    }

    public void setRole_name(String role_name) {
        this.role_name = role_name;
    }

    public String getRole_key() {
        return role_key;
    }

    public void setRole_key(String role_key) {
        this.role_key = role_key;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    @Override
    public String toString() {
        return "Role{" +
                "role_id=" + role_id +
                ", role_name='" + role_name + '\'' +
                ", role_key='" + role_key + '\'' +
                ", status=" + status +
                ", userList=" + userList +
                '}';
    }
}

User.java

package com.hs.model;

import java.util.Date;

public class User {

    private Integer user_id;
    private String account;
    private String password;
    private String user_name;
    private Integer status;
    private Date login_time;
    private String ip;
    private Integer fk_role_id;
    //关联对象 一对一或多对一
    private Role role;

    public Integer getUser_id() {
        return user_id;
    }

    public void setUser_id(Integer user_id) {
        this.user_id = user_id;
    }

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getUser_name() {
        return user_name;
    }

    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    public Date getLogin_time() {
        return login_time;
    }

    public void setLogin_time(Date login_time) {
        this.login_time = login_time;
    }

    public String getIp() {
        return ip;
    }

    public void setIp(String ip) {
        this.ip = ip;
    }

    public Integer getFk_role_id() {
        return fk_role_id;
    }

    public void setFk_role_id(Integer fk_role_id) {
        this.fk_role_id = fk_role_id;
    }

    public Role getRole() {
        return role;
    }

    public void setRole(Role role) {
        this.role = role;
    }

    @Override
    public String toString() {
        return "User{" +
                "user_id=" + user_id +
                ", account='" + account + '\'' +
                ", password='" + password + '\'' +
                ", user_name='" + user_name + '\'' +
                ", status=" + status +
                ", login_time=" + login_time +
                ", ip='" + ip + '\'' +
                ", fk_role_id=" + fk_role_id +
                ", role=" + role +
                '}';
    }
}

6.XML映射文件

RoleMapper.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">
<!--namespace=命名空间，唯一不重复-->
<mapper namespace="com.hs.dao.RoleDao"><!--命名空间规则
传统模式：（持久化类（实体化Bean）的类名全路径com.hs.Skill）
接口代理模式：接口的全路径r-->
    <resultMap type="Role" id="BaseResultMapper">
        <id column="role_id" property="role_id"/>
        <result column="role_name" property="role_name"/>
        <result column="role_key" property="role_key"/>
        <result column="status" property="status"/>
    </resultMap>
    <sql id="sys_role_columns">
        role_id,role_name,role_key,status
    </sql>
    <sql id="sys_role_columns_alias">
        ${alias}.role_id,${alias}.role_name,${alias}.role_key,${alias}.status
    </sql>

    <resultMap id="SimpleResultMapper" type="Role" extends="BaseResultMapper">
        <!--配置集合List<User>,javaType一般可以不写-->
        <!--在结果集中找到role_id这个字段，然后传给命名空间com.hs.dao.UserDao下id为getUserByFk的语句，
        返回的结果集字段为userList，类型为java.util.List，里面装的类型是com.he.model.User这个类型
        -->
        <collection property="userList"
                    javaType="java.util.List"
                    ofType="User"
                    column="role_id"
                    select="com.hs.dao.UserDao.getUserByFk"/>
    </resultMap>
    <select id="getRoleByPk" parameterType="_int" resultMap="SimpleResultMapper">
        select
        <include refid="sys_role_columns"/>
        from sys_role
        where role_id = #{role_id}
    </select>


    <resultMap id="JoinResultMapper" type="Role" extends="BaseResultMapper">
        <!--配置集合，查询出来的User里的结果集找com.hs.dao.UserDao.BaseResultMapper处理-->
        <collection property="userList" javaType="list" ofType="com.hs.model.User"
                    resultMap="com.hs.dao.UserDao.BaseResultMapper"/>
        <!--<id/>
        <result/>-->
    </resultMap>
    <select id="getRoleByLeftJoin" parameterType="_int" resultMap="JoinResultMapper">
        SELECT
        <include refid="com.hs.dao.UserDao.sys_user_colums_alias">
            <property name="alias" value="su"/>
        </include>
        ,
        <include refid="sys_role_columns_alias">
            <property name="alias" value="sr"/>
        </include>
        FROM
        sys_role sr
        LEFT JOIN sys_user su ON sr.role_id = su.fk_role_id
        WHERE
        sr.role_id =#{role_id}
    </select>
</mapper>

UserMapper.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">
<!--namespace=命名空间，唯一不重复-->
<mapper namespace="com.hs.dao.UserDao"><!--命名空间规则
传统模式：（持久化类（实体化Bean）的类名全路径com.hs.Skill）
接口代理模式：接口的全路径r-->
    <!--type直接用的别名方式，在核心配置文件里设置了的-->
    <resultMap id="BaseResultMapper" type="User">
        <id column="user_id" property="user_id" />
        <result column="account" property="account" />
        <result column="passwrod" property="pasword" />
        <result column="user_name" property="user_name" />
        <result column="status" property="status" />
        <result column="login_time" property="login_time" />
        <result column="ip" property="ip" />
        <result column="fk_role_id" property="fk_role_id" />
    </resultMap>
    <resultMap id="SimpleResultMapper" type="User" extends="BaseResultMapper"> <!-- extends继承了BaseResultMapper，同java继承一样 -->
        <!--关联对象-->
        <!--在结果集中找到fk_role_id字段，然后再传值给命名空间com.hs.dao.RoleDao下的getRoleByPk语句进行查询(找到要执行的SQL语句)，最后返回role，它的类型是com.hs.model.Role-->
        <association property="role" javaType="Role" column="fk_role_id" select="com.hs.dao.RoleDao.getRoleByPk"/>
    </resultMap>
    <sql id="sys_user_colums">
        user_id,account,password,user_name,status,login_time,ip,fk_role_id
    </sql>
    <sql id="sys_user_colums_alias">
        ${alias}.user_id,${alias}.account,${alias}.password,${alias}.user_name,${alias}.status,${alias}.login_time,${alias}.ip,${alias}.fk_role_id
    </sql>

    <select id="getUserByFk" parameterType="_int" resultMap="BaseResultMapper">
        select <include refid="sys_user_colums"/>
        from sys_user
        where fk_role_id = #{role_id}
    </select>

    <!--1.当你的形参传递>1个的时候，parameterType不写，让其自动处理
        2.#{值}，默认为arg0，arg1.....或param1，param2，，，
        若在dao注解了@xxx(相当于指明了key值)，即也可以写xxx，默认的也可以写，相当于3个值-->
    <select id="getUser" resultMap="BaseResultMapper">
        select <include refid="sys_user_colums"/>
        from sys_user
        where account=#{account} and password=#{password}
    </select>
</mapper>

7.接口

RoleDao.java

package com.hs.dao;

import com.hs.model.Role;

public interface RoleDao {

    /**
     * select方式，先在role表查出主键，然后传给user表当做条件，查询出user的信息
     *
     * @param role_id
     * @return
     */
    Role getRoleByPk(int role_id);

    /**
     * 利用连接查询方式，查询结果集
     *
     * @param role_id
     * @return
     */
    Role getRoleByLeftJoin(int role_id);
}

UserDao.java

package com.hs.dao;

import com.hs.model.User;
import org.apache.ibatis.annotations.Param;

public interface UserDao {

    /**
     * 传递多个参数
     * 1.当你的形参传递>1个的时候，parameterType不写，让其自动处理
     * 2.#{值}，默认为arg0，arg1.....或param1，param2，，，
     * 若在dao注解了@xxx(相当于指明了key值)，即也可以写xxx，默认的也可以写，相当于3个值
     */
    User getUser(@Param("account") String account, @Param("password") String password);
}

8.日志配置文件

mybatis-config.xml

# 日志配置文件Global logging configuration
log4j.rootLogger=ERROR, stdout
# MyBatis logging configuration...
# 如果要显示SQL语句，那么这个位置需要配置为命名空间log4j.logger.命名空间
log4j.logger.com.hs.dao.UserDao=TRACE
log4j.logger.com.hs.dao.RoleDao=TRACE
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

9.测试类

MyBatisTest.java

package com.hs.test;

import com.hs.dao.RoleDao;
import com.hs.dao.UserDao;
import com.hs.util.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

/**
 * 接口代理模式实现操作，在xxDao接口中，定义方法：  sql语句返回的结果类型 sql语句的id(要传的值);
 * 不用写实现类，直接写测试类,具体实现见测试类
 * sql的映射文件的命名空间跟接口的全路径一致
 * 可以根据接口的返回类型自动判断使用selectOne还是selectList eg:返回的是一个对象的为one，返回的是list的就是list，如果是List<Bean>，也是list
 */
public class MyBatisTest {

    /**
     * 利用select方式，
     */
    @Test
    public void getUserByPk(){
        SqlSession sqlSession = null;
        try {
            sqlSession = MyBatisUtils.getSqlsession();
            RoleDao roleDao = sqlSession.getMapper(RoleDao.class);
            System.out.println(roleDao.getRoleByPk(-100));
        } finally {
            MyBatisUtils.closeSqlSession(sqlSession);
        }
    }

    /**
     * 利用连接方式查询
     */
    @Test
    public void getUserByFk(){
        SqlSession sqlSession = null;
        try {
            sqlSession = MyBatisUtils.getSqlsession();
            RoleDao roleDao = sqlSession.getMapper(RoleDao.class);
            System.out.println(roleDao.getRoleByLeftJoin(-100));
        } finally {
            MyBatisUtils.closeSqlSession(sqlSession);
        }
    }

    /**
     * 传递多个参数
     */
    @Test
    public void getUser(){
        SqlSession sqlSession = null;
        try {
            sqlSession = MyBatisUtils.getSqlsession();
            UserDao userDao = sqlSession.getMapper(UserDao.class);
            String account = "admin";
            String password = "admin";
            System.out.println(userDao.getUser(account,password));
        } finally {
            MyBatisUtils.closeSqlSession(sqlSession);
        }
    }

}