Mybatis单向多对一

一、假定一个父母有多个孩子,那父母和孩子对应关系为1对多。

二、 1、添加依赖包,参考上篇文章 Mybatis+mysql入门使用

2、初始化数据库和初始数据,以mysql为例

DROP DATABASE IF EXISTS moy_mybatis;
CREATE DATABASE moy_mybatis CHARACTER SET UTF8;
USE moy_mybatis;

DROP TABLE  IF EXISTS t_children;
CREATE TABLE t_children(
  children_id INT(11),
  children_name VARCHAR(50) DEFAULT NULL,
  children_birthday DATE DEFAULT NULL,
  parent_id INT(11) NOT NULL,
  PRIMARY KEY (`children_id`)
);

DROP TABLE  IF EXISTS t_parent;
CREATE TABLE t_parent(
  id INT(11)  ,
  name VARCHAR(50) DEFAULT NULL,
  birthday DATE DEFAULT NULL,
  PRIMARY KEY (id)
);

INSERT INTO t_children(children_id,children_name,children_birthday,parent_id)
VALUES (1,‘一号熊孩子‘,now(),1);
INSERT INTO t_children(children_id,children_name,children_birthday,parent_id)
VALUES (2,‘二号熊孩子‘,now(),1);
INSERT INTO t_children(children_id,children_name,children_birthday,parent_id)
VALUES (3,‘三号熊孩子‘,now(),2);

INSERT INTO t_parent(id,name,birthday)
VALUES (1,‘一号父母‘,now());
INSERT INTO t_parent(id,name,birthday)
VALUES (2,‘二号父母‘,now());

3、新建实体类Children和Parent

package com.moy.mybatis3.entity;

import java.util.Date;

/**
 * [Project]:moy-gradle-project  <br/>
 * [Email]:[email protected]  <br/>
 * [Date]:2018/2/19  <br/>
 * [Description]:  <br/>
 *
 * @author YeXiangYang
 */
public class Children {

    private int childrenId;
    private String childrenName;
    private Date childrenBirthday;

    public int getChildrenId() {
        return childrenId;
    }

    public void setChildrenId(int childrenId) {
        this.childrenId = childrenId;
    }

    public String getChildrenName() {
        return childrenName;
    }

    public void setChildrenName(String childrenName) {
        this.childrenName = childrenName;
    }

    public Date getChildrenBirthday() {
        return childrenBirthday;
    }

    public void setChildrenBirthday(Date childrenBirthday) {
        this.childrenBirthday = childrenBirthday;
    }

    @Override
    public String toString() {
        return "Children{" +
                "childrenId=" + childrenId +
                ", childrenName=‘" + childrenName + ‘\‘‘ +
                ", childrenBirthday=" + childrenBirthday +
                ‘}‘;
    }
}

package com.moy.mybatis3.entity;

import java.util.Date;
import java.util.List;

/**
 * [Project]:moy-gradle-project  <br/>
 * [Email]:[email protected]  <br/>
 * [Date]:2018/2/19  <br/>
 * [Description]:  <br/>
 *
 * @author YeXiangYang
 */
public class Parent {

    private int id;
    private String name;
    private Date birthday;
    private List<Children> children;

    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 Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public List<Children> getChildren() {
        return children;
    }

    public void setChildren(List<Children> children) {
        this.children = children;
    }

    @Override
    public String toString() {
        return "Parent{" +
                "id=" + id +
                ", name=‘" + name + ‘\‘‘ +
                ", birthday=" + birthday +
                ", children=" + children +
                ‘}‘;
    }
}

4、新建实体对应配置文件Children.xml和Parent.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.moy.mybatis3.mapper.ChildrenMapper">
    <!--单向多对1 配置方法一 开始-->
    <resultMap id="ChildrenResultMap" type="Children">
        <id property="childrenId" column="children_id"/>
        <result property="childrenName" column="children_name"/>
        <result property="childrenBirthday" column="children_birthday"/>
    </resultMap>
    <!--单向多对1 配置方法一 结束-->
</mapper>

<?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.moy.mybatis3.mapper.ParentMapper">
    <!--单向多对1 配置方法一 开始-->
    <!--<resultMap id="ParentResultMap" type="Parent">-->
        <!--<id property="id" column="id"/>-->
        <!--<result property="name" column="name"/>-->
        <!--<result property="birthday" column="birthday"/>-->
        <!--<collection property="children" resultMap="com.moy.mybatis3.mapper.ChildrenMapper.ChildrenResultMap"/>-->
    <!--</resultMap>-->
    <!--单向多对1 配置方法一 结束-->

    <!--单向多对1 配置方法二 开始-->
    <resultMap id="ParentResultMap" type="Parent">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="birthday" column="birthday"/>
        <collection property="children"  ofType="Children" >
            <id property="childrenId" column="children_id"/>
            <result property="childrenName" column="children_name"/>
            <result property="childrenBirthday" column="children_birthday"/>
        </collection>
    </resultMap>
    <!--单向多对1 配置方法二 结束-->

    <select id="queryParentAndChildren" parameterType="int" resultMap="ParentResultMap">
          SELECT * FROM t_Parent p LEFT JOIN t_Children c  ON  p.id = c.parent_id WHERE 1=1 AND p.id  = #{id}
    </select>
</mapper>

5、编写接口ParentMapper

package com.moy.mybatis3.mapper;

import com.moy.mybatis3.entity.Parent;

/**
 * [Project]:moy-gradle-project  <br/>
 * [Email]:[email protected]  <br/>
 * [Date]:2018/2/19  <br/>
 * [Description]:  <br/>
 *
 * @author YeXiangYang
 */
public interface ParentMapper extends BaseMapper<Parent> {

    Parent queryParentAndChildren(int id);
}

6、为了方便测试,编写一个获取SqlSession的工具类Mybatis3Utils

package com.moy.mybatis3.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.Reader;
import java.util.Objects;

/**
 * [Project]:moy-gradle-project  <br/>
 * [Email]:[email protected]  <br/>
 * [Date]:2018/2/19  <br/>
 * [Description]:  <br/>
 *
 * @author YeXiangYang
 */
public abstract class Mybatis3Utils {

    public static final SqlSessionFactory sqlSessionFactory;
    public static final ThreadLocal<SqlSession> sessionThread = new ThreadLocal<>();

    static {
        try {
            Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static SqlSession getCurrentSqlSession() {
        SqlSession sqlSession = sessionThread.get();
        if (Objects.isNull(sqlSession)) {
            sqlSession = sqlSessionFactory.openSession();
            sessionThread.set(sqlSession);
        }
        return sqlSession;
    }

    public static void closeCurrentSession() {
        SqlSession sqlSession = sessionThread.get();
        if (Objects.nonNull(sqlSession)) {
            sqlSession.close();
        }
        sessionThread.set(null);
    }
}

7、新建mybatis配置信息文件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>
    <typeAliases>
        <package name="com.moy.mybatis3.entity"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/moy_mybatis?useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="123"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="mapper/Parent.xml"></mapper>
        <mapper resource="mapper/Children.xml"></mapper>
    </mappers>
</configuration>

8、编写测试类ParentMapperTest

package com.moy.mybatis3.mapper;

import com.moy.mybatis3.entity.Children;
import com.moy.mybatis3.entity.Parent;
import com.moy.mybatis3.utils.Mybatis3Utils;
import org.apache.ibatis.session.SqlSession;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.List;

import static org.junit.Assert.*;

/**
 * [Project]:moy-gradle-project  <br/>
 * [Email]:[email protected]  <br/>
 * [Date]:2018/2/20  <br/>
 * [Description]:  <br/>
 *
 * @author YeXiangYang
 */
public class ParentMapperTest {

    SqlSession sqlSession;
    ParentMapper parentMapper;

    @Before
    public void before() {
        sqlSession = Mybatis3Utils.getCurrentSqlSession();
        parentMapper = sqlSession.getMapper(ParentMapper.class);
    }

    @After
    public void after() {
        Mybatis3Utils.closeCurrentSession();
    }

    @Test
    public void queryParentAndChildren() {
        Parent parent = parentMapper.queryParentAndChildren(1);
        System.out.println(parent);
    }
}

yexiangyang

[email protected]


原文地址:https://www.cnblogs.com/moy25/p/8455879.html

时间: 2024-10-12 19:21:54

Mybatis单向多对一的相关文章

6、JPA_映射单向多对一的关联关系(n的一方有1的引用,1的一方没有n的集合属性)

单向多对一的关联关系 具体体现:n的一方有1的引用,1的一方没有n的集合属性 举个例子:订单Order和顾客Customer是一个单向多对一的关联关系.Order是n的一方,有对Customer的引用:而Customer作为1的一方却没有Order的集合属性. 主要是对n的一方使用@ManyToOne和@JoinColumn注解.而1的一方不需要做任何修改.具体的映射方法: 1.采用@ManyToOne注解映射多对一的关联关系,默认情况下采用“左外连接”的方式进行加载.可以通过配置@ManyTo

Hibernate单向多对多

最近做一个OA系统,用到了Hibernate框架,我发现,权限和角色的关系是一种多对多的关系,一个权限可以分配给多个角色,一个角色拥有多个权限. 多对多关系有两种,一种是单向的,一种是多向的.对于这个问题,曾经让我很犯难.单纯在语言上理解,会比较复杂,而从代码上理解,可能就会明白了. 下面模拟为角色授权的过程: 1,Hibernate使用Annotation 2,使用Junit进行测试. 3,使用Mysql作为后台数据库. 4,Hibernate不使用自动建表,也不采用反向工程. 过程 : 1,

(6)MyBatis之多对多关联

引言 MyBatis之多对多 1 创建我们的数据库 2 创建Student持久化类 3 创建Course持久化类 4 创建CS持久化类用于查询某学生某课程的成绩 5 根据需求编写映射文件 51 Student的映射文件 52 Course映射文件 53 CS映射文件 6 编写SQL相应的语句 61 查询选修某课程的所有学生一个Course对象里面有Student数组 62 查询某学生查询的课程信息一个Student对象里面有Course数组 63 查询某学生某课程的成绩信息 7 编写测试类 71

Hibernate单向“多对一”关联

1. 基于外键关联的单向"多对一"关联是最常见的单向关联其中指定many-to-one的unique="true",为单向"一对一",不指定就是单向"多对一" <class name="Person">    <id name="id" column="personId"><generator class="native&quo

Hibernate单向多对一级联删除引发的问题

Hibernate单向多对一在级联删除时,会出现一些问题. 下面模拟我遇到的问题: 这次模拟与之前的一次模拟方法一直,博客:http://blog.csdn.net/openjdk8/article/details/38424403 模拟场景:有一个部门表t_dept,职位表t_position. 需求:当删除部门表时,不管职位表有没数据,照样删除.删除职位表就直接删除. 1,建表: 建表: t_dept::部门表 t_position:职位表 CREATE TABLE t_dept(    d

(十三)Hibernate中的多表操作(3):单向多对多

多对多的处理方式是,有一张中间表,中间表保存两个多方之间的关系.首先来看实际应用场景:在之前开发的系统中,应用了基于角色的控制访问,也就是RBAC模型,一个用户可能存在多种角色,一种角色也可能有多个用户,所以用户和角色之间是一个多对多的关系. 案例一:  使用注解方式实现多对多关系 RoleBean.java package bean; import java.io.Serializable; import java.util.HashSet; import java.util.Set; imp

Mybatis的多对多映射

一.Mybatis的多对多映射 本例讲述使用mybatis开发过程中常见的多对多映射查询案例.只抽取关键代码和mapper文件中的关键sql和配置,详细的工程搭建和Mybatis详细的流程代码可参见<Mybatis入门和简单Demo>和<Mybatis的CRUD案例> 完整的工程代码已上传至https://files.cnblogs.com/files/jiyukai/MyBatis.zip 案例:查询xx同学所选择的多个不同选修课,查询xx选修课被多少同学选修 步骤1.建表脚本,

hibernate中配置单向多对一关联,和双向一对多

什么是一对多,多对一?双向多对一和双向一对多是不是同一个概念? 是一个概念,双向多对一和双向一对多都是配置一个 一对多和多对一 一对多,比如你去找一个父亲的所有孩子,孩子可能有两个,三个甚至四个孩子. 这就是一对多 父亲是1 孩子是多 多对一,比如你到了两个孩子,它们都是有一个共同的父亲. 此时孩子就是多 父亲是1  总结: 一对多就是: 1找到n 多对一就是: n找到1 有些人写概念写一大堆搞起我之前是一脸懵逼,还好弄懂了(手动滑稽) 配置单向多对一 通过上面我们可以了解,双向一对多是 1找n

MyBatis之多对一关系

MyBatis之多对一和一对多 多对一理解 多对一理解起来就是多张表中的数据对应一个数据,比如Student表中多个学生对应Teacher表中的一位老师.(这里指的是学校里上课的老师)通俗理解就是一个老师可以教多个学生 MyBatis中在处理多对一的sql语句方式有两种,一种是以子查询的方式,另一种是联表查询 子查询sql语句简单,但是映射关系相对复杂 下面是在MyBatis中StudentMapper.xml用子查询方式进行多对一查询 <mapper namespace="com.wcz