精华内容
下载资源
问答
  • Mybatis一对一增删修改查完整项目,是基于人与身份证的实体类,project可导入idea,建设mysql的表,改一下mysql连接就能直接运行,Mybatis一对一增删修改查完整项目,Mybatis一对一增删修改查完整项目
  • mybatis一对一的三种实现方式

    万次阅读 2017-01-04 12:43:35
    mybatis一对一的三种实现方式。使用双引号直接设置属性、使用 association 的 resultMap 模式、使用 association 的 select 模式。

    mybatis一对一的三种实现方式

    数据准备:

    使用mysql数据库作为测试。建表语句及测试数据:

    CREATE TABLE `classes` (
      `class_id` int(11) NOT NULL AUTO_INCREMENT,
      `class_name` varchar(255) DEFAULT NULL,
      KEY `class_id` (`class_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1003 DEFAULT CHARSET=utf8;

    insert  into `classes`(`class_id`,`class_name`) values (1001,'一班'),(1002,'二班');

    CREATE TABLE `student` (
      `student_id` int(11) NOT NULL AUTO_INCREMENT,
      `name` varchar(255) DEFAULT NULL,
      `age` int(11) DEFAULT NULL,
      `class_id` int(11) DEFAULT NULL,
      KEY `student_id` (`student_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=10004 DEFAULT CHARSET=utf8;

    insert  into `student`(`student_id`,`name`,`age`,`class_id`) values (10001,'张三',20,1001),(10002,'李四',21,1001),(10003,'王五',22,1002);

    model类:

    Student.java

    package com.example.model;
    
    /**
     * @author wrp
     * @Description com.example.model.Student
     * @Date 2017/1/4
     */
    public class Student {
    
        private Integer studentId;
    
        private String name;
    
        private Integer age;
    
        private Integer classId;
    
        private Classes classes;
    
        public Integer getStudentId() {
            return studentId;
        }
    
        public void setStudentId(Integer studentId) {
            this.studentId = studentId;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public Integer getClassId() {
            return classId;
        }
    
        public void setClassId(Integer classId) {
            this.classId = classId;
        }
    
        public Classes getClasses() {
            return classes;
        }
    
        public void setClasses(Classes classes) {
            this.classes = classes;
        }
    }
    

    Classes.java

    package com.example.model;
    
    /**
     * @author wrp
     * @Description com.example.model.Class
     * @Date 2016/12/30
     */
    public class Class {
    
        private Integer classId;
    
        private String className;
    
        public Integer getClassId() {
            return classId;
        }
    
        public void setClassId(Integer classId) {
            this.classId = classId;
        }
    
        public String getClassName() {
            return className;
        }
    
        public void setClassName(String className) {
            this.className = className;
        }
    }

    mybatis xml:

    Classes.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.example.dao.ClassesDao">
    
        <resultMap id="ClassesMap" type="com.example.model.Classes">
            <id property="classId" column="class_id" />
            <result property="className" column="class_name" />
        </resultMap>
    
        <select id="getClasses" parameterType="java.lang.Integer" resultMap="ClassesMap">
            SELECT
            t.class_id,
            t.class_name
            FROM classes t
            WHERE t.class_id = #{classId}
        </select>
    
    </mapper>

    Student.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.example.dao.StudentDao">
    
        <!-- 一对一关联 方式一 begin -->
        <select id="selectAllStudent1" resultType="com.example.model.Student">
            SELECT
            t.student_id as studentId,
            t.name as name,
            t.age as age,
            t.class_id as classId,
            t2.class_id "classes.classId",
            t2.class_name "classes.className"
            FROM student t
            LEFT JOIN classes t2 ON t.class_id=t2.class_id
        </select>
        <!-- 一对一关联 方式一 end -->
    
        <!-- 一对一关联 方式二 begin -->
        <resultMap id="StudentMap2" type="com.example.model.Student">
            <id property="studentId" column="student_id" />
            <result property="name" column="name" />
            <result property="age" column="age" />
            <result property="classId" column="class_id" />
            <association property="classes" resultMap="com.example.dao.ClassesDao.ClassesMap" />
        </resultMap>
        <!--<resultMap id="StudentMap2" type="com.example.model.Student">
            <id property="studentId" column="student_id" />
            <result property="name" column="name" />
            <result property="age" column="age" />
            <result property="classId" column="class_id" />
            <association property="classes" javaType="com.example.model.Classes">
                <id property="classId" column="class_id" />
                <result property="className" column="class_name" />
            </association>
        </resultMap>-->
        <select id="selectAllStudent2" resultMap="StudentMap2">
            SELECT
            t.student_id,
            t.name,
            t.age,
            t.class_id,
            t2.class_name
            FROM student t
            LEFT JOIN classes t2 ON t.class_id=t2.class_id
        </select>
        <!-- 一对一关联 方式二 end -->
    
        <!-- 一对一关联 方式三 begin -->
        <resultMap id="StudentMap3" type="com.example.model.Student">
            <id property="studentId" column="student_id" />
            <result property="name" column="name" />
            <result property="age" column="age" />
            <result property="classId" column="class_id" />
            <association property="classes" column="class_id" select="com.example.dao.ClassesDao.getClasses" />
        </resultMap>
        <select id="selectAllStudent3" resultMap="StudentMap3">
            SELECT
            t.student_id,
            t.name,
            t.age,
            t.class_id
            FROM student t
        </select>
        <!-- 一对一关联 方式三 end -->
    
    </mapper>

    dao类:

    ClassesDao.java

    package com.example.dao;
    
    import com.example.model.Classes;
    
    /**
     * @author wrp
     * @Description com.example.dao.Classes
     * @Date 2017/1/4
     */
    public interface ClassesDao {
    
        Classes getClasses(Integer classId);
    
    }

    StudentDao.java

    package com.example.dao;
    
    import com.example.model.Student;
    
    import java.util.List;
    
    /**
     * @author wrp
     * @Description com.example.dao.StudentDao
     * @Date 2017/1/4
     */
    public interface StudentDao {
    
        List<Student> selectAllStudent1();
    
        List<Student> selectAllStudent2();
    
        List<Student> selectAllStudent3();
    
    }
    

    测试用例:

    StudentDaoTest.java

    package com.example.dao;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    import com.example.model.Student;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.util.List;
    
    /**
     * @author wrp
     * @Description com.example.dao.StudentDaoTest
     * @Date 2017/1/4
     */
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class StudentDaoTest {
    
        @Autowired
        private StudentDao studentDao;
    
        @Test
        public void selectAllStudent1() {
            List<Student> students = studentDao.selectAllStudent1();
            System.out.println(JSON.toJSONString(students));
            //[{"age":20,"classId":1001,"classes":{"classId":1001,"className":"一班"},"name":"张三","studentId":10001},{"age":21,"classId":1001,"classes":{"classId":1001,"className":"一班"},"name":"李四","studentId":10002},{"age":22,"classId":1002,"classes":{"classId":1002,"className":"二班"},"name":"王五","studentId":10003}]
        }
    
        @Test
        public void selectAllStudent2() {
            List<Student> students = studentDao.selectAllStudent2();
            System.out.println(JSON.toJSONString(students));
        }
    
        @Test
        public void selectAllStudent3() {
            List<Student> students = studentDao.selectAllStudent3();
            // 禁用FastJson的“循环引用检测”特性。
            System.out.println(JSON.toJSONString(students, SerializerFeature.DisableCircularReferenceDetect));
        }
    
    }

    注意:

    1:本文三种方式排序按照个人建议,第三种可能会带来N+1的查询次数。

    2:FastJson转换json,会有循环引用检测的特性,需要加SerializerFeature.DisableCircularReferenceDetect参数禁用。


    展开全文
  • 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的值

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

    展开全文
  • mybatis一对一、一对多关联使用及结果嵌套和条件嵌套理解 2017年08月08日 15:04:00 阅读数:498 例一:使用association进行一对一关联查询,这里使用条件嵌套并且嵌套两层     public class ...

    mybatis一对一、一对多关联使用及结果嵌套和条件嵌套理解

    2017年08月08日 15:04:00

    阅读数:498

    例一:使用association进行一对一关联查询,这里使用条件嵌套并且嵌套两层

     

     
    1. public class ServerorderEntity

    2. {

    3. private String id;

    4. private String serverProductId;

    5. private ServerproductEntity serverProduct;

    6. }

    7.  
    8. public class ServerproductEntity

    9. {

    10. private String id;

    11. private String serverTicketTypeId;

    12. private ServertickettypeEntity serverTicketType;

    13. }

    14.  
    15. public class ServertickettypeEntity

    16. {

    17. private String id;

    18. }

    三个类分别是,订单,产品,优惠券。现要求查订单详情包含服务产品信息,产品包含优惠券信息。xml处理如下:

     

    上面的写法,是将原本一个比较复杂的多个连接查询,拆成3个简单的查询进行关联起来。这样做思路比较清晰

     

    例二:使用association和collection进行一对一、一对多关联查询,这里使用结果嵌套并且嵌套两层。

     

     
    1. public class OrderpayticketEntity

    2. {

    3. private String id;

    4. private List<OrderpayticketdetailEntity> orderPayTicketDetailList;

    5. }

    6.  
    7. public class OrderpayticketdetailEntity

    8. {

    9. private String id;

    10. private String orderpayticketId;

    11. private String serverTicketTypeId;

    12. private ServertickettypeEntity serverTicketType;

    13. }

    14.  
    15. public class ServertickettypeEntity

    16. {

    17. private String id;

    18. }

    三个类分别是,订单付券,订单付券明细,优惠券。现要求查订单付券信息包含付券明细信息(集合),付券明细包含优惠券信息。这里类字段简单写,xml详细按照实际操作写。主要为了说明结果嵌套的优劣。xml处理如下:

     

    这里通过左连接查询出所有结果,然后在用resultMap,collection,association把查询出的结果按要求一个个嵌套。这种结果嵌套的缺点很明显,sql语句和resultMap写的有点麻烦,但是优势就是一条sql就能解决所有。至于不用例一的条件嵌套的原因是,如果集合长度是N,那得进行1+N+N次查询,数据库性能消耗会很大。

     

    简单理解mybatis的一级缓存和二级缓存:mybatis的一级缓存的作用域是一次sqlSession,其缓存原理是一个map,以sql作为key。二级缓存的作用域是application级别,但并不是简单地对整个Application就只有一个Cache缓存对象,它将缓存划分的更细为Mapper级别的,即每一个Mapper都可以拥有一个Cache对象。在sqlSession会话中将查询结果放到Cache对象中。二级缓存可以集成第三方缓存框架、自定义的Cahce接口。

    一级缓存和二级缓存使用顺序:二级------》一级----------》db

    延迟加载在一对一association、一对多collection关联的条件嵌套查询时候使用。先从单表查询、需要时再从关联表去关联查询,提高数据库性能,因为查询单表要比关联查询多张表速度要快。

    展开全文
  • Mybatis一对一、一对多、多对多查询。+MYSQL

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

    场景:使用三张数据表:student学生表、teacher教师表、position职位表

    一个学生可以有多为老师、一位老师可以有多个学生、但是一个老师只能有一个职位:教授、副教授、讲师;但是一个职位可以有多个老师:例如教授可以多人

    这里则产生了:

    一对一关系,从老师角度:老师对职位一对一

    一对多关系,从职位角度:职位对老师一对多

    多对多关系:查找被教授教导的所有学生(首先职位对老师一对多,老师再对学生再对多、这里便有了一对多对多)

    数据表:

    老师表

    CREATE TABLE `tb_teacher` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `t_no` varchar(20) DEFAULT NULL,
      `t_name` varchar(20) DEFAULT NULL,
      `position_id` int(11) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
    
    /*Data for the table `tb_teacher` */
    
    insert  into `tb_teacher`(`id`,`t_no`,`t_name`,`position_id`) values
    (1,'163314001','张文远',1),
    (2,'163314002','赵传智',1),
    (3,'163314003','风清扬',2),
    (4,'163314004','王汇智',2),
    (5,'163314005','汪思远',3);

    学生表

    CREATE TABLE `tb_student` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `t_stu_name` varchar(20) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
    
    /*Data for the table `tb_student` */
    
    insert  into `tb_student`(`id`,`t_stu_name`) values 
    
    (1,'赵依'),
    
    (2,'钱迩'),
    
    (3,'张山'),
    
    (4,'李石'),
    
    (5,'王武'),
    
    (6,'马柳');

    职位表

    CREATE TABLE `tb_position` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `t_pos_name` varchar(20) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
    
    /*Data for the table `tb_position` */
    
    insert  into `tb_position`(`id`,`t_pos_name`) values 
    
    (1,'教授'),
    
    (2,'副教授'),
    
    (3,'讲师');

    最后是教师学生关系表

    CREATE TABLE `tb_stu_teach` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `t_stu_id` int(11) DEFAULT NULL,
      `t_teach_id` int(11) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=14 DEFAULT CHARSET=utf8;
    
    /*Data for the table `tb_stu_teach` */
    
    insert  into `tb_stu_teach`(`id`,`t_stu_id`,`t_teach_id`) values 
    
    (1,1,1),
    
    (2,1,2),
    
    (3,1,3),
    
    (4,2,2),
    
    (5,2,3),
    
    (6,2,4),
    
    (7,3,3),
    
    (8,3,4),
    
    (9,3,5),
    
    (10,4,4),
    
    (11,4,5),
    
    (12,4,1);
    

    最后在eclipse中的目录结构如下:

    希望您明白sqlMapConfig该如何配置,以及jdbc.properties和log4j的作用。

    贴出POJO中的三个实体(注意:以下的POJO都用了lombok来快速生成setter和getter等,lomok具体使用,请见此文):

    Position.java

    package com.pojo;
    
    import java.io.Serializable;
    
    import lombok.Data;
    
    @Data
    public class Position implements Serializable {
    	private int id;
    	private String name;
    	
    	private Teacher teacher;
    
    }
    

    Student.java

    package com.pojo;
    
    import java.io.Serializable;
    import java.util.List;
    
    import lombok.Data;
    
    @Data
    public class Student implements Serializable {
    	private String id;
    	private String name;
    	
    	private List<Teacher> list;
    }

    Teacher.java

    package com.pojo;
    
    import java.io.Serializable;
    import java.util.List;
    
    import lombok.Data;
    
    @Data
    public class Teacher implements Serializable {
    	private int id;
    	
    	private String no;
    	private String name;
    	private List<Student> studentList;
    	
    	private Position pos;
    }
    

    注意:关系表不用以实体表示出来,表示外键关系的ID也不用写在实体中(一般我们也不使用外键)

     

    再贴另一个MybatisUtil.java工具类

    package com.util;
    
    import java.io.IOException;
    import java.io.InputStream;
    
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    
    public class MyBatisUtil {
    	private static SqlSessionFactory sqlSessionFactory = null;
    	
    	static {
    		String resource = "sqlMapConfig.xml";
    		// 首先要加载核心配置文件:从classpath下开始找。
    		InputStream in;
    		try {
    			in = Resources.getResourceAsStream(resource);
    			
    			sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
    		} catch (IOException e) {
    			throw new RuntimeException(e.getMessage());
    		}	
    	}
    	
    	public static SqlSession getSqlSession() {
    		
    		return sqlSessionFactory.openSession();
    	}
    	
    	public static SqlSessionFactory getSqlSessionFactory() {
    		return sqlSessionFactory;
    	}
    }
    

    一对一:老师对职位

    TeacherMapper.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.mapper.TeacherMapper">
    	<resultMap type="Teacher" id="teacherPositionResultMap">
    		<id property="id" column="id"/>
    		<result property="no" column="t_no"/>
    		<result property="name" column="t_name"/>
    		<!-- association:配置的一对一属性 -->
    		<!-- property:名字
    			 javaType:类型
    		 -->
    		<association property="pos" javaType="Position">
    			<id property="id" column="id"/>
    			<result property="name" column="t_pos_name"/>
    		</association>
    	</resultMap>
    	
    	<!-- 一对一关联查询,查询老师及其对应的职位 -->
    	<!-- 注意:id不能相同,当多个值传入,比如包装类的时候,我们才能够用SQL片段的形式来做if判断,单个值是不行的 -->
    	<select id="queryTeacherPositionResultMapById" resultMap="teacherPositionResultMap" parameterType="Integer">
    		SELECT *
    		FROM tb_teacher t
    		LEFT JOIN tb_position p
    		ON t.position_id = p.id
    		where t.id = #{id}
    	</select>
    
    	<select id="queryTeacherPositionResultMap" resultMap="teacherPositionResultMap">
    		SELECT *
    		FROM tb_teacher t
    		LEFT JOIN tb_position p
    		ON t.`position_id` = p.id
    	</select> 
    </mapper>

    TeacherMapper.java接口

    package com.mapper;
    
    import java.util.List;
    
    import com.pojo.Teacher;
    
    public interface TeacherMapper {
    	public List<Teacher> queryTeacherPositionResultMap();
    	
    	public Teacher queryTeacherPositionResultMapById(Integer id);
    }
    

    测试一对一:

    package com.test;
    
    import java.util.List;
    
    import org.apache.ibatis.session.SqlSession;
    import org.junit.Test;
    
    import com.mapper.TeacherMapper;
    import com.pojo.Teacher;
    import com.util.MyBatisUtil;
    
    public class TestOneToOne {
    	@Test
    	public void testOneToOne() {
    		SqlSession sqlSession = MyBatisUtil.getSqlSession();
    		System.err.println(sqlSession);
    		
    		TeacherMapper teacherMapper = sqlSession.getMapper(TeacherMapper.class);
    		
    		List<Teacher> list = teacherMapper.queryTeacherPositionResultMap();
    		
    		System.out.println(list);
    		
    		Teacher teacher = teacherMapper.queryTeacherPositionResultMapById(1);
    		System.out.println(teacher);
    	}
    }
    

     

    一对多:职位对老师

    PositionMapper.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.mapper.PositionMapper"> 
    	<resultMap type="Position" id="positionTeacherResultMap">
    		<id property="id" column="id"/>
    		<result property="name" column="t_pos_name"/> <!-- t_name -->
    		<!-- 
    		property同association中的一样是属性名称(javaBean中的);
    		javaType也同association中的是类型,
    		最后多了一个OfType,因为一对多,不像一对一是单个的!我们这里是List集合,list和List都可以。
    		一对多其中是放的一个集合所以这个是集合的泛型的类型,这里我们的list中放的是Teacher:
    		所以这里是Teacher。
    		 -->
    		<collection property="teacherList" javaType="list" ofType="Teacher" >
    			<!-- 
    				一对多出现的问题:
    					当数据库表中,主表的主键id和明细表的 ...
    					当表中的字段名相同时怎么办?多表联查?
    					
    					注意:Mybatis中做多表联查的时候,不管是
    					一对一、一对多、一对多对多:多对多:
    					都不能有字段重名的情况:不管是主键还是普通字段。
    					一旦字段重名的话,就会造成数据少自动赋值,或者覆盖,甚至重复赋值!
    					规避和解决此类问题的方法:
    						1.尽量不要表间重名,mybatis里处理起来很麻烦!id和普通字段都是。
    						但是在表多的时候,很难不会出现字段重名的情况。主键id最容易重名!
    						那么就要用以下的办法了!
    						
    						2.在mybatis中写原生SQL进行查询的时候,查的字段尽可能的少,这
    						也影响速率,强烈禁止使用*,用多少查多少!这样也能及时发现字段重
    						名的情况!
    						
    						3.最后如果真的需要查出重名的字段,并且修改数据库字段名造成的更改
    						过大,这里推荐的方式是给字段取别名,在写resultMap映射的时候,其
    						中的column属性就填写SQL语句中查出字段取的别名,这样就能解决重复
    						问题了!
    			 -->
    			<id property="id" column="t_id"/>
    			<result property="no" column="t_no"/>
    			<result property="name" column="t_name"/>	
    		</collection>
    	</resultMap>
    	
    	<select id="queryPositionTeacherResultMapById" resultMap="positionTeacherResultMap" 
    		parameterType="Integer">
    		<!-- 
    		SELECT *
    		FROM tb_position p
    		LEFT JOIN tb_teacher t
    		ON p.id = t.position_id
    		WHERE p.id = #{id}
    		-->
    		
    		SELECT 
    		p.*, 
    		t.id t_id,
    		t.t_name,
    		t.t_no
    		FROM tb_position p
    		LEFT JOIN tb_teacher t
    		ON p.id = t.position_id
    		WHERE p.id = #{id}
    	</select>
    	
    	<select id="queryPositionTeacherResultMap" resultMap="positionTeacherResultMap" >
    		<!-- 
    		SELECT *
    		FROM tb_position p
    		LEFT JOIN tb_teacher t
    		ON p.id = t.position_id
    		-->
    		
    		SELECT 
    		p.*, 
    		t.id t_id,
    		t.t_name,
    		t.t_no
    		FROM tb_position p
    		LEFT JOIN tb_teacher t
    		ON p.id = t.position_id
    		
    	</select>
    </mapper>
    
    

    TeacherMapper.java接口

    package com.mapper;
    
    import java.util.List;
    
    import com.pojo.Position;
    
    public interface PositionMapper {
    	public Position queryPositionTeacherResultMapById(Integer id);
    	
    	public List<Position> queryPositionTeacherResultMap();
    }
    

    测试一对多:

    package com.test;
    
    import java.util.List;
    
    import org.apache.ibatis.session.SqlSession;
    import org.junit.Test;
    
    import com.mapper.PositionMapper;
    import com.pojo.Position;
    import com.util.MyBatisUtil;
    
    public class TestOneToMany {
    	
    	@Test
    	public void testOneToMany() {
    		SqlSession sqlSession = MyBatisUtil.getSqlSession();
    		PositionMapper positionMapper = sqlSession.getMapper(PositionMapper.class);
    		List<Position> list = positionMapper.queryPositionTeacherResultMap();
    		
    		System.out.println(list);
    		
    		Position pos = positionMapper.queryPositionTeacherResultMapById(1);
    		
    		System.out.println(pos);
    	}
    }
    

    多对多:职位是教授的老师教授的所有学生(一对多对多:只要你愿意可以一直对多下去...)

    PositionMapper.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.mapper.PositionMapper"> 
    	<resultMap type="Position" id="positionStudentResultMap">
    		<!-- <id property="id" column="id"/> -->
    		<result property="name" column="t_pos_name"/>
    		<collection property="teacherList" javaType="list" ofType="Teacher" >
    			<result property="name" column="t_name"/>	
    			<collection property="studentList" javaType="list" ofType="Student">
    				<result property="name" column="t_stu_name"/>
    			</collection>
    		</collection>
    	</resultMap>
    	
    	<select id="selectPositionStudentByPosId" resultMap="positionStudentResultMap" parameterType="Integer">
    		SELECT p.t_pos_name, t.t_name, s.t_stu_name
    		FROM tb_position p
    		INNER JOIN tb_teacher t ON p.id = t.position_id
    		LEFT JOIN tb_stu_teach st ON st.t_teach_id = t.id
    		LEFT JOIN tb_student s ON s.id = st.t_stu_id
    		WHERE p.id = #{id}
    	</select>
    </mapper>
    
    

    PositionMapper.java接口

    package com.mapper;
    
    import com.pojo.Position;
    
    public interface PositionMapper {
    	public Position selectPositionStudentByPosId(Integer id);
    	
    }
    

    测试:

    package com.test;
    
    import org.apache.ibatis.session.SqlSession;
    import org.junit.Test;
    
    import com.mapper.PositionMapper;
    import com.pojo.Position;
    import com.util.MyBatisUtil;
    
    public class TestManyToMany {
    	
    	@Test
    	public void testManyToMany() {
    		SqlSession sqlSession = MyBatisUtil.getSqlSession();
    		PositionMapper positionMapper = sqlSession.getMapper(PositionMapper.class);
    		Position pos = positionMapper.selectPositionStudentByPosId(1);
    		
    		System.out.println(pos);
    	}
    }

     

    展开全文
  • 今天使用Mybatis一对一关联查询时候出现一个问题,只能查出关联表主键,无法查询出关联表中的其他数据:   Mybatis的代码: mapper namespace="com.usc.user.mapper.UserMapper">   "UserBean" id=...
  • mybatis做association的关联时,后台执行了association的 查询语句,但是得到的结果中association关联的对象为null。 代码截图如下 ![图片说明](https://img-ask.csdn.net/upload/201706/02/1496387794_219788.png...
  • 创建Product对象,在创建PrdBusiness对象并继承Product对象。 Mapper文件中的SQL语句为: SELECT product.*,prd.* FROM product INNER JOIN prd ON product.prd_id=prd.prd_id 测试结果为: ...
  • 今天在做个增删改功能时候,用到了mybatis的accociation 关联学生信息,但是一直回显不成功,发现查询的学生信息为空。 dao中这样写的  select * from xgxt_bzb_zhcp_jjf  where pkey=#{pkey} ...
  • mybatis 一对一的映射(两种方式)

    万次阅读 2015-08-05 20:25:22
    对于一对一的关系映射一共有两种解决方案: 开发步骤:1)写OrdersMapperUser.xml文件 2)编写与xml同名的接口OrdersMapperUser 3)测试 声明:一下xml文件的代码都在中 方式一:使用包装类完成映射关系(比较容易...
  • MyBatis一对一demo!!!

    千次阅读 2011-03-03 12:08:00
    ClassesMapper.xml <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper ...<mapper namespace="com.nantian.mybatis.one2one.ClassesMapper"> <resultMap ty
  • public interface OneToOneTestDao { public List<Classes> listClasses(); }
  • 里面的type不一定是pojo文件夹下的实体类,如果是自己封装,可以是vo或者dto下的自己定义的,如果这个类下有其他pojo的类对象作为他的...作为他的成员,那么就是一对多映射,那就用来映射; ...
  • mybatis 一对多性能优化 demo mybatis 一对多性能优化 demo
  • MyBatis一对多映射

    2017-05-26 10:59:39
    MyBatis一对多映射实例,代码完整,可运行
  • mybatis一对多的查询方法详解! mybatis一对多的查询方法详解! mybatis一对多的查询方法详解! mybatis一对多的查询方法详解!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 212,871
精华内容 85,148
关键字:

mybatis一对一