精华内容
下载资源
问答
  • Mybatis一对一关联查询

    万次阅读 2016-09-18 10:30:23
    Mybatis一对一关联查询有两张表,teacher和class,一个class班级对应一个teacher,一个teacher对应一个class需求是根据班级id 查询班级信息(带老师的信息)创建teacher和class表:CREATE TABLE teacher ( t_id INT ...

    Mybatis一对一关联查询

    有两张表,老师表teacher和班级表class,一个class班级对应一个teacher,一个teacher对应一个class

    需求是根据班级id查询班级信息(带老师的信息)

    创建teacherclass表:

        CREATE TABLE teacher (
            t_id INT PRIMARY KEY AUTO_INCREMENT,
            t_name VARCHAR(20)
        );
        CREATE TABLE class (
            c_id INT PRIMARY KEY AUTO_INCREMENT,
            c_name VARCHAR(20),
            teacher_id INT
        );
        ALTER TABLE class ADD CONSTRAINT fk_teacher_id FOREIGN KEY (teacher_id) REFERENCES
        teacher(t_id);
        INSERT INTO teacher(t_name) VALUES('LS1');
        INSERT INTO teacher(t_name) VALUES('LS2');
        INSERT INTO class(c_name, teacher_id) VALUES('bj_a', 1);
        INSERT INTO class(c_name, teacher_id) VALUES('bj_b', 2);

    首先定义实体类
    老师Teacher

        package mybatis.bean;
    
        public class Teacher {
    
            private int id;
            private String name;
    
            public Teacher() {
    
            }
    
            public Teacher(int id, String name) {
                super();
                this.id = id;
                this.name = name;
            }
    
            public int getId() {
                return id;
            }
    
            public void setId(int id) {
                this.id = id;
            }
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
            @Override
            public String toString() {
                return "Teacher [id=" + id + ", name=" + name + "]";
            }
    
    
    
        }
    

    班级Class

    package mybatis.bean;
    
    public class Class {
    
        private int id;
        private String name;
        private Teacher teacher;
    
        public Class() {
        }
    
        public Class(int id, String name, Teacher teacher) {
            super();
            this.id = id;
            this.name = name;
            this.teacher = teacher;
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Teacher getTeacher() {
            return teacher;
        }
    
        public void setTeacher(Teacher teacher) {
            this.teacher = teacher;
        }
    
        @Override
        public String toString() {
            return "Class [id=" + id + ", name=" + name + ", teacher=" + teacher + "]";
        }
    
    
    
    
    
    }
    

    要实现一对一关联查询,有两种方式

    1.关联表查询

    SELECT * FROM class c, teacher t WHERE c.teacher_id = t.t_id AND c.c_id = 1;

    2.执行2次查询
    先查询class表,获取teacher_id,再查询teacher表,获取teacher的信息

    SELECT * FROM class where c_id = 1;
    SELECT * FROM teacher where t_id = 1;//使用上面得到的teacher_id

    这两种查询方式就引出了2中方式

    • 嵌套结果: 使用嵌套结果映射来处理重复的联合结果的子集
    • 嵌套查询:通过执行另外一个SQL 映射语句来返回预期的复杂类型

    嵌套结果

    使用嵌套结果映射来处理重复的联合结果的子集
    可以理解为封装联表查询的数据(去除重复的数据)select * from class c, teacher t where c.teacher_id=t.t_id and c.c_id=1

    classMapper.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="mybatis.test5.classMapper">
    
        <!--根据id查询到一个班级信息(带老师信息) -->
    
    
        <!-- 嵌套结果 -->
        <select id="getClass" parameterType="int" resultMap="ClassResultMap">
            select * from class c, teacher t where c.teacher_id=t.t_id and c.c_id=#{id}
        </select>
        <resultMap type="mybatis.bean.Class" id="ClassResultMap">
            <id property="id" column="c_id" />
            <result property="name" column="c_name" />
            <association property="teacher" column="teacher_id" javaType="mybatis.bean.Teacher">
                <id property="id" column="t_id" />
                <result property="name" column="t_name" />
            </association>
        </resultMap>
    
    </mapper>
    

    查询过程如下:

        mybatis.bean.Class clazz = session.selectOne("mybatis.test5.classMapper.getClass", 1);
        System.out.println(clazz);
    

    控制台输出结果为:

     Class [id=1, name=bj_a, teacher=Teacher [id=1, name=LS1]]
    

    这里使用association标签,association用于一对一的关联查询

    • property - 对象属性的名称
    • javaType - 对象属性的类型
    • column - 所对应的外键字段名称
    • select - 使用另一个查询封装的结果

    嵌套查询

    通过执行另外一个SQL 映射语句来返回预期的复杂类型

    SELECT * FROM class WHERE c_id=1;
    SELECT * FROM teacher WHERE t_id=1 //1 是上一个查询得到的teacher_id 的值

    classMapper.xml中的配置如下:

    <!--嵌套查询  -->
    <select id="getClass2" parameterType="int" resultMap="ClassResultMap2">
        select * from class where c_id=#{id}
    </select>
    <resultMap type="mybatis.bean.Class" id="ClassResultMap2">
        <id property="id" column="c_id" />
        <result property="name" column="c_name" />
        <association property="teacher" column="teacher_id" javaType="mybatis.bean.Teacher" select="getTeacher">
        </association>
    </resultMap>
    <!-- 使用了sql别名  -->
    <select id="getTeacher" parameterType="int" resultType="mybatis.bean.Teacher">
        SELECT t_id id, t_name name FROM teacher WHERE t_id=#{id}
    </select>
    

    这里使用了association标签的select属性,其值对应为<select id="getTeacher" ...>中的id的值

    这种方式,同样可以得到正确的结果

    展开全文
  • 文章目录案例描述1. 创建数据库表person和card2. 创建bean对象3. 创建dao层映射层4. 创建连接数据库的属性文件db.properties(键值对形式)5....创建person表和card表,通过resultMap映射的一对一关联映射ass

    案例描述

      一个人有一个身份证,一个身份证只对应一个人所有。人和身份证之间的关系是一对一的关联关系。创建person表和card表,通过resultMap映射的一对一关联映射association实现。(这里设计表,person表有外键id_card关联card表的主键id)

    1. 创建数据库表person和card

      (一对一关联,一个表的外键是另一个表的主键,在哪个表创建外键都可以)

    -- ----------------------------
    -- 身份证card表,主键id自动增长
    -- ----------------------------
    DROP TABLE IF EXISTS `card`;
    CREATE TABLE `card` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `code` varchar(18) NOT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
    
    INSERT INTO `card` VALUES ('1', '111111111123456789');
    INSERT INTO `card` VALUES ('2', '222222222223456789');
    INSERT INTO `card` VALUES ('3', '333333333333456789');
    
    
    -- ----------------------------
    -- 人 person表,主键id自动增长,在person表中设置card表的主键id作为外键
    -- ----------------------------
    DROP TABLE IF EXISTS `person`;
    CREATE TABLE `person` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `username` varchar(20) DEFAULT NULL,
      `id_card` int(11) DEFAULT NULL,
      PRIMARY KEY (`id`),
      KEY `FK_person_card` (`id_card`),
      CONSTRAINT `FK_person_card` FOREIGN KEY (`id_card`) REFERENCES `card` (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
    
    INSERT INTO `person` VALUES ('1', '张三', '1');
    INSERT INTO `person` VALUES ('2', '李四', '2');
    INSERT INTO `person` VALUES ('3', '王五', '3');
    

    2. 创建bean对象

    //person表
    public class Person {
        private Integer id;
        private String username;
        private Card card; // 1	111111111123456789
        //省略getter/setter方法
    }
    
    //card表
    public class Card {
        private Integer id;
        private String code;
        //省略getter/setter
    }
    

    3. 创建dao层映射层

    @Repository
    public interface CardMapper {
    
        //通过id来查询身份证表Card的信息
        public Card getCardById(Integer id);
    }
    
    @Repository
    public interface PersonMapper {
    
        //通过一条Sql语句来查询
        Person getPersonById(int id);
    
        //通过嵌套查询
        Person getPersonById2(int id);
    
        //通过用户名查询
        Person getPersonByName(String username);
    }
    

    4. 创建连接数据库的属性文件db.properties(键值对形式)

    jdbc.driver = com.mysql.jdbc.Driver
    jdbc.url = jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=UTF-8
    jdbc.username = root
    jdbc.password = 861221293
    

    5. spring整合MyBatis,核心配置文件applicationContext.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:mybatis="http://mybatis.org/schema/mybatis-spring" xmlns:tx="http://www.springframework.org/schema/tx"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    
    
        <!--1. 引入jdbc的属性文件,在配置中通过占位使用 -->
        <context:property-placeholder location="classpath*:db.properties" />
    
        <!--2. <context:component-scan>扫描包中注解所标注的类(@Component、@Service、@Controller、@Repository) -->
        <context:component-scan base-package="com.xgf.correlation.one_to_one"/>
    
        <!--3. 由spring管理    配置数据源数据库连接(从jdbc属性文件中读取参数) -->
        <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
            <property name="username" value="${jdbc.username}"/>
            <property name="password" value="${jdbc.password}"/>
            <property name="url" value="${jdbc.url}"/>
            <property name="driverClassName" value="${jdbc.driver}"/>
        </bean>
    
        <!--  通过spring来管理Mybatis的sqlSessionFactory对象创建  -->
        <!--4. 通过完全限定名匹配查找  创建SqlSessionFactoryBean  -->
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource" />
        </bean>
    
        <!-- 5. mybatis提供的一个注解扫描标签(搜索映射器 Mapper 接口),通过自动扫描注解的机制,创建每个dao接口定义的bean  -->
        <mybatis:scan base-package="com.xgf.correlation.one_to_one"/>
    
        <!-- 6. 配置事务管理器 完成手动事务管理  由spring管理事务-->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"/>
        </bean>
        <!--
            支持注解驱动的事务管理,指定事务管理器。
            配置事务 提供回滚,发生异常数据回滚  需要在类/方法上写注解 @Transactional -->
        <tx:annotation-driven transaction-manager="transactionManager"/>
    </beans>
    

    6. 创建映射文件mapper.xml

    这里通过两种方式来查询

    • 第一种(getPersonById)直接通过一条SQL语句查询
    • 第二种(getPersonById2)嵌套sql查询,第二种才需要创建card表的映射文件【推荐使用第二种】

    PersonMapper.xml

    <mapper namespace="com.xgf.mybatis.correlation.one_to_one.dao.PersonMapper">
    
        <!-- 1. 通过一条SQL语句查询主表+关联表双表信息 autoMapping="true"自动映射,如果表列名和对象属性名一致,可以不用配置<result>-->
        <resultMap id="personMap" type="com.xgf.correlation.one_to_one.bean.Person" autoMapping="true">
            <!--<id>主键   <result>其它属性列  -->
           <id property="id" column="id"/>
           <result property="username" column="username"/>
    
            <!--  封装person对象对应的card
                  一对一关联 用association封装对象类型
            -->
           <association property="card" javaType="com.xgf.correlation.one_to_one.bean.Card">
               <id property="id" column="id"/>
               <result property="code" column="code"/>
           </association>
    
        </resultMap>
    
    <!--  查询结构封装成map对象  -->
        <select id="getPersonById" resultMap="personMap">
            select p.id,p.username,c.id,c.code
            from person p inner join card c on p.id_card = c.id
            where p.id = #{id}
        </select>
    
        <select id="getPersonByName" resultMap="personMap">
            select p.id,p.username,c.id,c.code
            from person p inner join card c on p.id_card = c.id
            where p.username = #{username}
        </select>
    
    
    
        <!--2. 嵌套查询实现 - 通过分布加载方式加载(嵌套select)
             通过多条SQL语句查询主表=关联表信息  一对一分布加载
        -->
    
        <!-- association select通过命名空间 + sql语句的id 来查询
              column对应主键id  foreignColumn外键
              column="id"  card表中的主键   foreignColumn="id_card"  person表的外键
         -->
    
        <resultMap id="personMap2" type="com.xgf.correlation.one_to_one.bean.Person">
            <id property="id" column="id"/>
            <result property="username" column="username"/>
            <association property="card" javaType="com.xgf.correlation.one_to_one.bean.Card"
                         select="com.xgf.correlation.one_to_one.dao.CardMapper.getCardById"
                         column="id"
                         foreignColumn="id_card"
            />
        </resultMap>
    
        <select id="getPersonById2" resultMap="personMap2" parameterType="int">
            select id,username
            from person
            where id=#{id}
        </select>
    
    </mapper>
    

    CardMapper.xml

    <!--分布加载方式 加载person外键关联card表-->
    <mapper namespace="com.xgf.correlation.one_to_one.dao.CardMapper">
    
        <select id="getCardById" parameterType="int" resultType="com.xgf.correlation.one_to_one.bean.Card">
            select id,code
            from card
            where id=#{id}
        </select>
    
    </mapper>
    

    7. 创建测试类

    测试结果

    test01() 测试getPersonById结果(一条sql查两表)

    Person{id=1, username=‘张三’, card=Card{id=1, code=‘111111111123456789’}}

    test02()测试getPersonById2结果(嵌套查询)

    Person{id=2, username=‘李四’, card=Card{id=2, code=‘222222222223456789’}}

    test03()测试getPersonByName结果(用户名查找)

    Person{id=2, username=‘王五’, card=Card{id=2, code=‘333333333333456789’}}

    展开全文
  • 模型一对一关联总结:(仅供参考) 如: user 表关联 profile表为一对一关联 在User模型下定义一对一关联: <?php namespace app\front\model; use think\Model; class User extends Model { //.......... public...

    模型一对一关联总结:(仅供参考)
    如:
    user 表关联 profile表为一对一关联
    在User模型下定义一对一关联:

    <?php
    namespace app\front\model;
    use think\Model;
    class User extends Model
    {
    //..........
    public function profile()
    {
    return $this->hasOne('Profile','user_id');
    

    //两个参数分别是Profile模型名(需要新建Profile.php),外键名(也就是在profile表中关联user表的字段名)
    //可以支持为关联模型定义需要查询的字段,return $this->hasOne(‘Profile’,‘user_id’)->field(‘phone,email,address’);
    }

    }

    //定义好上面的内容后,在使用User模型时就可以使用一对一关联了

    1)一对一关联查询
    如:在user控制器中查询用户的信息

    public function getUserInfo()
    {
    $user = UserModel::get(1);
    
    // 输出Profile关联模型的email属性
    echo $user->profile->email;
    
    
    //如果要根据关联表的查询条件查询当前模型的数据,可以使用hasWhere方法,例如:
    $user = User::hasWhere('profile',['email'=>'thinkphp@qq.com'])->find();
    echo $user->name;
    //查询多条数据 User::hasWhere('profile',['email'=>'thinkphp@qq.com'])->select();
    }
    
    如果是关联查询多个用户信息,则关联查询时采用预载入查询(避免关联时多次查询)
    $list = User::with('profile')->select([1,2,3]);
    foreach($list as $user){
    // 获取用户关联的profile模型数据
    dump($user->profile); //这里注意,如果表模型名是驼峰的如userPro,则这里要用下划线$user->user_pro,要不然还是重复查询操作
    //输出关联的字段:echo $user['profile']['email'];
    }
    
    //如果想直接添加关联字段到主模型,可以用绑定属性到父模型
    //return $this->hasOne('Profile','user_id')->setEagerlyType(0)->bind('phone,email,address');
    //输出关联字段时就可以直接用 echo $user['email'];
    如:
    $user = UserModel::get(1,'profile'); echo $user['email'];
    $users = UserModel::with('profile')->select[1,2,3];
    foreach($users as $user){
    echo $user['email'];
    }
    
    如果要指定属性查询,可以使用:(也可以在关联模型定义时规定关联查询的字段)
    $list = User::field('id,name')->with(['profile'=>function($query){$query->field('email,phone');}])->select([1,2,3]);
    foreach($list as $user){
    // 获取用户关联的profile模型数据
    dump($user->profile);
    }
    
    V5.0.4+版本开始,一对一关联预载入支持两种方式:JOIN方式(一次查询)和IN方式(两次查询),用JOIN方式查询性能会好一些
    // 设置预载入查询方式为IN方式(默认) return $this->hasOne('Profile')->setEagerlyType(1);
    // 设置预载入查询方式为JOIN方式 return $this->hasOne('Profile')->setEagerlyType(0);
    如上面在User模型中定义的一对一关联可以改为:
    public function profile()
    {
    return $this->hasOne('Profile','user_id')->setEagerlyType(0)->bind('phone,email,address');
    }
    
    2)一对一关联新增、更新、删除
    <?php
    namespace app\front\controller;
    use app\front\model\User as UserModel;
    use app\front\model\Profile as ProfileModel;
    public function saveUserProfile()
    {
    $user = User::get(1);
    // 如果还没有关联数据 则进行新增
    if(isset($user->profile->email)){ //如果存在关联属性,则为更新
    $user->profile->save(['email'=>'thinkphp']);
    }else{
    $user->profile()->save(['email' => 'thinkphp']); //此处若没有判断会一直新增
    }
    }
    
    //关联自动写入:together();
    public function saveUser()
    {
    $userInfo = UserModel::get(1);
    if(!$userInfo){ //关联新增
    $user = new UserModel(); //实例化User模型并给属性赋值
    $user->loginname = 'piter';
    $user->create_time = time();
    $profile = new ProfileModel();//实例化Profile模型并给属性赋值
    $profile->email = '123@my.com';
    $profile->phone = '13245678901';
    $user->profile = $profile;//指定关联模型
    $user->together('profile')->save(); //关联写入
    }else{ //关联更新
    $userInfo->last_login_time = time();
    $userInfo->profile->email = '345@my.com';
    $userInfo->together('profile')->save();
    }
    }
    
    //关联删除
    public function deleteUser()
    {
    $userInfo = UserModel::get(1);
    $userInfo->together('profile')->delete();
    }
    
    
    展开全文
  • 注意:因为一个订单信息只会是一个人下的订单,所以从查询订单信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的订单信息则为一对多查询,因为一个用户可以下多个订单。 sql语句: SELECT ...

    需求:查询所有订单信息,关联查询下单用户信息。

    注意:因为一个订单信息只会是一个人下的订单,所以从查询订单信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的订单信息则为一对多查询,因为一个用户可以下多个订单。

    sql语句:

    SELECT

    o.id,

    o.user_id userId,

    o.number,

    o.createtime,

    o.note,

    u.username,

    u.address

    FROM

    `order` o

    LEFT JOIN `user` u ON o.user_id = u.id

     1.方法一:使用resultType

    使用resultType,改造订单pojo类,此pojo类中包括了订单信息和用户信息

    这样返回对象的时候,mybatis自动把用户信息也注入进来了

    1.1改造POJO类:

    OrderUser类继承Order类后OrderUser类包括了Order类的所有字段,只需要定义用户的信息字段即可,如下图:

    1.2.mapper.xml

    在UserMapper.xml添加sql,如下

    <!-- 查询订单,同时包含用户数据 -->

    <select id="queryOrderUser" resultType="orderUser">

    SELECT

    o.id,

    o.user_id

    userId,

    o.number,

    o.createtime,

    o.note,

    u.username,

    u.address

    FROM

    `order` o

    LEFT JOIN `user` u ON o.user_id = u.id

    </select>

    1.3mapper接口:

    在UserMapper接口添加方法,如下图:

    1.4.测试方法:

    在UserMapperTest添加测试方法,如下:

    @Test

    public void testQueryOrderUser() {

    // mybatis和spring整合,整合之后,交给spring管理

    SqlSession sqlSession = this.sqlSessionFactory.openSession();

    // 创建Mapper接口的动态代理对象,整合之后,交给spring管理

    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

     

    // 使用userMapper执行根据条件查询用户

    List<OrderUser> list = userMapper.queryOrderUser();

     

    for (OrderUser ou : list) {

    System.out.println(ou);

    }

     

    // mybatis和spring整合,整合之后,交给spring管理

    sqlSession.close();

    }

    1.5.测试:

    测试结果如下图:

    1.6.小结:

    定义专门的pojo类作为输出类型,其中定义了sql查询结果集所有的字段。此方法较为简单,企业中使用普遍。

    2.方法二:使用resultMap

    使用resultMap,定义专门的resultMap用于映射一对一查询结果。

    2.1改造POJO类:

    在Order类中加入User属性,user属性中用于存储关联查询的用户信息,因为订单关联查询用户是一对一关系,所以这里使用单个User对象存储关联查询的用户信息。

    改造Order如下图:

    2.2mapper.xml

    这里resultMap指定orderUserResultMap,如下:

    <resultMap type="order" id="orderUserResultMap">

    <id property="id" column="id" />

    <result property="userId" column="user_id" />

    <result property="number" column="number" />

    <result property="createtime" column="createtime" />

    <result property="note" column="note" />

     

    <!-- association :配置一对一属性 -->

    <!-- property:order里面的User属性名 -->

    <!-- javaType:属性类型 -->

    <association property="user" javaType="user">

    <!-- id:声明主键表示user_id是关联查询对象的唯一标识-->

    <id property="id" column="user_id" />

    <result property="username" column="username" />

    <result property="address" column="address" />

    </association>

     

    </resultMap>

     

    <!-- 一对一关联,查询订单,订单内部包含用户属性 -->

    <select id="queryOrderUserResultMap" resultMap="orderUserResultMap">

    SELECT

    o.id,

    o.user_id,

    o.number,

    o.createtime,

    o.note,

    u.username,

    u.address

    FROM

    `order` o

    LEFT JOIN `user` u ON o.user_id = u.id

    </select>

    2.3mapper接口:

    编写UserMapper如下图:

    2.4测试方法:

    在UserMapperTest增加测试方法,如下:

    @Test

    public void testQueryOrderUserResultMap() {

    // mybatis和spring整合,整合之后,交给spring管理

    SqlSession sqlSession = this.sqlSessionFactory.openSession();

    // 创建Mapper接口的动态代理对象,整合之后,交给spring管理

    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

    // 使用userMapper执行根据条件查询用户

    List<Order> list = userMapper.queryOrderUserResultMap();

    for (Order o : list) {

    System.out.println(o);

    }

    // mybatis和spring整合,整合之后,交给spring管理

    sqlSession.close();

    }

    2.5.测试效果:

    测试效果如下图:

     

     

     

     

     

     

     

     

     

     

    展开全文
  • MyBatis基础篇之使用association解决一对一关联查询

    万次阅读 多人点赞 2018-03-09 20:10:13
    、前言上章节&lt;&...接下来我们将介绍一下association标签的相关用法,包括嵌套查询和分段查询两种方式。二、案例♦参照前面介绍的相关章节,如&lt;&lt;MyBatis基础篇之简单入...
  • mybatis学习笔记(6):一对一关联查询

    万次阅读 2018-07-01 12:16:09
    在mybatis中,对于一对一、多对一都可以使用&amp;amp;amp;lt;association&amp;amp;amp;gt;标签关联一方。 准备工作,创建两个表: tbl_employee:员工表,使用dept_id关联部门表 tbl_department: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,378,153
精华内容 551,261
关键字:

一对一关联查询