以顾客（一）和订单（多）为例：
1.创建一个web项目，名字叫做oneToMany


2.导入mybatis所需的包mybatis-3.4.1.jar(以自己的版本为准)
3.配置myBatis的配置文件：










4.创建Customer类和Order类








5.创建customer.xml文件和order.xml文件

Hibernate的关系映射-------多对一与一对多的实现举例
此处以部门（Department）与部门员工（Employee）为例，显而易见department为一的一方，员工为多的一方。
 
Domain层的创建：
 
Department类的实例化：
public class Department {
    private Integer id;
    private String name;
     privateSet<Employee> emps;
     
    publicSet<Employee> getEmps() {
       return emps;
    }
    public voidsetEmps(Set<Employee> emps) {
       this.e配置文件的编写代码：
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/HibernateConfiguration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 
<hibernate-configuration>
    <session-factory name="foo">
       <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
       <property name="connection.url">jdbc:mysql:///demo</property>
       <property name="hibernate.connection.username">root</property>
       <property name="connection.password">123</property>
       <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
       <property name="hibernate.hbm2ddl.auto">update</property>
       <property name="hibernate.show_sql">true</property>
       
       <mapping resource="com/hbsi/domain/Department.hbm.xml"/>
       <mapping resource="com/hbsi/domain/Employee.hbm.xml"/>  </session-factory>
</hibernate-configuration>
各个包的导入：
mps = emps;
    }
    public Integer getId() {
       return id;
    }
    public void setId(Integer id) {
       this.id = id;
    }
    public String getName() {
       return name;
    }
    public void setName(Stringname) {
       this.name = name;
    }
    
}
     Department映射文件的创建：
       <?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 
<hibernate-mapping package="com.hbsi.domain">
 
    <class name="Department" table="department">
       <id name="id">
           <generator class="native"/>
       </id>
       <property name="name"/>
       <set name="emps">
           <key column="depart_id"/><!-- 查找部门下所包含的员工，根据主外键查 -->
           <one-to-many class="Employee"/>    
       </set>
    </class>
</hibernate-mapping>
Employee的实例化：
public class Employee {
    private Integer id;
    private String name;
    private Department depart;
    
    public Integer getId() {
       return id;
    }
    public void setId(Integer id) {
       this.id = id;
    }
    public String getName() {
       return name;
    }
    public void setName(Stringname) {
       this.name = name;
    }
    public DepartmentgetDepart() {
       return depart;
    }
    public voidsetDepart(Department depart) {
       this.depart = depart;
    }
    
}
Employee映射文件的创建：
              <?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 
<hibernate-mapping package="com.hbsi.domain">
 
    <class name="Employee" table="employee">
       <id name="id">
           <generator class="native"/>
       </id>
       <property name="name"/>
       <many-to-one name="depart"column="depart_id"/>    此处多对一的列必须要与上面set标签中key中coulmn中的相同
    </class>
</hibernate-mapping>
配置文件的编写代码：
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/HibernateConfiguration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 
<hibernate-configuration>
    <session-factory name="foo">
       <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
       <property name="connection.url">jdbc:mysql:///demo</property>
       <property name="hibernate.connection.username">root</property>
       <property name="connection.password">123</property>
       <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
       <property name="hibernate.hbm2ddl.auto">update</property>
       <property name="hibernate.show_sql">true</property>
       
       <mapping resource="com/hbsi/domain/Department.hbm.xml"/>
       <mapping resource="com/hbsi/domain/Employee.hbm.xml"/>  </session-factory>
</hibernate-configuration>
各个包的导入：
 
获取Session的工具类Util的编写：
public final class HibernateUtil {
    private static SessionFactory sessionFactory;
    private HibernateUtil(){
       
    }
    static{
       Configuration cfg=new Configuration();
       cfg.configure();
       sessionFactory=cfg.buildSessionFactory();
    }
    public static SessionFactory getSessionFactory() {
       return sessionFactory;
    }
    public static Session getSession(){
       return sessionFactory.openSession();
    }
    
}
 
此处以插入方法实现一对多的测试类的编写：
 
       //插入方法的实现
    static Department add(){
       Session session=null;
       Transaction tx=null;
       try{
           session=HibernateUtil.getSession();
           tx=session.beginTransaction();
           //添加
           Department dep=new Department();
           dep.setName("departone");
           
           Employee e1=new Employee();
           e1.setName("Tom");
           e1.setDepart(dep);//指定员工在哪个部门-----对象模型，对象建立关联关系          

           
           session.save(dep);
           session.save(e1);
           
           tx.commit();
           
           return dep;
       }finally{
           if(session!=null){
              session.close();
           }
       }
       
    }
 
 
主函数的调用：
    public static void main(String[] args) {
       // TODO Auto-generatedmethod stub
       add();
    }
 
然后以查找的形式实现的多对一测试类的编写：
   static Employee query(int empId){
       Session session=null;
       try{
           session=HibernateUtil.getSession();
           //查询的操作
           Employee e=(Employee) session.get(Employee.class,empId);
           System.out.println(e.getName()+" "+e.getDepart().getName());
           return e;
       }finally{
           if(session!=null){
              session.close();
           }
       }
    }
主函数的调用：
       public static void main(String[] args){
       query(1);
    }

本文目录

一、association 标签（一对一）

二、collection 标签（一对多）

一、association 标签（一对一）

association通常用来映射一对一的关系，例如，有个类User，对应的实体类如下：(getter,setter方法省略)

@Data
public class User {
    /**
     * 主键
     */
    private String id;
    /**
     * 用户姓名
     */
    private String userName;
}

有个类Article，对应的实体类如下：

@Data
public class Article {
    /**
     * 主键
     */
    private String id;
    /**
     * 文章标题
     */
    private String articleTitle;
    /**
     * 文章内容
     */
    private String articleContent;
}

如果我想查询一个用户的时候，也查到他写的一篇文章，那么怎样写呢？其实可以在类User中加入一个属性Article类：

@Data
public class User {
    /**
     * 主键
     */
    private String id;
    /**
     * 用户姓名
     */
    private String userName;
    /**
     * 类Article
     */
    private Article article;
}

mapper.xml 我在user类的UserMapper.xml这样配置

<mapper namespace="com.uiot.practice.mysqltest.dao.UserMapper">
	<resultMap type="com.uiot.practice.mysqltest.entity.Article" id="articleMap">
		<id column="id" property="id" jdbcType="VARCHAR" javaType="java.lang.String"/>
		<result column="userName" property="userName" jdbcType="VARCHAR" javaType="java.lang.String"/>
		<!--这里把user的id传过去，com.uiot.practice.mysqltest为命名空间-->
		<association property="article" column="id" select="com.uiot.practice.mysqltest.selectArticleByUserId" />
	</resultMap>
</mapper>

同时，我的article对应的ArticleMapper.xml这样写：

<mapper namespace="com.uiot.practice.mysqltest.dao.ArticleMapper">
    <resultMap type="com.uiot.practice.mysqltest.entity.Article" id="ArticleResultMap">
        <id column="id" property="id" jdbcType="VARCHAR" javaType="java.lang.String"/>
        <result column="articleTitle" property="articleTitle" jdbcType="VARCHAR" javaType="java.lang.String"/>
        <result column="articleContent" property="articleContent" jdbcType="VARCHAR" javaType="java.lang.String"/>
    </resultMap>

    <select id="selectArticleByUserId" parameterType="java.lang.String" resultMap="ArticleResultMap">
        select * from tb_article where userId=#{userId}
    </select>
</mapper>

二、collection 标签（一对多）

一对多，collection，理解了一对一，一对多容易理解

@Data
public class User {
    /**
     * 主键
     */
    private String id;
    /**
     * 用户姓名
     */
    private String userName;
    /**
     * 类Article
     */
    private List<Article> articleList;
}

UserMapper.xml这样配置

<mapper namespace="com.uiot.practice.mysqltest.dao.UserMapper">
	<resultMap type="com.uiot.practice.mysqltest.entity.User" id="articleMap">
		<id column="id" property="id" jdbcType="VARCHAR" javaType="java.lang.String"/>
		<result column="userName" property="userName" jdbcType="VARCHAR" javaType="java.lang.String"/>
		<!--这里把user的id传过去，com.uiot.practice.mysqltest为命名空间-->
		<collection property="articleList" column="id" select="com.uiot.practice.mysqltest.selectArticleByUserId"/>
	</resultMap>
	<!--以下省略，类同，Mybatis会把结果封装成List类型。-->
</mapper>

 

完结！

原文链接：http://www.yiidian.com/mybatis/one-to-one.html
1 什么是一对一、一对多映射？
以用户和订单举例，
一对一 : 一个订单只属于一个用户 ==> 订单对用户是一对一关系
一对多 : 一个用户可以拥有多个订单 ==> 用户对订单是一对多关系
注意：在MyBatis中，如果要完成多对多关系，其实就是两个一对多映射！
接下来先讲解MyBatis的一对一映射如何实现。
2 建立表结构
2.1 创建用户表
CREATE TABLE `t_user` (
   `id` int(11) DEFAULT NULL,
   `username` varchar(50) DEFAULT NULL,
   `password` varchar(50) DEFAULT NULL
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8
2.2 创建订单表
CREATE TABLE `t_order` (
   `id` int(11) DEFAULT NULL,
   `orderno` varchar(100) DEFAULT NULL,
   `amount` double DEFAULT NULL,
   `user_id` int(11) DEFAULT NULL
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8
2.3 插入测试数据


3 设计Pojo实体，建立关系
3.1 用户实体类
package com.yiidian.domain;

import java.util.List;

/**
 * 用户实体
 * 一点教程网 - www.yiidian.com
 */
public class User {
    private Integer id;
    private String username;

    public void setOrders(List<Order> orders) {
        this.orders = orders;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}
3.2 订单实体类
package com.yiidian.domain;

/**
 * 订单实体
 * 一点教程网 - www.yiidian.com
 */
public class Order {
    private Integer id;
    private String orderno;
    private Double amount;
    private User user;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getOrderno() {
        return orderno;
    }

    public void setOrderno(String orderno) {
        this.orderno = orderno;
    }

    public Double getAmount() {
        return amount;
    }

    public void setAmount(Double amount) {
        this.amount = amount;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}
Order实体类，通过user属性建立跟User实体的关系。注意，这里是一个User。
4 编写Dao接口
4.1 UserDao接口
package com.yiidian.dao;

import com.yiidian.domain.User;

import java.util.List;

/**
 * 用户Dao接口
 * 一点教程网 - www.yiidian.com
 */
public interface UserDao {

}
4.2 OrderDao接口
package com.yiidian.dao;
import com.yiidian.domain.Order;
import com.yiidian.domain.User;
import java.util.List;

/**
 * 订单Dao接口
 * 一点教程网 - www.yiidian.com
 */
public interface OrderDao {
    /**
     * 查询所有订单
     */
    public List<Order> findAllOrders();
}
5 编写Dao映射配置
5.1 UserDao.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: 用于指定该映射文件需要映射的Dao接口
-->
<mapper namespace="com.yiidian.dao.UserDao">

</mapper>
5.2 OrderDao.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: 用于指定该映射文件需要映射的Dao接口
-->
<mapper namespace="com.yiidian.dao.OrderDao">

    <!--一对一映射-->
    <resultMap id="OrderResultMap" type="com.yiidian.domain.Order">
        <id property="id" column="oid"/>
        <result property="orderno" column="orderno"/>
        <result property="amount" column="amount"/>
        <!--关联查询订单所属的用户-->
        <association property="user" column="id" javaType="com.yiidian.domain.User">
            <id property="id" column="id"/>
            <result property="username" column="username"/>
            <result property="password" column="password"/>
        </association>
    </resultMap>

    <select id="findAllOrders" resultMap="OrderResultMap">
        SELECT
          o.id oid,
          o.orderno orderno,
          o.amount amount,
          u.*
        FROM t_order o
          LEFT JOIN t_user u
            ON o.user_id = u.id
    </select>
</mapper>

association：用在一对一关联映射
property：对应Order类的user属性
column：对应外键字段名称
javaType：User类的全限定名称

6 编写测试类
package com.yiidian.mybatis;

import com.yiidian.dao.OrderDao;
import com.yiidian.domain.Order;
import com.yiidian.utils.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * MyBatis测试类 - 一对一映射
 * 一点教程网 - www.yiidian.com
 */
public class TestOne2One {

    /**
     * 测试一对一映射
     */
    @Test
    public void testOrderDao(){
        //1.获取SqlSession对象
        SqlSession sqlSession = MyBatisUtils.getSession();

        //2.创建Mapper代理对象
        OrderDao orderDao = sqlSession.getMapper(OrderDao.class);

        //3.调用方法
        List<Order> list = orderDao.findAllOrders();
        System.out.println(list);
        //4.关闭连接
        sqlSession.close();
    }

}
7 运行测试类
以debug模式启动测试类，查看list变量的情况，可以看到Order对象中成功封装了User对象的数据！


源码下载：https://pan.baidu.com/s/1jZrfapjqB_VHI_GLgKPo4g


欢迎关注我的公众号：：一点教程。获得独家整理的学习资源和日常干货推送。
如果您对我的系列教程感兴趣，也可以关注我的网站：yiidian.com