一对多单向关联关系理解与实践

于 2015-10-08 14:26:24 发布
阅读量621 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Hibernate学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/liu_005/article/details/48972157
这篇博客主要面向Hibernate初学者，详细介绍了如何理解和实现一对多单向关联关系，以生产商和产品为例，通过代码示例展示了配置文件、实体类的创建以及数据库操作。作者提醒注意配置文件中的数据库信息，并提供了两种建表方法。文章最后提到，虽然一对多关联常用，但因效率问题建议考虑使用多对一关系。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

本人是hibernate的初学者，以下是我对于hibernate实体关联关系中一对多单向关联关系的理解，希望对于初学者在理解这一部分内容的时候有帮助。

hibernate中一对多单向关联关系主要是对应数据库中的一对多的关系，其实这是一种非常常见的关系，这里以生产商（factory）和产品（product）为例进行讲解。

使用开发工具：
IDE：eclipse
数据库：MySql

【以下使用代码下载地址：http://download.youkuaiyun.com/detail/liu_005/9163051】

1、建表：（方法一）
这里我们用sql语句建表（下面有另外的方法，可以不使用sql语句建表），当然建立数据库的语句就不在这里写了，你自己随便建个数据库就行（记得等下在hibernate.cfg.xml中修改成对应数据库就行），sql语句如下：

生厂商表

DROP TABLE IF EXISTS `tab_factory`;
CREATE TABLE `tab_factory` (
  `factoryId` int(11) NOT NULL AUTO_INCREMENT,
  `factoryName` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`factoryId`)
) ENGINE=InnoDB AUTO_INCREMENT=22 DEFAULT CHARSET=latin1;

产品表

DROP TABLE IF EXISTS `tab_product`;
CREATE TABLE `tab_product` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(45) NOT NULL,
  `price` double NOT NULL,
  `factory_id` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=33 DEFAULT CHARSET=latin1;

2、数据表建完后，我们开始编辑配置文件：
（1）编写hibernate全局配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
 <hibernate-configuration>
    <session-factory>
        <!-- 开启二级缓存 -->
        <property name="hibernate.cache.use_second_level_cache">true</property>
        <!-- 指定缓存产品提供商 -->
        <property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
        <!-- 数据库驱动 -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <!-- 数据库连接的URL -->
        <property name="connection.url">jdbc:mysql://localhost:3306/test</property>
        <!-- 数据库连接用户名 -->
        <property name="connection.username">root</property>
        <!-- 数据库连接密码 -->
        <property name="connection.password">123</property>
        <!-- Hibernate方言 -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        <!-- 打印SQL语句 -->
        <property name="show_sql">true</property>
        <!-- 映射文件  -->
        <mapping resource="com/mr/product/Product.hbm.xml"/>
        <mapping resource="com/mr/factory/Factory.hbm.xml"/>
    </session-factory>
 </hibernate-configuration>

【提醒】请修改相应的数据库驱动、URL、用户名以及密码

（2）定义HibernateInitialize类
这个类主要是初始化sessionFactory和定义获取session的方法，主要是为了后面使用方便。

package com.mr.hibernate;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * Hibernate初始化类
 *
 */
public class HibernateInitialize {
    private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();// ThreadLocal对象
    private static SessionFactory sessionFactory = null;// SessionFactory对象
    // 静态块
    static {
        try {
            // 加载Hibernate配置文件
            Configuration cfg = new Configuration().configure();
            sessionFactory = cfg.buildSessionFactory();
        } catch (Exception e) {
            System.err.println("创建会话工厂失败");
            e.printStackTrace();
        }
    }

    /**
     * 获取Session
     * 
     * @return Session
     * @throws HibernateException
     */
    public static Session getSession() throws HibernateException {
        Session session = (Session) threadLocal.get();
        if (session == null || !session.isOpen()) {
            if (sessionFactory == null) {
                rebuildSessionFactory();
            }
            session = (sessionFactory != null) ? sessionFactory.openSession(): null;
            threadLocal.set(session);
        }

        return session;
    }

    /**
     * 重建会话工厂
     */
    public static void rebuildSessionFactory() {
        try {
            // 加载Hibernate配置文件
            Configuration cfg = new Configuration().configure();
            sessionFactory = cfg.buildSessionFactory();
        } catch (Exception e) {
            System.err.println("创建会话工厂失败");
            e.printStackTrace();
        }
    }

    /**
     * 获取SessionFactory对象
     * 
     * @return SessionFactory对象
     */
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    /**
     * 关闭Session
     * 
     * @throws HibernateException
     */
    public static void closeSession() throws HibernateException {
        Session session = (Session) threadLocal.get();
        threadLocal.set(null);//
        if (session != null) {
            session.close();// 关闭Session
        }
    }
}

（3）定义【生产商】类

package com.mr.factory;

import java.util.Set;

import com.mr.product.Product;

public class Factory {

    private Integer factoryId;// 生产商的id

    private String factoryName;// 生产商名称

    private Set<Product> products;  // 关联产品的集合

    public Set<Product> getProducts()
    {
        return products;
    }

    public void setProducts(Set<Product> products)
    {
        this.products = products;
    }

    public Integer getFactoryId() {
        return factoryId;
    }

    public void setFactoryId(Integer factoryId) {
        this.factoryId = factoryId;
    }

    public String getFactoryName() {
        return factoryName;
    }

    public void setFactoryName(String factoryName) {
        this.factoryName = factoryName;
    }
}

（4）编写【生产商】配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 <!-- 产品信息字段配置信息 -->
 <hibernate-mapping>
    <class name="com.mr.factory.Factory" table="tab_factory">
        <!-- id值 -->
        <id name="factoryId" column="factoryId" type="int">
            <generator class="native"/>
        </id>
        <!-- 生产商名称 -->
        <property name="factoryName" type="string" length="45">
            <column name="factoryName"/>
        </property>     
        <set name="products">
            <key column="factory_id"></key>
            <one-to-many class="com.mr.product.Product" />
        </set>      
    </class>
 </hibernate-mapping>

【提醒】class中的table字段是对应数据库中生厂商表名（如果你是按以上提供的建表语句生成的数据表的话，这里就不用修改了，否则请做相应修改）

（5）定义【产品】类

package com.mr.product;

/**
 * 商品信息的持久化类
 */
public class Product {

    private Integer id;// 唯一性标识
    private String name;// 产品名称
    private Double price;// 产品价格

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
}

（6）编写【产品】配置文件

package com.mr.product;

/**
 * 商品信息的持久化类
 */
public class Product {

    private Integer id;// 唯一性标识
    private String name;// 产品名称
    private Double price;// 产品价格

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
}

【提醒】class中的table字段是对应数据库中产品表名（如果你是按以上提供的建表语句生成的数据表的话，这里就不用修改了，否则请做相应修改）

如果你已经使用了第一步中的sql语句建表的话，这里就不用建表了。当然你也可以删除以前建的表尝试一下这种方式。

3、建表：（方法二）
定义以下类并运行就可以根据以上的配置文件进行建表

package com.mr.main;

import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.boot.spi.MetadataImplementor;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.tool.hbm2ddl.SchemaExport;

public class createTable
{
    public static void main(String[] args)
    {       
        ServiceRegistry serviceRegistry = (ServiceRegistry) new StandardServiceRegistryBuilder()
                .configure().build();
        MetadataImplementor metadataImplementor = (MetadataImplementor) new MetadataSources(
                serviceRegistry).buildMetadata();
        SchemaExport export = new SchemaExport(serviceRegistry,
                metadataImplementor);
        export.create(true, true);//第一个参数是是否输出到控制台，第二个参数是是否输出到数据库建表
    }
}

4、测试：
如果还没用数据的话，先将插入部分代码去除注释运行。然后可以将插入部分注释，然后将查询部分注释去除进行测试。

package com.mr.main;

import org.hibernate.Session;

import com.mr.hibernate.HibernateInitialize;

public class OperateFactory {
    public static void main(String[] args) {
        Session session = null; // 声明第一个Session对象
        try {
            // Hibernate的持久化操作
            session = HibernateInitialize.getSession();// 获取Session
            session.beginTransaction();// 事务开启

            /******* 插入 ********/
            // Product product1 = new Product();
            // product1.setName("product88");
            // product1.setPrice(33.2);
            // session.save(product1);
            //
            // Product product2 = new Product();
            // product2.setName("productName77");
            // product2.setPrice(23.6);
            // session.save(product2);
            //
            // Set<Product> products = new HashSet<Product>();
            // products.add(product1);
            // products.add(product2);
            //
            // Factory factory = new Factory();
            // factory.setFactoryName("factoryName66");
            // factory.setProducts(products);
            // session.save(factory);

            /******* 查询 *******/
            // Factory factory = (Factory) session.get(Factory.class,
            // new Integer("18"));// 这里的“18”为factory表中的id，可根据需要修改
            // System.out.println("factoryName: " + factory.getFactoryName());
            //
            // Set<Product> products = factory.getProducts();
            // for (Iterator<Product> iterator = products.iterator(); iterator
            // .hasNext();)
            // {
            // Product product = iterator.next();
            // System.out.println("product_id: " + product.getId());
            // System.out.println("product_name: " + product.getName());
            // System.out.println("product_price: " + product.getPrice());
            // }

            session.getTransaction().commit();// 事务提交
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();// 事务回滚
        } finally{
            HibernateInitialize.closeSession();// 关闭Session
        }
    }
}

【提醒】将注释除去时可能会报错，点解错误处会提示导入相应的包，导入时Set和Iterator的包一定要导入java.util下的包，不然会出错。

【结语】 一对多的关系也是经常用到的，但是这种关系在加载时效率会不高，因为需要维护的数据较多，所以不建议使用一对多的关系，可以考虑多对一的关系，这样在加载时其实是一种一对一的关系，加载的效率较高，关系和对象模型得到了优化。

以上内容如有错误之处，欢迎各位指正。如有问题，可以与我讨论。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值