现在根据customer和orders写一个复合主键的例子,两张表,如下所示
CREATE TABLE CUSTOMERS(ID INT AUTO_INCREMENT PRIMARY KEY,NAME VARCHAR(20), AGE INT )
CREATE TABLE ORDERS (ID INT,CUSTOMER_ID INT, NAME VARCHAR(20),PRICE DOUBLE,
CONSTRAINT PK_OR PRIMARY KEY(ID,CUSTOMER_ID),
CONSTRAINT FK_OR FOREIGN KEY (CUSTOMER_ID) REFERENCES CUSTOMERS(ID))
package entity;
import java.util.*;
public class Customer implements java.io.Serializable
{
private Long id;
private String name;
private Integer age;
private Set orders=new HashSet();
private void setId(Long id)
{
this.id=id;
}
public Long getId()
{
return this.id;
}
public void setName(String name)
{
this.name=name;
}
public String getName()
{
return this.name;
}
public void setAge(Integer age)
{
this.age=age;
}
public Integer getAge()
{
return this.age;
}
public void setOrders(Set orders)
{
this.orders=orders;
}
public Set getOrders()
{
return this.orders;
}
}
package entity;
public class Order implements java.io.Serializable
{
private Long id;
private String name;
private Double price;
private Customer customer;
public Long cstid;
public void setCstid(Long cstid)
{
this.cstid=cstid;
}
public Long getCstid()
{
return this.cstid;
}
public void setId(Long id)
{
this.id=id;
}
public Long getId()
{
return this.id;
}
public void setName(String name)
{
this.name=name;
}
public String getName()
{
return this.name;
}
public void setPrice(Double price)
{
this.price=price;
}
public Double getPrice()
{
return this.price;
}
public void setCustomer(Customer customer)
{
this.customer=customer;
}
public Customer getCustomer()
{
return this.customer;
}
}
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="entity">
<class name="Customer" table="CUSTOMERS">
<id name="id" column="ID">
<generator class="increment"/>
</id>
<property name="name" type="string" column="NAME"/>
<property name="age"/>
<set name="orders" cascade="delete" inverse="true" lazy="true">
<key column="CUSTOMER_ID"/>
<one-to-many class="Order"/>
</set>
</class>
</hibernate-mapping>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="entity">
<class name="Order" table="ORDERS">
<composite-id>
<key-property name="id" column="ID" type="long" />
<key-property name="cstid" column="CUSTOMER_ID" type="long"/>
</composite-id>
<property name="name"/>
<property name="price" type="double" />
<many-to-one name="customer" column="CUSTOMER_ID" class="Customer" insert="false" update="false"/>
</class>
</hibernate-mapping>
package util;
import org.hibernate.cfg.*;
import org.hibernate.*;
import entity.*;
public class HibernateUtil
{
private static SessionFactory sessionFactory;
static
{
try
{
Configuration config=new Configuration();
config.addClass(Customer.class).addClass(Order.class);
sessionFactory = config.buildSessionFactory();
}
catch (Exception e)
{
e.printStackTrace();
}
}
public static SessionFactory getSessionFactory()
{
return sessionFactory;
}
}
hibernate.dialext=org.hibernate.dialext.MySQLDialect
hibernate.connection.driver_class=com.mysql.jdbc.Driver
hibernate.connection.url=jdbc:mysql://localhost:3306/PKTEST
hibernate.connection.username=root
hibernate.connection.password=
hibernate.show_sql=false
package service;
import util.*;
import entity.*;
import org.hibernate.*;
import java.util.*;
public class Test
{
public static void saveCustomer()
{
Session session=HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
Customer c=new Customer();
c.setName("aaa");
c.setAge(new Integer(23));
session.save(c);
session.getTransaction().commit();
}
public static void saveOrder()
{
Session session=HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
Order o=new Order();
o.setId(new Long(1));
o.setCstid(new Long(2));
o.setName("cpn");
o.setPrice(new Double(25));
session.save(o);
session.getTransaction().commit();
}
public static void listCstOrders()
{
Session session=HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
Set ls=((Customer)session.load(Customer.class,new Long(1))).getOrders();
Iterator it=null;
for(it=ls.iterator();it.hasNext();)
{
System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
Order o=(Order)it.next();
System.out.println(o.getName());
System.out.println("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
}
session.getTransaction().commit();
}
public static void getCustomer()
{
Session session=HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
Order or=new Order();
or.setId(new Long(1));
or.setCstid(new Long(2));
Order o=(Order)session.load(Order.class,or);
System.out.println("{{{{{{{{{{{{{{{{{{{");
System.out.println(o.getCustomer().getName());
System.out.println("}}}}}}}}}}}}}}}}}}}");
session.getTransaction().commit();
}
public static void main(String[] args)
{
//Test.getCustomer();
//Test.listCstOrders();
Test.saveCustomer();
//Test.saveOrder();
}
}
<project name="hibernate-tutorial" default="compile">
<property name="sourcedir" value="${basedir}/src"/>
<property name="targetdir" value="${basedir}/bin"/>
<property name="librarydir" value="${basedir}/lib"/>
<path id="libraries">
<fileset dir="${librarydir}">
<include name="*.jar"/>
</fileset>
</path>
<target name="clean">
<delete dir="${targetdir}"/>
<mkdir dir="${targetdir}"/>
</target>
<target name="compile" depends="clean, copy-resources">
<javac srcdir="${sourcedir}"
destdir="${targetdir}"
classpathref="libraries"/>
</target>
<target name="copy-resources">
<copy todir="${targetdir}">
<fileset dir="${sourcedir}">
<exclude name="**/*.java"/>
</fileset>
</copy>
</target>
<target name="run" depends="compile">
<java fork="true" classname="service.Test" classpathref="libraries">
<classpath path="${targetdir}"/>
</java>
</target>
</project>
分享到:
相关推荐
在Java的持久化框架Hibernate中,无主键表映射是一种特殊情况,主要处理那些在数据库中没有明确单一主键的表。这种情况通常出现在那些通过多个字段共同唯一标识一条记录的复合主键(Composite Key)场景。本文将详细...
本篇文章将深入探讨Hibernate如何处理复合主键映射,并通过实例进行解析。 复合主键在数据库设计中是常见的,例如,考虑一个订单明细表,其中订单号(order_id)和商品编号(product_id)结合在一起可以唯一识别一...
在XML配置时代,我们需要在Hibernate的映射文件(.hbm.xml)中显式声明复合主键。现在,大多数项目都使用注解配置,但如果你仍然需要处理旧的项目,这里是如何配置的示例: ```xml <hibernate-mapping> ...
在Hibernate中,有三种主要的注解方式来映射联合主键,以下是对这三种方式的详细解释: 1. **使用`@Embeddable`和`@Id`** 在这种映射方式中,联合主键的字段被放在一个单独的类中,这个类需要实现`java.io....
"Hibernate复合主键" Hibernate复合主键是指在 Hibernate 框架中使用复合主键来唯一标识一个实体。复合主键是指由多个字段组成的主键,用于唯一标识一个实体。在本例中,我们将通过一个简单的复合主键的做关联类的...
在Hibernate的映射文件(XML方式)或者使用JPA注解(Java方式)中,需要为复合主键提供相应的配置。对于XML配置,你可能会看到类似以下的设置: ```xml <hibernate-mapping> <!-- 其他属性的映射 --> ...
以上就是Hibernate主键生成的常见策略,每种策略都有其适用的场景。在实际开发中,应根据数据库类型和需求选择合适的主键生成策略,确保数据的一致性和完整性。理解并正确配置这些策略,将有助于提高程序的稳定性和...
hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,包含4个说明文档,分别详细解说了hibernate关联映射的...
通过这种方式,Hibernate将知道如何处理`UserRole`类,将其映射到具有复合主键的数据库表。 3. 嵌入式主键(Embedded Id): 如果希望将主键字段作为实体类的一部分,而不是单独的类,可以使用`@EmbeddedId`和`@...
标题"Hibernate一对一主键关联映射(双向关联)"中的"主键关联"指的是两个实体通过共享相同的主键来建立关联。"双向关联"则意味着在两个实体类中,都可以直接访问到对方的实例,即在实体A中有一个对实体B的引用,...
本实例将深入探讨如何在Hibernate中实现主键级别的单向一对一映射。 首先,我们理解一对一映射的基本概念。在数据库设计中,一对一映射通常发生在两个表的主键之间,其中一个表的主键是另一个表的外键。在Hibernate...
在Java的持久化框架Hibernate中,复合主键(Composite Key)是一种特殊的数据结构,用于处理具有多个字段作为唯一标识的情况。本实例将深入探讨如何在Hibernate中实现复合主键,并提供一个具体的示例来帮助理解。 ...
### Hibernate映射主键生成策略native #### 一、引言 在ORM(对象关系映射)技术中,Hibernate作为一款流行的Java持久层框架,在处理数据持久化方面提供了丰富的功能和灵活性。其中,主键生成策略是Hibernate配置...
### Hibernate中对数据库复合主键的支持 #### 一、引言 在软件开发过程中,特别是在J2EE领域中,Hibernate作为一种流行的ORM(Object-Relational Mapping)框架被广泛使用。ORM框架的主要作用是将关系型数据库中的...
Hibernate映射文件主键生成策略详解 Hibernate.cfg.xml配置文件是Hibernate框架中的一部分,该文件用于配置Hibernate的各种设置,例如数据库连接、dialect、mapping文件等。在这个文件中,我们可以看到hibernate-...
在Java的Hibernate框架中,复合主键映射是一种处理多列组合成主键的情况,它使得在数据库表中由两个或更多个字段组成的主键能够被正确地映射到实体类。在使用复合主键时,我们需要遵循一定的步骤和规则。 首先,...
标题中的“Spring+Hibernate 自动映射”是指在Java Web开发中,利用Spring框架与Hibernate ORM工具进行数据层的整合,实现对象关系映射(ORM)的自动化处理。这一技术结合了Spring的强大依赖注入(DI)和事务管理...
如果使用Hibernate开发legacy的数据库应用,对于数据库表中有使用字符串作为主键或者使用复合主键情况,那么对于这些情况的影射档是比较麻烦的。该示例应用演示了两张表ITEM和CATEGORY_ITEM表有主外键关系,并且ITEM...