精华内容
下载资源
问答
  • 实现Mybatis框架中一对一关联映射的查询操作。 User用户表 - User_Card身份证表属于 1-1 的关系
  • mybatis一对多的查询方法详解! mybatis一对多的查询方法详解! mybatis一对多的查询方法详解! mybatis一对多的查询方法详解!
  • Mybatis 关联查询一对一与一对多)

    万次阅读 2019-08-18 19:55:11
    1、一对一查询 需求:查询所有订单信息,关联查询下单用户信息。 注意:因为一个订单信息只会是一个人下的订单,所以从查询订单信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的订单信息则...

    数据库表与表之间的关系:

    1、一对一查询

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

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

    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.1 方法一:使用resultType

            使用resultType,改造订单pojo类,此pojo类中包括了订单信息和用户信息,这样返回对象的时候,mybatis自动把用户信息也注入进来了。

    1.1.1 改造pojo类

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

    1.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.1.3 Mapper接口:在UserMapper接口添加方法,如下图:

    1.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.1.5 结果

    1.2 方法二:使用resultMap

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

    1.2.1 改造pojo类

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

    1.2.2 Mapper.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>

    1.2.3 Mapper接口:编写UserMapper如下图:

    1.2.4 测试

    @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();
    }

    1.2.5 结果

    2 一对多查询

    案例:查询所有用户信息及用户关联的订单信息。

    用户信息和订单信息为一对多关系。

    sql语句:

    SELECT
    	u.id,
    	u.username,
    	u.birthday,
    	u.sex,
    	u.address,
    	o.id oid,
    	o.number,
    	o.createtime,
    	o.note
    FROM
    	`user` u
    LEFT JOIN `order` o ON u.id = o.user_id

    2.1 改造pojo类

    在User类中加入List<Order> orders属性,如下图:

    2.2 Mapper.xml,在UserMapper.xml中添加sql,如下:

    <resultMap type="user" id="userOrderResultMap">
    	<id property="id" column="id" />
    	<result property="username" column="username" />
    	<result property="birthday" column="birthday" />
    	<result property="sex" column="sex" />
    	<result property="address" column="address" />
    
    	<!-- 配置一对多的关系 -->
    	<collection property="orders" javaType="list" ofType="order">
    		<!-- 配置主键,是关联Order的唯一标识 -->
    		<id property="id" column="oid" />
    		<result property="number" column="number" />
    		<result property="createtime" column="createtime" />
    		<result property="note" column="note" />
    	</collection>
    </resultMap>
    
    <!-- 一对多关联,查询订单同时查询该用户下的订单 -->
    <select id="queryUserOrder" resultMap="userOrderResultMap">
    	SELECT
    	u.id,
    	u.username,
    	u.birthday,
    	u.sex,
    	u.address,
    	o.id oid,
    	o.number,
    	o.createtime,
    	o.note
    	FROM
    	`user` u
    	LEFT JOIN `order` o ON u.id = o.user_id
    </select>

    2.3 Mapper接口,编写UserMapper接口,如下:

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

    @Test
    public void testQueryUserOrder() {
    	// mybatis和spring整合,整合之后,交给spring管理
    	SqlSession sqlSession = this.sqlSessionFactory.openSession();
    	// 创建Mapper接口的动态代理对象,整合之后,交给spring管理
    	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    
    	// 使用userMapper执行根据条件查询用户
    	List<User> list = userMapper.queryUserOrder();
    
    	for (User u : list) {
    		System.out.println(u);
    	}
    
    	// mybatis和spring整合,整合之后,交给spring管理
    	sqlSession.close();
    }

    2.5 结果

    展开全文
  • MyBatis实现一对一,一对多关联查询

    万次阅读 多人点赞 2019-09-25 00:20:31
    MyBatis如何实现一对一,一对多查询的? 可以通过关联查询实现。关联查询是几个表联合查询,只查询一次,通过在resultMap里面的association,collection节点配置一对一,一对多的类就可以完成 具体实现如下 准备...

    MyBatis如何实现一对一,一对多查询的?

    可以通过关联查询实现。关联查询是几个表联合查询,只查询一次,通过在resultMap里面的association,collection节点配置一对一,一对多的类就可以完成

    具体实现如下

    准备数据库表结构与数据

    班级classes与老师teacher是一对一的关系

    班级classes与学生student是一对多的关系

    
    SET NAMES utf8mb4;
    SET FOREIGN_KEY_CHECKS = 0;
    
    -- ----------------------------
    -- Table structure for classes
    -- ----------------------------
    DROP TABLE IF EXISTS `classes`;
    CREATE TABLE `classes`  (
      `c_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '班级id',
      `c_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '班级名',
      `teacher_id` int(11) NULL DEFAULT NULL COMMENT '老师id',
      PRIMARY KEY (`c_id`) USING BTREE
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic COMMENT '班级表';
    
    -- ----------------------------
    -- Records of classes
    -- ----------------------------
    INSERT INTO `classes` VALUES (1, '高三2班', 1);
    INSERT INTO `classes` VALUES (2, '高一4班', 2);
    
    -- ----------------------------
    -- Table structure for teacher
    -- ----------------------------
    DROP TABLE IF EXISTS `teacher`;
    CREATE TABLE `teacher`  (
      `t_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '老师id',
      `t_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '老师姓名',
      PRIMARY KEY (`t_id`) USING BTREE
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic COMMENT '老师表';
    
    -- ----------------------------
    -- Records of teacher
    -- ----------------------------
    INSERT INTO `teacher` VALUES (1, '老师张三');
    INSERT INTO `teacher` VALUES (2, '老师李四');
    
    SET NAMES utf8mb4;
    SET FOREIGN_KEY_CHECKS = 0;
    
    -- ----------------------------
    -- Table structure for student
    -- ----------------------------
    DROP TABLE IF EXISTS `student`;
    CREATE TABLE `student`  (
      `s_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '学生id',
      `s_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '学生姓名',
      `class_id` int(11) NULL DEFAULT NULL COMMENT '班级id',
      PRIMARY KEY (`s_id`) USING BTREE
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic COMMENT '学生表';
    
    -- ----------------------------
    -- Records of student
    -- ----------------------------
    INSERT INTO `student` VALUES (1, '学生小明', 1);
    INSERT INTO `student` VALUES (2, '学生小陈', 1);
    INSERT INTO `student` VALUES (3, '学生小张', 2);
    
    SET FOREIGN_KEY_CHECKS = 1;
    

    数据库准备工作完成后,使用IDEA新建一个Spring Boot项目,工程目录如下

    新建Spring Boot项目

    在这里插入图片描述

    在pom.xml文件中添加如下依赖

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.0</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    

    在application.yml文件中进行数据库和mybatis配置

    # spring配置
    spring:
      # 数据库配置
      datasource:
        type: com.zaxxer.hikari.HikariDataSource
        url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf-8&autoReconnect=true&allowMultiQueries=true&useSSL=false&tinyInt1isBit=false&serverTimezone=GMT%2B8
        driverClassName: com.mysql.cj.jdbc.Driver
        username: root
        password: root
    
    # mybatis配置
    mybatis:
      # 给实体类配置别名
      type-aliases-package: com.jourwon.*.pojo
      # 加载mybatis的mapper配置文件
      mapper-locations: classpath:mybatis/mapper/**/*Mapper.xml
      configuration:
        # 开发环境控制台打印sql语句
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
        # 开启驼峰规则自动映射字段属性值;如字段为user_name的可以映射到userName属性中
        map-underscore-to-camel-case: true
        # 设置sql执行超时时间,以秒为单位的全局sql超时时间设置,当超出了设置的超时时间时,会抛出SQLTimeoutException
        default-statement-timeout: 30
        # 解决查询返回结果含null没有对应字段值问题
        call-setters-on-nulls: true
    

    新建老师类Teacher

    @Data
    public class Teacher {
    
        private int id;
    
        private String name;
    
    }
    

    新建班级类Classes

    @Data
    public class Classes {
    
        private int id;
    
        private String name;
    
        private Teacher teacher;
    
        private List<Student> studentList;
    
    
    }
    

    新建学生类Student

    @Data
    public class Student {
    
        private int id;
    
        private String name;
    
    }
    

    新建ClassesMapper.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.jourwon.mybatis.mapper.ClassesMapper">
    
        <!-- 一对一关联查询 -->
        <select id="listClasses" parameterType="int" resultMap="ClassesResultMap">
    		select * from classes c,teacher t where c.teacher_id=t.t_id and c.c_id=#{id}
    	</select>
    
        <resultMap type="com.jourwon.mybatis.pojo.Classes" id="ClassesResultMap">
            <!-- 实体类的字段名和数据表的字段名映射 -->
            <id property="id" column="c_id"/>
            <result property="name" column="c_name"/>
            <association property="teacher" javaType="com.jourwon.mybatis.pojo.Teacher">
                <id property="id" column="t_id"/>
                <result property="name" column="t_name"/>
            </association>
        </resultMap>
    
        <!-- 一对多关联查询 -->
        <select id="listClasses2" parameterType="int" resultMap="ClassesResultMap2">
    		select * from classes c,teacher t,student s where c.teacher_id=t.t_id and c.c_id=s.class_id and c.c_id=#{id}
    	</select>
    
        <resultMap type="com.jourwon.mybatis.pojo.Classes" id="ClassesResultMap2">
            <id property="id" column="c_id"/>
            <result property="name" column="c_name"/>
            <association property="teacher" javaType="com.jourwon.mybatis.pojo.Teacher">
                <id property="id" column="t_id"/>
                <result property="name" column="t_name"/>
            </association>
            <collection property="studentList" ofType="com.jourwon.mybatis.pojo.Student">
                <id property="id" column="s_id"/>
                <result property="name" column="s_name"/>
            </collection>
        </resultMap>
    
    
    </mapper>
    

    Application类

    @MapperScan(basePackages = {"com.jourwon.mybatis.**.mapper"})
    @SpringBootApplication
    public class Application {
    
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    
    }
    

    测试类

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class ApplicationTests {
    
        @Autowired
        private ClassesMapper classesMapper;
    
        /**
         * Description: 测试班级与老师一对一关联关系
         *
         * @author JourWon
         * @date 2019/9/24 23:18
         * @param 
         * @return void
         */
        @Test
        public void test01() {
    
            List<Classes> classes = classesMapper.listClasses(1);
            for (Classes aClass : classes) {
                System.out.println(classes);
            }
    
        }
    
        /**
         * Description: 测试班级与学生一对多关联关系
         *
         * @author JourWon
         * @date 2019/9/24 23:19
         * @param 
         * @return void
         */
        @Test
        public void test02() {
    
            List<Classes> classes = classesMapper.listClasses2(1);
            for (Classes aClass : classes) {
                System.out.println(classes);
            }
    
        }
    
    }
    

    测试结果

    test01()测试结果输出

    ==>  Preparing: select * from classes c,teacher t where c.teacher_id=t.t_id and c.c_id=? 
    ==> Parameters: 1(Integer)
    <==    Columns: c_id, c_name, teacher_id, t_id, t_name
    <==        Row: 1, 高三2, 1, 1, 老师张三
    <==      Total: 1
    Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@140d1230]
    [Classes(id=1, name=高三2, teacher=Teacher(id=1, name=老师张三), studentList=null)]
    

    test02()测试结果输出

    ==>  Preparing: select * from classes c,teacher t,student s where c.teacher_id=t.t_id and c.c_id=s.class_id and c.c_id=? 
    ==> Parameters: 1(Integer)
    <==    Columns: c_id, c_name, teacher_id, t_id, t_name, s_id, s_name, class_id
    <==        Row: 1, 高三2, 1, 1, 老师张三, 1, 学生小明, 1
    <==        Row: 1, 高三2, 1, 1, 老师张三, 2, 学生小陈, 1
    <==      Total: 2
    Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@140d1230]
    [Classes(id=1, name=高三2, teacher=Teacher(id=1, name=老师张三), studentList=[Student(id=1, name=学生小明), Student(id=2, name=学生小陈)])]
    

    所以,一对一关联查询需要在resultMap里面配置association,一对多关联查询需要在resultMap里面配置collection节点

    展开全文
  • 使用MyBatis写的一对多关联映射查询的web,在eclipse上写的,使用的Mysql进行数据连接,内含数据库脚本,直接导入数据库即可建数据库和建表,不用再编写,非常方便
  • Mybatis left join 一对一、一对多...-- 一对一查询 ,一个订单对应一个用户--> <resultMap type="com.Orders" id="OrdersUserResultMap"> <id column="id" property="id"/> <result column="us...

    Mybatis left join 一对一、一对多、多对多查询

    <!-- 一对一查询 ,一个订单对应一个用户-->
    <resultMap type="com.Orders" id="OrdersUserResultMap">
            <id column="id" property="id"/>
            <result column="user_id" property="userid"/>
            <result column="number" property="number"/>
             <result column="createtime" property="createTime"/>
             <result column="note" property="note"/>
             <!-- 订单关联用户 -->
             <association property="user" javaType="com.User">
                <id column="user_id" property="id"/>
                 <result column="username" property="username"/>
                 <result column="sex" property="sex"/>
                 <result column="address" property="address"/>
             </association>
     </resultMap>
    

    查询语句:

    <select id="findOrdersUser" resultType="com.OrdersCustom" resultMap="OrdersUserResultMap">
        SELECT  t1.*, t2.*
        FROM orders t1
        LEFT JOIN t_user t2
        WHERE t1.user_id=t2.id
    </select>
    

    一对多查询(left join 主要是为了当多方为null时一方可以查)和多对多
    目前有个需求:
    条件筛选出一个A表的结果list,另一张B表的uuid,
    他们之间的关联关系是 a.id=b.uuid,
    若不存在关联的B对象则返回null.
    因此考虑用左连接,不存在字段也不影响总的A表条数

    <resultMap type="com.User" id="userAndItemsResultMap">
            <!-- 用户信息 -->
            <id column="user_id" property="id"/>
            <result column="username" property="username"/>
            <result column="sex" property="sex"/>
            <result column="address" property="address"/>
            <!-- 一个用户对应多个订单 -->
            <collection property="ordersList" ofType="com.Orders">
                     <id column="id" property="id"/>
                     <result column="user_id" property="userid"/>
                    <result column="number" property="number"/>
                    <result column="createtime" property="createTime"/>
                    <result column="note" property="note"/>
                    <!-- 一个订单对应多个订单明细 -->
                    <collection property="orderdetails" ofType="com.OrderDetail">
                        <id column="orderdetail_id" property="id"/>
                        <result column="items_id"   property="itemsId"/>
                        <result column="items_num"  property="itemsNum"/>
                        <result column="orders_id"  property="ordersId"/>
                        <!-- 一个订单明细对应一个商品 -->
                        <association property="items" javaType="com.Items">
                            <id column="items_id" property="id"/>
                            <result column="items_name" property="itemsName"/>
                            <result column="items_detail" property="detail"/>
                            <result column="items_price" property="price"/>
                        </association>
                    </collection>
             </collection>
     </resultMap>
    

    优化
    before:

    SELECT 
    a.name,a.uuid,a.app_name,a.app_uuid,a.release_uuid,a.release_name,
    a.layout_template_name,a.layout_template_uuid,a.layout_template_version,
    a.cluster_uuid,a.status,a.remark,a.delete_flag,
    a.create_time,a.create_user,a.update_time,a.update_user,
    d.department_code,d.deploy_type,d.department_name,d.namespace
    FROM app_instance as a
    LEFT JOIN dms_release as d
    ON a.release_uuid = d.uuid
    AND d.delete_flag=0
    WHERE a.delete_flag=0
    ORDER BY a.create_time 
    DESC LIMIT 1,2
    

    after:

    SELECT 
    a.name,a.uuid,a.app_name,a.app_uuid,a.release_uuid,a.release_name,
    a.layout_template_name,a.layout_template_uuid,a.layout_template_version,
    a.cluster_uuid,a.status,a.remark,a.delete_flag,
    a.create_time,a.create_user,a.update_time,a.update_user,
    d.department_code,d.deploy_type,d.department_name,d.namespace
    FROM (
            select * from app_instance where delete_flag=0 
            ORDER BY create_time desc LIMIT 1,2
         ) as a
    LEFT JOIN dms_release as d
    ON a.release_uuid = d.uuid
    AND d.delete_flag=0
    

    创建索引:

    ALTER TABLE app_instance ADD INDEX index_release_uuid (release_uuid)
    

    思路:参考文献
    引申改进SQL方案:点此链接
    1.先筛选出符合条件的再进行join,而不是先全表join再筛选
    2.加入关键选项的索引

    遇到的问题及解决方案:
    问题描述: 查询时父表和子表属性名一致,查出的数据被先查出的数据覆盖。
    问题原因: 查询的SQL里选择的列中有两个列名为id的字段,导致封装成对象时出问题。
    修改方法: 把其中一个列名id使用别名(这里把role表的列名id使用别名rid)。在这里插入图片描述
    在这里插入图片描述

    展开全文
  • Mybatis实现关联查询一对一和一对多实现,具体效果看博文 http://blog.csdn.net/evankaka/article/details/45674101
  • mybatis 一对多性能优化 demo mybatis 一对多性能优化 demo
  • 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: ...

    在mybatis中,对于一对一、多对一都可以使用<association>标签关联一方。
    准备工作,创建两个表:
    tbl_employee:员工表,使用dept_id关联部门表
    这里写图片描述

    tbl_department:
    这里写图片描述

    创建两个实体类:
    Employee.java:

    public class Employee {
    
        private Integer id;
        private String lastName;
        private String gender;
        private String email;
        private Department dept;
    
        public Employee() {
            super();
        }
        public Employee(Integer id, String lastName, String gender, String email) {
            super();
            this.id = id;
            this.lastName = lastName;
            this.gender = gender;
            this.email = email;
        }
        public Integer getId() {
            return id;
        }
        public void setId(Integer id) {
            this.id = id;
        }
        public String getLastName() {
            return lastName;
        }
        public void setLastName(String lastName) {
            this.lastName = lastName;
        }
        public String getGender() {
            return gender;
        }
        public void setGender(String gender) {
            this.gender = gender;
        }
        public String getEmail() {
            return email;
        }
        public void setEmail(String email) {
            this.email = email;
        }
        public Department getDept() {
            return dept;
        }
        public void setDept(Department dept) {
            this.dept = dept;
        }
        @Override
        public String toString() {
            return "Employee [id=" + id + ", lastName=" + lastName + ", gender="
                    + gender + ", email=" + email + ", dept=" + dept + "]";
        }
    }

    Department.java:

    public class Department {
    
        private Integer id;
        private String departmentName;
    
        public Integer getId() {
            return id;
        }
        public void setId(Integer id) {
            this.id = id;
        }
        public String getDepartmentName() {
            return departmentName;
        }
        public void setDepartmentName(String departmentName) {
            this.departmentName = departmentName;
        }
        @Override
        public String toString() {
            return "Department [id=" + id + ", departmentName=" + departmentName
                    + "]";
        }
    }

    1. 关联查询方式

    1.1 创建Mapper文件
    首先定义一个接口:

    public interface EmployeeMapperPlus {
        public Employee getEmpAndDeptById(Integer id);
    }

    配置Mapper 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.mybatis.mapper.EmployeeMapperPlus">
    <!-- 定义结果集,column表示sql查询列,property表示映射到实体的属性 -->
    <resultMap type="com.mybatis.domain.Employee" id="myEmp">
        <id column="id" property="id"/>
        <result column="last_name" property="lastName"/>
        <result column="gender" property="gender"/>
        <result column="email" property="email"/>
        <!-- 关联对象 -->
        <association property="dept" javaType="com.mybatis.domain.Department">
            <!-- 关联条件Employee的dept_id对应着Department的id -->
            <id column="dept_id" property="id"/>
            <result column="department_name" property="departmentName"/>
        </association>
    </resultMap>
    <!-- resultMap指定使用上面定义的结果集,查询使用关联查询,查询列要和上面的column对应 -->
    <select id="getEmpAndDeptById" resultMap="myEmp">
        select e.id,e.last_name,e.gender,e.email,e.dept_id,d.id,d.department_name
         from tbl_employee e,tbl_department d
         where e.dept_id = d.id and e.id=#{id}
    </select>

    1.2 注册Mapper 文件
    在conf配置文件中注册:

    <mappers>
        <!-- 直接使用接口文件,必须将xml映射文件放在相同的文件夹下,会自动匹配置文件 -->
         <mapper class="com.mybatis.mapper.EmployeeMapperPlus"/>
    </mappers>

    1.3 测试

    @Test
    public void getEmpAndDeptById(){
        SqlSessionFactory factory = MyBatisUtil.getFactory();
        SqlSession session = factory.openSession();
        EmployeeMapperPlus mapper = session.getMapper(EmployeeMapperPlus.class);
        Employee employee = mapper.getEmpAndDeptById(3);
        System.out.println(employee);
        session.commit();
        session.close();
    }

    1.4 结果
    这里写图片描述
    可以看到关联成功

    需要注意的地方:
    1. 上面使用tbl_employee表中的dept_id列关联 tbl_department表的id,在实体类Employee中 不需要定义dept_id属性,定义一个Department类的属性,然后通过关联查询将关联数据塞进去。
    2.在 <association>标签中需要配置javaType的值,指定关联的类型。


    2. 分部查询

    2.1 创建部门的Mapper文件
    接口:

    public interface DepartmentMapper {
    
        public Department getDeptById(Integer id);
    
    }

    Mapper 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.mybatis.mapper.DepartmentMapper">
        <select id="getDeptById" resultType="com.mybatis.domain.Department">
            select * from tbl_department
            where id = #{id}
        </select>
    
    </mapper>

    配置Department实体的Mapper文件,创建getDeptById方法。
    并将之注册:

    <mappers>
        <!-- 直接使用接口文件,必须将xml映射文件放在相同的文件夹下,会自动匹配置文件 -->
         <mapper class="com.mybatis.mapper.EmployeeMapperPlus"/>
         <mapper class="com.mybatis.mapper.DepartmentMapper"/>
    </mappers>

    2.2 配置Employee的Mapper文件
    接口:

    public interface EmployeeMapperPlus {
    
        public Employee getEmpAndDeptByStep(Integer id);
    }

    Mapper 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.mybatis.mapper.EmployeeMapperPlus">
        <resultMap type="com.mybatis.domain.Employee" id="myEmpByStep">
            <id column="id" property="id"/>
            <result column="last_name" property="lastName"/>
            <result column="gender" property="gender"/>
            <result column="email" property="email"/>
            <!-- 使用select属性指定第二步调用的方法,并通过column指定传递的参数值,这个值是第一步的查询的数据 -->
            <association property="dept" 
                select="com.mybatis.mapper.DepartmentMapper.getDeptById"
                column="dept_id">
            </association>
        </resultMap>
        <!-- 第一步值只查询tbl_employee表 -->
        <select id="getEmpAndDeptByStep" resultMap="myEmpByStep">
            select id,last_name,gender,email,dept_id
             from tbl_employee
             where id = #{id}
        </select>
    </mapper>

    2.3 测试

    @Test
    public void getEmpAndDeptByStep(){
        SqlSessionFactory factory = MyBatisUtil.getFactory();
        SqlSession session = factory.openSession();
        EmployeeMapperPlus mapper = session.getMapper(EmployeeMapperPlus.class);
        Employee employee = mapper.getEmpAndDeptByStep(3);
        System.out.println(employee);
        session.commit();
        session.close();
    }

    2.4 结果
    这里写图片描述
    可以看到发出了两个sql,是分步查询的,而不是之前那样一条语句关联查询。

    2.5 配置懒加载
    我们可以配置懒加载以达到在不使用关联表信息的时候不进行查询的目的
    在conf文件中配置settings:

    <settings>
        <!-- 设置驼峰属性 -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!-- 配置懒加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"/>
        <!-- 其他配置略 -->
    </settings>

    在执行测试,这次只查询员工表信息:

    @Test
    public void getEmpAndDeptByStep(){
        SqlSessionFactory factory = MyBatisUtil.getFactory();
        SqlSession session = factory.openSession();
        EmployeeMapperPlus mapper = session.getMapper(EmployeeMapperPlus.class);
        Employee employee = mapper.getEmpAndDeptByStep(3);
        System.out.println(employee.getLastName());
        session.commit();
        session.close();
    }

    结果:
    这里写图片描述

    可以看出,只发出一个sql,这就是懒加载模式,分步查询时,在不适使用关联表的信息时就不会尽心查询。

    注:<association > 标签里面的column可以使用键值对传多列值,例如:

    <association property="dept" 
                select="com.mybatis.mapper.DepartmentMapper.getDeptById"
                column="{id=dept_id,xx=xx}">
            </association>

    对于 column=”{id=dept_id,xx=xx}” 中id表示getDeptById方法的参数,dept_id是第一步查询的id列。
    <association > 标签还包含一个fetchType属性,这个可以设置抓取方式,即是懒加载还是立即加载。

    展开全文
  • mybatis一对多嵌套查询: 嵌套查询特点:发送1+n条sql语句 步骤: 新建domain类: 数据库设计: 定义一个domainMapper接口: 新建一个domainMapper.xml文件 本例中为DepartmentMapper.xml: &lt;?xml version=...
  • //查询所有的用户并且显示用户的所有账号信息 @Test public void findAl2() { List<Account> list = mapper.findAccountUser(); for (Account account : list) { System.out.println(account); } } 运行...
  • 今天在做个增删改功能时候,用到了mybatis的accociation 关联学生信息,但是一直回显不成功,发现查询的学生信息为空。 dao中这样写的  select * from xgxt_bzb_zhcp_jjf  where pkey=#{pkey} ...
  • 场景:现有两张表 s_class(班级表) s_student(学生表) ...方法二:mybatis提供一对多的查询,一次查询解决 对比:方法二明显比方法一更合适,更符合需求,更方便操作 实际操作: 创...
  • mybatis关联查询问题(一对多、多对一) 博客系统源码
  • 今天使用Mybatis一对一关联查询时候出现一个问题,只能查出关联表主键,无法查询出关联表中的其他数据:   Mybatis的代码: mapper namespace="com.usc.user.mapper.UserMapper">   "UserBean" id=...
  • mybatis一对多关联查询两种方式

    万次阅读 2018-12-24 00:01:06
    mybatis一对多关联查询两种方式前提:方式一:方式二: 前提: 现在有两张表,学生表跟教师表,一个教师对应多个学生 教师表: CREATE TABLE `teacher` ( `id` int(11) PRIMARY KEY, `name` varchar(20) , `age` ...
  • (1)实现一对一关系就先在实体类中添加一个你需要对应的对象作为实体类的字段 (2)同理,实现一对多关系就现在实体类中添加一个你需要对应集合作为实体类的字段 实体类这里就这样了 重点是到下面的Mapper.x
  • Mybatis一对一、一对多、多对多查询。+MYSQL

    万次阅读 多人点赞 2018-08-09 10:03:28
    场景:使用三张数据表:student学生表、teacher教师表、...一对一关系,从老师角度:老师对职位一对一 一对多关系,从职位角度:职位对老师一对多 多对多关系:查找被教授教导的所有学生(首先职位对老师一对多...
  • Mybatis注解方式实现一对一,一对多的关联查询

    万次阅读 多人点赞 2019-01-03 12:11:31
    Step1 创建数据库表 使用Mysql WorkBench创建数据库表ssm20191229test,并创建...创建maven工程:mybatis20190103oneToOne,完整的结构目录如下: Step3 配置pom.xml和mybatis.xml pom.xml代码如下: &lt;proje...
  • MyBatis一对一表关系查询案例(一)

    千次阅读 2020-03-28 16:39:16
    //员工基本情况表和员工学历表是一对一的关系,每一个员工有且只有一份学历表 private EmployeeSchool employeeSchool; public String getEmp_no() { return emp_no; } public void setEmp_no(String emp_no) { ...
  • 使用方法请看博客 https://blog.csdn.net/bandaotixiruiqiang/article/details/72478361#comments_12931827
  • 、整合mybatis 1、建表phone_type DROP TABLE IF EXISTS `phone_type`; CREATE TABLE `phone_type` ( `type_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '类型id', `number_part` varchar(50) DEFAULT NULL ...
  • 1、业务描述:之前位好友问,如何实现,分页查询所有用户信息,并且查询的用户信息里,每条包含此用户所携带的所有工具,每个工具也是条数据。 最近我自己做项目,发现也需要实现个类似的业务,百度了很多...
  • MyBatis高级映射(一对一查询
  • PageHelper关于Mybatis一对查询返回Total错误 遇到的问题: pagehelper进行一对多查询时,返回的总数量对不上,例如需求是一个页面展示10个spu信息,实际上只展示了6个spu,其分页的依据是根据sku,6个spu中包含了...
  • Mybatis 对象嵌套关联查询一对

    千次阅读 2019-06-12 10:59:36
    mybatis嵌套关联查询如下: 请先一字一句的看完以下的文字!!!! 谢谢 我先解释一下类还有mapper文件。 这个实体类还有mapper文件是自定义的,不是mybatis映射的文件 为什么要自己创建呢?因为这个联表查询...
  • mybatis实现多表一对一,一对多,多对多关联查询

    万次阅读 多人点赞 2018-02-03 15:40:08
    1、一对一 关键字:association 作用:针对pojo对象属性的映射  property:pojo的属性名  javaType:pojo类名 (1) 嵌套结果: 使用嵌套结果映射来处理重复的联合结果的子集 <!-- 1、...
  • mybatis一对查询返回

    千次阅读 2019-06-20 19:32:52
    mybatis一对查询返回定义实体类Mapper.xml文件Mapper.java文件 定义实体类 InventoryVO 和InventoryDetailVO是一对多的关系。 @Data public class InventoryVO { /**收发 1: 收 0:发**/ private String inOrOut...
  • 错误区:在结果集中,将俩个column中的ID混淆,我这边是区分的id和model_id,如果俩个都为同样的字段,系统在数据筛选的时候会出现无法判断,所以只能读取第条数据作为最后结果。切记,结果集有集合的,在mapper...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 216,958
精华内容 86,783
关键字:

mybatis一对一查询