文章目录
XML格式
项目结构
order.java
package com.hibernate.entity;
public class Order {
private Integer id;
private Double price;
private User user;
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Double getPrice() {
return price;
}
public void setPrice(Double price) {
this.price = price;
}
@Override
public String toString() {
return "Order [id=" + id + ", price=" + price + "]";
}
}
user.java
package com.hibernate.entity;
import java.util.HashSet;
import java.util.Set;
public class User {
private Integer id;
private String userName;
private String password;
//域模型中用来表示从用户能够导航到订单数据（从用户到订单的一对多关联）
//先初始化是为了放置空引用异常
//Set类型无序，且不重复。
//要求有顺序的话还是用
private Set orderSet = new HashSet<>();
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "User [id=" + id + ", userName=" + userName + ", password=" + password + "]";
}
public Set getOrderSet() {
return orderSet;
}
public void setOrderSet(Set orderSet) {
this.orderSet = orderSet;
}
}
order.hbm.xml
<?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 package="com.hibernate.entity">
<class name="Order" table="hibernate_05_01_orders">
<id name="id" type="int" column="id">
<generator class="identity"></generator>
</id>
<property name="price" column="price" ></property>
<!-- 映射一对多关系 -->
<many-to-one name="user" class="User" column="USER_ID"></many-to-one>
</class>
</hibernate-mapping>
User.hbm.xml
<?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 package="com.hibernate.entity">
<class name="User" table="hibernate_05_01_user">
<id name="id" type="int" column="id">
<generator class="identity"/>
</id>
<property name="userName" type="java.lang.String" column="name"/>
<property name="password" type="java.lang.String" column="password"/>
<!-- 映射User与Order之间的一对多关系
set标签用来映射Set类型的属性(name)
key:指定外键字段名字(此名称是数据库库名称)
one-to-many表示一对多关系 -->
<!-- 用户与订单这种情况不会产生创建用户也创建订单，
删除订单也不会删除用户，所以进选择delete -->
<set name="orderSet" cascade="delete">
<key column="USER_ID"/>
<one-to-many class="Order"/>
</set>
</class>
</hibernate-mapping>
Test.java
package com.hibernate.ui;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.hibernate.entity.Order;
import com.hibernate.entity.User;
import com.hibernate.util.HibernateUtil;
public class Test {
public static void main(String[] args) {
saveUserAndOrder();
// addOrder();
// getUserAndOrders();
// deleteUser();
// getOrderAndUser();
HibernateUtil.closeSessionFactory();
}
//保存
private static void saveUserAndOrder() {
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
User u = new User();
u.setUserName("李四");
u.setPassword("77777");
Order o = new Order();
o.setPrice(300.0);
//建立关联
Set set = new HashSet();
set.add(o);
u.setOrderSet(set);
session.save(u);
session.save(o);
tx.commit();
session.close();
}
//给已经存在的用户添加新的订单
private static void addOrder() {
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
User u = session.get(User.class, new Integer(1));
//新的订单对象
Order o = new Order();
o.setPrice(200.0);
//建立关联
u.getOrderSet().add(o);
session.save(o);
tx.commit();
session.close();
}
//一对一关联式，查询用户也会查询订单
//一对多时候查询用户仅是用户
//检索用户数据，并通过用户导航到它所关联的订单
private static void getUserAndOrders() {
Session session = HibernateUtil.openSession();
//一对多关联映射默认情况下查询用户时，不会连接订单表查询
User u = session.get(User.class, new Integer(1));
//通过上述用户对象导航到它关联的订单(映射关联关系的优势)
//这个方法也会触发一次查询
System.out.println(u.getOrderSet());
session.close();
}
//由于配置了级联删除操作，所以删除用户时，会自动删除同用户关联的订单
private static void deleteUser() {
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
User u = session.get(User.class, new Integer(1));
session.delete(u);
tx.commit();
session.close();
}
private static void getOrderAndUser() {
Session session=HibernateUtil.openSession();
Order o=session.get(Order.class,new Integer(2));
System.out.println(o.getUser());
System.out.println(o.getUser().toString());
}
}
注解格式配置
项目结构
user.java
package com.hibernate.entity;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="hibernate_05_05_user")
public class User {
private Integer id;
private String name;
private String password;
//域模型中用来表示从用户能够导航到订单数据（从用户到订单的一对多关联）
//先初始化是为了放置空引用异常
//Set类型无序，且不重复。
//要求有顺序的话还是用
private Set orderSet = new HashSet<>();
@Id
@GeneratedValue(generator ="linshi1" )
@GenericGenerator(name="linshi1",strategy ="native" )
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "User [id=" + id + ", name=" + name + ", password=" + password + ", orderSet=" + orderSet + "]";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@OneToMany(targetEntity = Order.class,mappedBy="user",cascade = CascadeType.ALL)
public Set getOrderSet() {
return orderSet;
}
public void setOrderSet(Set orderSet) {
this.orderSet = orderSet;
}
}
test.java
package com.hibernate.ui;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.hibernate.entity.Order;
import com.hibernate.entity.User;
import com.hibernate.util.HibernateUtil;
public class Test {
public static void main(String[] args) {
// saveUserAndOrder();
addOrder();
// getUserAndOrders();
// deleteUser();
// getOrderAndUser();
HibernateUtil.closeSessionFactory();
}
//保存
private static void saveUserAndOrder() {
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
User u = new User();
u.setName("李四");
u.setPassword("77777");
Order o = new Order();
o.setPrice(300.0);
//建立关联
Set set = new HashSet();
set.add(o);
u.setOrderSet(set);
session.save(u);
session.save(o);
tx.commit();
session.close();
}
//给已经存在的用户添加新的订单
private static void addOrder() {
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
User u = session.get(User.class, new Integer(1));
System.out.println(u.toString());
//新的订单对象
Order o = new Order();
o.setPrice(200.0);
System.out.println(o.toString());
//建立关联
u.getOrderSet().add(o);
o.setUser(u);
session.save(o);
tx.commit();
session.close();
}
//一对一关联式，查询用户也会查询订单
//一对多时候查询用户仅是用户
//检索用户数据，并通过用户导航到它所关联的订单
private static void getUserAndOrders() {
Session session = HibernateUtil.openSession();
//一对多关联映射默认情况下查询用户时，不会连接订单表查询
User u = session.get(User.class, new Integer(1));
//通过上述用户对象导航到它关联的订单(映射关联关系的优势)
//这个方法也会触发一次查询
System.out.println(u.getOrderSet());
session.close();
}
//由于配置了级联删除操作，所以删除用户时，会自动删除同用户关联的订单
private static void deleteUser() {
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
User u = session.get(User.class, new Integer(1));
session.delete(u);
tx.commit();
session.close();
}
private static void getOrderAndUser() {
Session session=HibernateUtil.openSession();
Order o=session.get(Order.class,new Integer(2));
System.out.println(o.getUser());
System.out.println(o.getUser().toString());
}
}
order.java
package com.hibernate.entity;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="hibernate_05_05_orders1")
public class Order {
private Integer id;
private Double price;
private User user;
//映射多对一关系
@ManyToOne
//映射外键字段
//使用注解方式映射双向一对多是，默认多的一方维护关联关系
@JoinColumn(name="USER_ID")
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
@Id
@GeneratedValue(generator ="linshi2" )
@GenericGenerator(name="linshi2",strategy ="native" )
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Double getPrice() {
return price;
}
public void setPrice(Double price) {
this.price = price;
}
@Override
public String toString() {
return "Order [id=" + id + ", price=" + price + "]";
}
}