`

035_一对一单向外键关联_annotation

阅读更多

星期六, 一月 09, 2016   17:59

一对一单向关联

1.a)hibernate_0700_One2One_unic_fk

b)Annotation: @OneToOne@JoinColumn

c)xml:<many-to-one/>

 

关系映射

对象

 

表与表之间的关系只有外键。

 

 

关系映射(这里讲的是对象)

 

关系对象的关系:

        一对一、一对多、多对多

 

写在对象里,又出现了单向、多向。

 

加起来7中。

 

一对一:

1.单向(主键、外键)

2.双向()

 

 

 

 

7.集合映射

8.继承关系

9.组件映射

 

 

2.简化问题

   2.1怎么写Annotation

   2.2增删改查CRUD怎么写

 

3.一对一

3.1单向(主键、外键)

3.2

 

 

 

 

 

本节:

一对一:

1.一对一单向、外键关联

 

步骤:

考虑这两个类怎么写

Husband  -----Wife

要在上面加上@Entity保证是实体类

 

站在husband角度有一个wife的引用

 

 

然后在数据库中进行设计表

两张表

husband    id name wife_id

wife           id  name

几种方法:

1.主键关联

2.外键关联

3.关联表-----多对多的时候使用

 

 

运行测试:

       在运行的console中看到自动帮你生成的建表语句,数据库中对应的表。

 

 

 

二、使用powerdesinger根据sql进行生成表

 

1.先数据库配置

数据库-->config    connection 

--->connection profile-->新加一个数据源

:name:  MySql  description:MySql....

还需要在环境变量中进行配置mysql.jar,因为powerdesigner支持不好

-----加了可还是没有成功。

 

 

代码案例:

 

package com.zhuhw.hibernate.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Entity
public class Husband{
	private int id;
	private String name;
	//一个husband里又一个wife的引用
    private Wife wife;
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	@OneToOne
	public Wife getWife() {
		return wife;
	}
	public void setId(int id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
}

 

 

package com.zhuhw.hibernate.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Wife{
	private int id;
	private String name;
    @Id
    @GeneratedValue
	public int getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	public void setId(int id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
}

 

 

 

 

<?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>

        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost/hibernate</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>

        
        <!--
        <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
        <property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
        <property name="connection.username">scoot</property>
        <property name="connection.password">tiger</property>-->
        
        <!-- JDBC connection pool (use the built-in) -->
        <!--<property name="connection.pool_size">1</property>-->

        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <property name="hbm2ddl.auto">update</property>
      
	    <mapping class="com.zhuhw.hibernate.model.Husband"/>
		<mapping class="com.zhuhw.hibernate.model.Wife"/>	    
    </session-factory>

</hibernate-configuration>

 

 

 

 

package com.zhuhw.hibernate.model;

import java.util.Date;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

public class HibernateORMappingTest {
	
	public static SessionFactory sf = null;
	@BeforeClass
	public  static void beforeClass(){
			sf = new AnnotationConfiguration().configure().buildSessionFactory();
	}
	
	@Test
	public void testOne2One(){
		new SchemaExport(new AnnotationConfiguration().configure()).create(false, true);
	}
	@AfterClass
	public static void afterClass(){
		sf.close();
	}
	
	
	
}

 

 

ok刚开始运行不成功是没加@Entity

已解决

 

0
0
分享到:
评论

相关推荐

    Hibernate一对一单向外键关联 (联合主键annotation)

    本篇将详细讲解如何使用Hibernate进行一对一单向外键关联,并且该关联涉及到联合主键的注解配置。 首先,一对一关联可以分为两种类型:单向和双向。在单向一对一关联中,只有一个实体知道另一个实体的存在,而另一...

    Hibernate一对一单向外键关联(annotation/xml)

    本篇将深入探讨Hibernate中的一对一单向外键关联,通过注解和XML配置两种方式进行实现。这种关联允许一个实体类与另一个实体类之间存在一对一的关系,并且只在其中一个实体类中维护这种关系。 首先,我们来理解一对...

    Hibernate Annotation 唯一外键一对一双向关联

    在Java的持久化框架Hibernate中,`@OneToOne`注解用于表示一对一的关联关系,而唯一外键一对一双向关联则是这种关系的一种具体实现方式。这篇文章将深入探讨这一概念,帮助你理解如何在实际开发中应用。 首先,我们...

    Hibernate Annotation 基于外键的单向多对一关联

    本篇文章将深入探讨如何使用Hibernate Annotation来实现基于外键的单向多对一关联。 在关系型数据库中,多对一关联是一种常见的关系类型,意味着一个实体(如表)可以与另一个实体有多条记录关联,而另一个实体只能...

    Hibernate_Annotation关联映射

    其中一个实体通过外键关联到另一个实体的主键(注意要模拟一对一关联必须在外键列上添加唯一约束),(3).通过关联表来保存两个实体之间的连接关系(要模拟一对一关联必须在每一个外键上添加唯一约束)。 1.共享主键的...

    Hibernate ORMapping Annotation XML PDF

    ### 一、一对一单向外键关联 在一对一单向外键关联中,一个实体可以关联到另一个实体,但这种关联是单向的,即只有从一方到另一方的导航。例如,`Husband`实体可以有一个指向`Wife`实体的外键,但`Wife`实体没有...

    详解Hibernate一对一映射配置

    在Java持久化框架Hibernate中,一对一(One-to-One)映射是对象关系映射的一种常见方式,用于表示两个实体之间一对一的关系。这种关系通常出现在一个实体的实例只能与另一个实体的单个实例相关联的情况。下面我们将...

    Hibernate多对多单向关联(annotation/xml)

    本篇将详细讲解如何使用Hibernate实现多对多单向关联,包括注解(Annotation)和XML配置方式。 一、多对多关联的基本概念 多对多关联意味着一个实体可以与多个其他实体关联,反之亦然。例如,学生和课程的关系,一...

    Hibernate一对多单向关联(annotation/xml)

    在本教程中,我们将探讨如何使用注解和XML配置实现Hibernate的一对多单向关联。 首先,让我们理解一对多关联的概念。在数据库中,一对多关联意味着在一个表(父表)中的一个记录可以对应另一个表(子表)中的多个...

    Hibernate多对一单向关联(annotation/xml)

    以上就是使用Hibernate通过注解和XML配置实现多对一单向关联的详细步骤。在实际开发中,这种关联方式能够有效地简化数据操作,提高代码的可读性和可维护性。注意,根据项目需求,你可能还需要处理关联的懒加载或立即...

    Hibernate Annotation 基于连接表的单向一对多关联

    本篇文章将详细讲解如何利用Hibernate的注解实现基于连接表的单向一对多关联。 首先,理解一对多关联:在数据库设计中,一对多关联意味着一个实体(表)可以与多个其他实体(表)相对应。例如,一个学生可以有多个...

    Hibernate 注解

    单向外键关联中,`@OneToOne`注解用于在User类中定义对Address对象的引用: ```java @OneToOne @JoinColumn(name = "ADDRESS_ID") private Address address; ``` 如果需要双向关联,Address类也需要有一个对User的...

    Hibernate一对多映射配置详解

    在Java持久化框架Hibernate中,一对多映射是常见的实体关系映射类型,它表示一个实体(例如User)可以与多个其他实体(例如Account)相关联。以下是对Hibernate一对多映射配置的详解: 一、XML文件配置 1. 单向...

    Hibernate3的帮助文档

    8.5.2. 一对一(one to one) 8.5.3. 多对多(many to many) 9. 组件(Component)映射 9.1. 依赖对象(Dependent objects) 9.2. 在集合中出现的依赖对象 9.3. 组件作为Map的索引(Components as Map indices ...

    Hibernate_3.2.0_符合Java习惯的关系数据库持久化

    7.2.2. 一对一(one to one) 7.2.3. 一对多(one to many) 7.3. 使用连接表的单向关联(Unidirectional associations with join tables) 7.3.1. 一对多(one to many) 7.3.2. 多对一(many to one) 7.3.3. ...

    hibernate 框架详解

    一对一(one to one) 8.5. 使用连接表的双向关联(Bidirectional associations with join tables) 8.5.1. 一对多(one to many) /多对一( many to one) 8.5.2. 一对一(one to one) 8.5.3. 多对多...

    hibernate3.04中文文档.chm

    8.4.2. 一对一(one to one) 8.5. 使用连接表的双向关联(Bidirectional associations with join tables) 8.5.1. 一对多(one to many) /多对一( many to one) 8.5.2. 一对一(one to one) 8.5.3. 多对多...

    Hibernate中文详细学习文档

    7.4.2. 一对一(one to one) 7.5. 使用连接表的双向关联(Bidirectional associations with join tables) 7.5.1. 一对多(one to many) /多对一( many to one) 7.5.2. 一对一(one to one) 7.5.3. 多对多...

Global site tag (gtag.js) - Google Analytics