hibernate的一对多配置

 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 }

 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 }

 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>

 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>

 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>

 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 }

 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 }