首先是“一”的
Customer.java
1 package com.xiaostudy.domain;
2
3 import java.util.HashSet;
4 import java.util.Set;
5
6 /**
7 * 一对多中的“一”的bean
8 *
9 * @author xiaostudy
10 *
11 */
12 public class Customer {
13 // id
14 private Integer id;
15 // 普通属性
16 private String name;
17 // “多”的集合，一般选Set集合，因为Set的特点，里面的元素不能重复
18 private Set<Order> order = new HashSet<Order>();
19
20 // 自动生成get、set方法
21 public Integer getId() {
22 return id;
23 }
24
25 public void setId(int id) {
26 this.id = id;
27 }
28
29 public String getName() {
30 return name;
31 }
32
33 public void setName(String name) {
34 this.name = name;
35 }
36
37 public Set<Order> getOrder() {
38 return order;
39 }
40
41 public void setOrder(Set<Order> order) {
42 this.order = order;
43 }
44 }
接着就是“多”
Order.java
1 package com.xiaostudy.domain;
2
3 /**
4 * 一对多中的“多”的bean
5 *
6 * @author xiaostudy
7 *
8 */
9 public class Order {
10 // id
11 private Integer id;
12 // 普通属性
13 private String name;
14 // 一对多中的“一”
15 private Customer customer;
16
17 // 自动生成get、set方法
18 public Integer getId() {
19 return id;
20 }
21
22 public void setId(Integer id) {
23 this.id = id;
24 }
25
26 public String getName() {
27 return name;
28 }
29
30 public void setName(String name) {
31 this.name = name;
32 }
33
34 public Customer getCustomer() {
35 return customer;
36 }
37
38 public void setCustomer(Customer customer) {
39 this.customer = customer;
40 }
41
42 }
接着就是这两个bean对应的映射关系配置文件
Customer.hbm.xml
1 <?xml version="1.0" encoding="UTF-8"?> 2 <!DOCTYPE hibernate-mapping PUBLIC 3 "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 4 "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 5 <!-- 引进包，如果没有引进，下面用到的类要全路径 --> 6 <hibernate-mapping package="com.xiaostudy.domain"> 7 <!-- name为bean的类名，table为数据库的表名 --> 8 <class name="Customer" table="customer"> 9 <!-- name为bean中的属性id，column为数据库中的列名 --> 10 <id name="id" column="id"> 11 <!-- generator:主键生成策略 12 1.increment 数据库自己生成主键. 先从数据库中查询最大的ID值,将ID值加1作为新的主键 13 2.identity 依赖于数据的主键自增功能 14 3.sequence 序列,依赖于数据中的序列功能(Oracle). 15 4.hilo(纯了解,永远用不到) : Hibernate自己实现序列的算法,自己生成主键. (hilo算法 ) 16 5.native 自动根据数据库判断,三选一. identity|sequence|hilo 17 6.uuid 生成32位的不重复随机字符串当做主键 18 7.assigned 自己指定主键值. 表的主键是自然主键时使用. 19 --> 20 <generator class="native"></generator> 21 </id> 22 <!-- property普遍属性，name为bean中的普通属性，column为数据库中的列名，type为数据类型 --> 23 <property name="name" column="name" type="string"></property> 24 <!-- set为一对多中“一”的设置，inverse的值表示是否为自身维护关系，默认也是false --> 25 <set name="order" inverse="true"> 26 <!-- key为“一”对应“多”的键，column为键的名称 --> 27 <key column="cid"></key> 28 <!-- one-to-many表明自身是一对多的“一”，class为“多”的类名 --> 29 <one-to-many class="Order" /> 30 </set> 31 </class> 32 </hibernate-mapping>
Order.hbm.xml
1 <?xml version="1.0" encoding="UTF-8"?> 2 <!DOCTYPE hibernate-mapping PUBLIC 3 "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 4 "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 5 6 <hibernate-mapping package="com.xiaostudy.domain"> 7 <!-- name为一对多中的“多”的类名，table为数据库的表名， 8 注意：这里不能用order做表名，因为在mysql中，它是一个关键词 --> 9 <class name="Order" table="t_order"> 10 <!-- name是id的名称，column为数据库中表的列名 --> 11 <id name="id" column="id"> 12 <!-- generator:主键生成策略 13 1.increment 数据库自己生成主键. 先从数据库中查询最大的ID值,将ID值加1作为新的主键 14 2.identity 依赖于数据的主键自增功能 15 3.sequence 序列,依赖于数据中的序列功能(Oracle). 16 4.hilo(纯了解,永远用不到) : Hibernate自己实现序列的算法,自己生成主键. (hilo算法 ) 17 5.native 自动根据数据库判断,三选一. identity|sequence|hilo 18 6.uuid 生成32位的不重复随机字符串当做主键 19 7.assigned 自己指定主键值. 表的主键是自然主键时使用. 20 --> 21 <generator class="native"></generator> 22 </id> 23 <!-- property普遍属性，name为bean中的普通属性，column为数据库中的列名，type为数据类型 --> 24 <property name="name" column="name" type="string"></property> 25 <!-- many-to-one表明自身为“多”，name为bean中属性“一”的名称，column为自身的外键id，class为“一”的类名 --> 26 <many-to-one name="customer" column="cid" class="Customer"></many-to-one> 27 </class> 28 </hibernate-mapping>
hibernate.cfg.xml
1 <?xml version="1.0" encoding="UTF-8" ?> 2 <!DOCTYPE hibernate-configuration PUBLIC 3 "-//Hibernate/Hibernate Configuration DTD 3.0//EN" 4 "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> 5 6 <hibernate-configuration> 7 <session-factory> 8 <!-- 注册驱动 --> 9 <property name="connection.driver_class">com.mysql.jdbc.Driver</property> 10 <!-- mysql的用户名 --> 11 <property name="connection.username">root</property> 12 <!-- mysql的用户密码 --> 13 <property name="connection.password">123456</property> 14 <!-- 连接mysql的某库 --> 15 <property name="connection.url">jdbc:mysql://localhost:3306/user</property> 16 <!-- 控制台输出sql --> 17 <property name="show_sql">true</property> 18 <!-- 格式化输出的sql --> 19 <property name="format_sql">true</property> 20 <!-- 自动提交事务 --> 21 <!-- <property name="connection.autocommit">true</property> --> 22 <!-- 创建sql表 23 update：如果没有表，则创建一个。如果有表，而且表结构一致，那么不改变表。如果表结构不一样，会添加sql表缺少的列，多余的也不会删除。 24 create：不管sql表有没有存在，都会重新创建表。 25 create-drop：在create的基础上，每次关闭虚拟机时都会把表删除了。 26 validate：效验sql表，如果一致，则没有反应，如果不一致了，会抛出异常。 27 --> 28 <property name="hbm2ddl.auto">update</property> 29 <!-- 将Session与线程绑定=> 只有配置了该配置,才能使用getCurrentSession --> 30 <property name="current_session_context_class">thread</property> 31 <!-- 数据库方言配置 --> 32 <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> 33 <!-- 导入映射文件 --> 34 <mapping resource="com/xiaostudy/domain/Customer.hbm.xml"/> 35 <mapping resource="com/xiaostudy/domain/Order.hbm.xml"/> 36 </session-factory> 37 </hibernate-configuration>
HibernateUtils.java
1 package com.xiaostudy.util;
2
3 import org.hibernate.SessionFactory;
4 import org.hibernate.cfg.Configuration;
5 import org.hibernate.classic.Session;
6
7 /**
8 * Hibernate的工具类
9 *
10 * @author xiaostudy
11 *
12 */
13 public class HibernateUtils {
14 // 定义一个SessionFactory
15 private static SessionFactory sessionFactory;
16
17 // 静态代码块，当类加载时，会只执行一次
18 static {
19 // 加载配置文件，这里没有参数，是因为hibernate.cfg.xml文件是默认放在src目录下
20 Configuration conf = new Configuration().configure();
21 // 通过配置文件获取一个SessionFactory
22 sessionFactory = conf.buildSessionFactory();
23 // 当退出java虚拟机时，自动关闭资源
24 Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
25 @Override
26 public void run() {
27 sessionFactory.close();
28 }
29 }));
30 }
31
32 // 每次都获取新的一个Session
33 public static Session openSession() {
34 return sessionFactory.openSession();
35 }
36
37 // 获取当前线程的Session，多用于处理事务
38 public static Session getCurrentSession() {
39 return sessionFactory.getCurrentSession();
40 }
41
42 }
Test1.java
1 package com.xiaostudy.test;
2
3 import org.hibernate.classic.Session;
4
5 import com.xiaostudy.domain.Customer;
6 import com.xiaostudy.domain.Order;
7 import com.xiaostudy.util.HibernateUtils;
8
9 /**
10 * 测试一对多
11 *
12 * @author xiaostudy
13 *
14 */
15 public class Test1 {
16
17 public static void main(String[] args) {
18 // 根据工具类获取一个全新的Session
19 Session session = HibernateUtils.openSession();
20 // 开始事务
21 session.beginTransaction();
22 // 创建“一”的对象
23 Customer customer = new Customer();
24 // 赋值
25 customer.setName("demo1");
26 // 创建“多”的对象
27 Order order1 = new Order();
28 Order order2 = new Order();
29 // 赋值
30 order1.setName("test1");
31 order2.setName("test2");
32 // 这里是“一”没有维护关系，所以在“多”的设置把“一”添加进来
33 order1.setCustomer(customer);
34 order2.setCustomer(customer);
35 // 数据持久化
36 session.save(customer);
37 session.save(order1);
38 session.save(order2);
39 // 关闭事务和提交数据
40 session.getTransaction().commit();
41 // 关闭资源
42 session.close();
43 }
44
45 }
整个项目上传到码云：https://gitee.com/xiaostudy2/hibernate_one_to_many_demo/attach_files
hibernate的一对多配置
原文地址：https://www.cnblogs.com/xiaostudy/p/9520280.html
时间： 2024-11-09 00:37:48