`
Wind_ZhongGang
  • 浏览: 263719 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类
最新评论

Hibernate one-to-many 一方单向连接表关联

阅读更多

 

  Hibernate中对于持久化实体间的关联关系有三种分类,第一个是一对一,第二个是一对多,第三个是多对多,对于多对一的关联关系认定为是一对多的反向,所以从实质上看这两者是一样的。而对于关联关系的设置,通常的做法是,对于一对一,将关联关系可以放在两方中的任何一方,而对于一对多,将关联关系放置在多方,由多方来控制一对多的关联关系,而对于多对多,需要将关联关系同时放置在两方,即由两方共同来控制多对多的关联关系,不过由于这样的做法带来很大的数据冗余,及其它不合理之处,所以这时会开辟第三张表用来映射多对多的关联关系。那么对于一对多或一对一的关联关系,我想将它们的关联关系用第三张表来表示,应该如何做呢?这就引出来了Hibernate的join的用法,它为我们提供了将一对一或多对多关联关系以第三张表的方式来表示,而不是由关联关系的两方的其中一方去控制。

 

  一。Husband

 

package com.dream.model.couple;

import java.util.Set;

/**
 * Created by IntelliJ IDEA.
 * User: Zhong Gang
 * Date: 11-10-15
 * Time: 下午3:53
 */
public class Husband {
    private Integer id;
    private String name;

    private Set<Wife> wifes;

    public Husband(String name) {
        this.name = name;
    }

    public Husband() {
    }

    public Husband(String name, Set<Wife> wifes) {
        this.name = name;
        this.wifes = wifes;
    }
}

 

<?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 default-access="field">

    <class name="com.dream.model.couple.Husband" table="husband" dynamic-insert="true" dynamic-update="true">
        <id name="id" column="id" type="java.lang.Integer">
            <generator class="native"/>
        </id>
        <property name="name" column="name" type="java.lang.String"/>

        <set name="wifes" cascade="save-update" table="couple">
            <key column="husbandid"/>
            <many-to-many class="com.dream.model.couple.Wife" column="wifeid" unique="true"/>
        </set>
    </class>

</hibernate-mapping>

 

  二。Wife

 

package com.dream.model.couple;

/**
 * Created by IntelliJ IDEA.
 * User: Zhong Gang
 * Date: 11-10-15
 * Time: 下午3:52
 */
public class Wife {
    private Integer id;
    private String name;

    public Wife(String name) {
        this.name = name;
    }

    public Wife() {
    }

    public String name() {
        return this.name;
    }
}
 

 

<?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 default-access="field">

    <class name="com.dream.model.couple.Wife" table="wife" dynamic-insert="true" dynamic-update="true">
        <id name="id" column="id" type="java.lang.Integer">
            <generator class="native"/>
        </id>
        <property name="name" column="name" type="java.lang.String"/>
    </class>

</hibernate-mapping>

 

  三。CoupleDao

 

 

package com.dream.dao.standard;

import com.dream.model.couple.Husband;

import java.util.List;

/**
 * Created by IntelliJ IDEA.
 * User: Zhong Gang
 * Date: 11-10-15
 * Time: 下午4:24
 */
public interface CoupleDao {

    void saveOrUpdateHusband(Husband husband);

    List<Husband> findHusbandsByName(String name);
}

 

 

package com.dream.dao;

import com.dream.dao.standard.CoupleDao;
import com.dream.model.couple.Husband;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import java.util.List;

/**
 * Created by IntelliJ IDEA.
 * User: Zhong Gang
 * Date: 11-10-15
 * Time: 下午4:24
 */
public class CoupleDaoImpl extends HibernateDaoSupport implements CoupleDao {

    @Override
    public void saveOrUpdateHusband(Husband husband) {
        getHibernateTemplate().saveOrUpdate(husband);
    }

    @Override
    public List<Husband> findHusbandsByName(String name) {
        return getHibernateTemplate().find("from Husband husband where husband.name=?", name);
    }
}

 

  四。CoupleService

 

 

package com.dream.service.standard;

import com.dream.model.couple.Husband;

import java.util.List;

/**
 * Created by IntelliJ IDEA.
 * User: Zhong Gang
 * Date: 11-10-15
 * Time: 下午4:23
 */
public interface CoupleService {

    void saveOrUpdateHusband(Husband husband);

    List<Husband> loadHusbandsByName(String name);
}

 

 

package com.dream.service;

import com.dream.dao.standard.CoupleDao;
import com.dream.model.couple.Husband;
import com.dream.service.standard.CoupleService;

import java.util.List;

/**
 * Created by IntelliJ IDEA.
 * User: Zhong Gang
 * Date: 11-10-15
 * Time: 下午4:23
 */
public class CoupleServiceImpl implements CoupleService {

    private CoupleDao coupleDao;

    @Override
    public void saveOrUpdateHusband(Husband husband) {
        coupleDao.saveOrUpdateHusband(husband);
    }

    @Override
    public List<Husband> loadHusbandsByName(String name) {
        return coupleDao.findHusbandsByName(name);
    }

    public void setCoupleDao(CoupleDao coupleDao) {
        this.coupleDao = coupleDao;
    }

}

 

  五。testDB

 

 

db.url=jdbc:mysql://localhost:3306/couple?createDatabaseIfNotExist=true&amp;useUnicode=true&amp;characterEncoding=utf-8

db.driver=com.mysql.jdbc.Driver

db.username=root

db.password=root

hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

hibernate.show_sql=true

hibernate.hbm2ddl.auto=update

hibernate.jdbc.batch_size=100

 

  六。testDataSource

 

 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
		 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"
       default-autowire="byName">

    <context:property-placeholder location="classpath:testDB.properties"/>

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
          destroy-method="close">
        <property name="driverClassName" value="${db.driver}"/>
        <property name="url" value="${db.url}"/>
        <property name="username" value="${db.username}"/>
        <property name="password" value="${db.password}"/>
    </bean>

    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="mappingLocations">
            <list>
                <value>classpath:/hibernate_mappings/Husband.hbm.xml</value>
                <value>classpath:/hibernate_mappings/Wife.hbm.xml</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
                <prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
            </props>
        </property>
    </bean>

    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <aop:config>
        <aop:pointcut id="service" expression="execution(* com.dream.service..*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="service"/>
    </aop:config>

    <bean id="coupleDao" class="com.dream.dao.CoupleDaoImpl">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

    <bean id="coupleService" class="com.dream.service.CoupleServiceImpl">
        <property name="coupleDao" ref="coupleDao"/>
    </bean>
</beans>

 

   七。Test

 

 

package com.dream.couple;

import com.dream.model.couple.Husband;
import com.dream.model.couple.Wife;
import com.dream.service.standard.CoupleService;
import junit.framework.TestCase;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Created by IntelliJ IDEA.
 * User: Zhong Gang
 * Date: 11-10-15
 * Time: 下午4:10
 */
public class HibernateOneToManyJoinTest extends TestCase {
    private CoupleService coupleService;

    @Override
    public void setUp() throws Exception {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:testDataSource.xml");
        coupleService = (CoupleService) context.getBean("coupleService");
    }

    public void testOneToOneJoin() throws Exception {

        Wife wife1 = new Wife("wife1");
        Wife wife2 = new Wife("wife2");
        Wife wife3 = new Wife("wife3");

        Set<Wife> wifes = new HashSet<Wife>();
        wifes.add(wife1);
        wifes.add(wife2);
        wifes.add(wife3);

        Husband husband = new Husband("husband", wifes);

        coupleService.saveOrUpdateHusband(husband);
    }
}

 

  跑完测试,发出的sql语句

 

  result

 

  来看看跑完测试后,数据库中相关的数据表及数据:

 

  result1

 

  result2

  • 大小: 13.7 KB
  • 大小: 16.5 KB
  • 大小: 9.3 KB
1
0
分享到:
评论

相关推荐

    Hibernate性能调优

    关联通常包括以下几种类型:单向`one-to-many`关联、双向`one-to-many`关联、`many-to-one`关联以及`one-to-one`关联。 ##### 单向`one-to-many`关联 - **定义**:单向`one-to-many`关联是指一个实体可以拥有多个...

    Hibernate关联映射

    配置上,需要创建一个新的实体类来代表连接表,并在其中定义两个 `many-to-one` 属性,分别对应一对一关联的两个实体。 4. Hibernate 一对多外键单向关联: 在这种关联中,一个实体类(如 Department)可以有多个...

    hibernate的关联映射

    关联映射主要包括四种类型:一对一(One-to-One)、一对多(One-to-Many)、多对一(Many-to-One)和多对多(Many-to-Many)。下面我们将逐一探讨这些关联映射的配置方法。 1. **一对一关联映射** - **主键关联**...

    Hibernate关联关系映射目录

    在多对多单向关联中,两个实体之间可以相互关联,这种关联通常通过第三个表(连接表或关联表)来实现。 **表结构示例**: - **Student表**: - `studentid`: 主键 - `name`: 姓名 - `age`: 年龄 - **Course表**:...

    HIbernate关联关系总结

    如果是通过连接表实现1-N关联,我们需要使用`&lt;many-to-many&gt;`标签,并设置`unique=true`来限制一对多的关系。连接表的配置需要在`&lt;set&gt;`标签中指定`table`属性。 **优点**:1端可以方便地管理和操作N端的所有对象...

    Hibernate关联关系总结

    **多对一关联(Many-to-One)** 多对一关联是一对一关联的反转,即多个实体对应一个实体。例如,多个员工可以属于同一个部门。这种关系可以通过`@ManyToOne`注解实现。多对一关联的一方通常会包含对另一方的引用,而...

    Hibernate中的关联映射

    - **有连接表**:类似于多对多映射,但是通过在一方的映射中添加`inverse="true"`来表明该方放弃管理关联关系。 - **映射示例**: - 1端 (`Person`): ```xml &lt;many-to-many class="Address" column=...

    hibernate关联映射

    在Person类中添加`private Address address`属性,并在`person.hbm.xml`中配置`&lt;many-to-one&gt;`元素,如`&lt;many-to-one name="address" cascade="all" class="Address" column="address_id"/&gt;`。这表示Person表中的...

    hibernate中的关联关系

    - 在 `Person` 类中添加 `Address` 属性,并在映射文件中使用 `&lt;one-to-one&gt;` 或 `&lt;many-to-one&gt;` 进行关联映射。 --- 以上介绍的是 Hibernate 中一对一关联关系的三种不同方式,包括一对一连接表单向关联、一对...

    hibrenate xml 配置 映射

    这使用`&lt;many-to-one&gt;`标签。 ```xml &lt;many-to-one name="address" class="com.example.Address" column="address_id"/&gt; ``` #### 2.1.7 多对一连接表单向关联 与上述相同,但通过连接表进行关联。 #### 2.1.8 多...

    Hibernate笔记

    在Hibernate中,我们可以通过在N的一端(通常是拥有集合的一方)使用`&lt;many-to-one&gt;`元素来实现这种关联。对于无连接表的N-1关联,我们可以在实体类的`Person`中添加`Address`对象,并在配置文件中设置`&lt;many-to-one...

    Hibernate数据关联实现〖MVSN〗_Struts + DAO + Hibernate

    在Hibernate中,数据关联分为一对一(One-to-One)、一对多(One-to-Many)、多对一(Many-to-One)和多对多(Many-to-Many)四种类型。每种关联都需要在实体类(Entity)上通过注解进行配置,例如: 1. **一对一...

    hibernate多对多单向关联

    在Java的持久化框架Hibernate中,多对多(Many-to-Many)关联是一种常见的关系映射类型,它用于表示两个实体之间可以有多个对应的关系。本文将深入探讨Hibernate中的多对多单向关联,并结合提供的资源`hibernate_...

    hibernate_reference中文文档.pdf

    - **7.3.2 多对一 (many-to-one)**:介绍使用连接表的多对一关联映射。 - **7.3.3 一对一 (One-to-one)**:说明使用连接表的一对一关联映射。 - **7.3.4 多对多 (many-to-many)**:解释多对多关联的映射。 - **...

    hibernate映射关系

    本文将深入探讨Hibernate中的三种主要映射关系:一对一(One-to-One)、一对多(One-to-Many)以及多对多(Many-to-Many)。 ### 一对一映射(One-to-One) 一对一映射在现实世界中非常常见,例如一个人只有一个...

Global site tag (gtag.js) - Google Analytics