Hibernate学习（1）
JPA常用注解
请参考：http://1194867672-qq-com.iteye.com/blog/1730513
下面根据经验谈谈Hibernate的一对多，多对一问题。
（一）双向一对多的用法
可参考：http://blog.csdn.net/lxl_family/article/details/26523757
双向一对多关系，一是关系维护端（owner side），多是关系被维护端（inverse side）。数据库中的表一般都是相互关联的，它们通过foreign key产生关系。在关系被维护端需要通过@JoinColumn建立外键列指向关系维护端的主键列。
@Entity //设置一个类为实体类</span>
@JsonIgnoreProperties(value={"orderItems "}) </span>
@Table(name="Order") //作用：设置实体类对应的表，常与@Entity一起使用</span>
public class Order implements Serializable {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Long id;
@JsonIgnore
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private transient String strbegin;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")</span>
private Date begindate;
private Set<OrderItem> orderItems = new HashSet<OrderItem>();
。。。。
@OneToMany(mappedBy="order",cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@OrderBy(value = "id ASC")
public Set<OrderItem> getOrderItems() {
return orderItems;
}
//其他get set方法省略
}
public class OrderItem implements Serializable {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Long id;
private String itenName;
private Order order; //不用再根据表结构定义order_id属性
。。。。
@ManyToOne(cascade=CascadeType.REMOVE,optional=false)
@JoinColumn(name = "order_id",referencedColumnName="id") //OrderItem表中的order_id字段与order表中的id关联
public Order getOrder() {
return order;
}
}
@OrderBy(value = "id ASC")
指明加载
OrderItem
时按
id
的升序排序
@OneToMany
的属性
：
1>targetEntity
定义关系类的类型，默认是该成员属性对应的类类型，所以通常不需要提供定义。
2>mappedBy
定义类之间的双向关系。如果类之间是单向关系，不需要提供定义，如果类和类之间形成双向关系，我们就需要使用这个属性进行定义，否则可能引起数据一致性的问题。
该属性的值是“多”方class里的“一”方的变量名
3>cascade
该属性定义类和类之间的级联关系。定义的级联关系将被容器视为对当前类对象及其关联类对象采取相同的操作，而且这种关系是递归调用的。举个例子：
Order
和
OrderItem
有级联关系，那么删除
Order
时将同时删除它所对应的
OrderItem
对象。而如果
OrderItem
还和其他的对象之间有级联关系，那么这样的操作会一直递归执行下去。
cascade
的值只能从
CascadeType.PERSIST
（级联新建）、
CascadeType.REMOVE
（级联删除）、
CascadeType.REFRESH
（级联刷新）、
CascadeType.MERGE
（级联更新）中选择一个或多个。还有一个选择是使用
CascadeType.ALL
，表示选择全部四项。
4>fetch
可选择项包括：
FetchType.EAGER
和
FetchType.LAZY
。前者表示关系类
(
本例是
OrderItem
类
)
在主类
(
本例是
Order
类
)
加载的时候同时加载，后者表示关系类在被访问时才加载。默认值是
FetchType.LAZY
。
@JoinColumn(name = "order_id" ,referencedColumnName="id")
注释指定OrderItem映射表的order_id列作为外键与Order 映射表的主键列id关联。
@ManyToOne
：指明OrderItem和Order之间为多对一关系。
@ManyToOne
注释有四个属性：targetEntity、cascade、fetch 和optional，前三个属性的具体含义和@OneToMany的同名属性相同，但@ManyToOne的fetch 属性默认值是FetchType.EAGER。
optional
属性是定义该关联类是否必须存在，值为false 时，关联类双方都必须存在，如果关系被维护端不存在，查询的结果为null。值为true 时, 关系被维护端可以不存在，查询的结果仍然会返回关系维护端，在关系维护端中指向关系被维护端的属性为null。optional属性的默认值是true。optional 属性实际上指定关联类与被关联类的join 查询关系，如optional=false 时join 查询关系为inner join, optional=true 时join 查询关系为left join。下面代码片断解释如下:
有一点需要强调：当业务方法需要把一个实体
Bean
作为参数返回给客户端时，除了实体
Bean本身需要实现Serializable
接口之外
，如果关联类(OrderItem)是延迟加载，还需在返回实体Bean之前通过访问关联类的方式加载关联类（见下例）。否则在客户端访问关联类时将会抛出加载例外。
public
Order getOrderByID(Integer orderid) {
Order order =
em
.find(Order.
class
, orderid);
//!!!!!
因为是延迟加载，通过执行
size()
这种方式获取订单下的所有订单项
order.getOrderItems().size();
return
order;
}
另外不管是否延迟加载，通过join fetch 关联语句都可显式加载关联类
，如下例：
public
List getAllOrder() {
Query query =
em
.createQuery(
"select DISTINCT o from Order o inner
join fetch o.orderItems order by o.orderid"
);
List result = query.getResultList();
return
result;
}
通常后台返回的数据都需要转换成JSON字符串，以下三个注解都是用于JSON转换。
@JsonIgnoreProperties(value={"OrderItems"}) 忽略实体类中的关联类
通常后台返回的数据都需要转换成JSON字符串，以下三个注解都是用于JSON转换。
@JsonIgnore 也可以直接在属性上Ignore
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") 对属性进行格式转换，一般用于时间等特殊格式。
如果不处理，可能报错：
jackson.databind.ser.BeanSerializer.serialize(BeanSerializer.java:143) //Json转换死循环
org.springframework.orm.hibernate3.HibernateQueryException: could not resolve property
org.springframework.http.converter.HttpMessageNotWritableException: Could not write content: could not initialize proxy - no Session (through reference chain。。。）
（二）Hql的关联查询
1、从One的一方关联到Many的一方：
查找出球员所属的球队，可以使用以下语句：
SELECT DISTINCT t FROM Order t JOIN t.OrderItems p where p.ItemName LIKE :name或者使用以下语句：
SELECT DISTINCT t FROM Order t,IN(t.OrderItems) p WHERE p.ItemName LIKE :name
上面两条语句是等价的，产生的SQL语句如下：
select
distinct Order0_.id as id0_,
Order0_.ItemName as ItemName0_
from
Order Order0_
inner join
player OrderItem1_
on Order0_.id=OrderItem1_.Order_id
where
OrderItems1_.ItemName like ?
从SQL语句中可以看到team inner join 到player。inner join要求右边的表达式必须有返回值。
不能使用以下语句：
<span style="font-size:12px;">SELECT DISTINCT t FROM Order t WHERE t.OrderItem.ItemName LIKE :ItemName </span>
不能使用t.OrderItems.ItenName这样的方式从集合中取值，要使用join或者in才行。
2、从Many的一方关联到One的一方：
查找出某个球队下的所有球员，可以使用以下查询语句：
<span style="font-size:12px;">SELECT p FROM OrderItem p JOIN p.Order t WHERE t.id = :id </span>
或者使用以下语句
SELECT p FROM OrderItem p, IN(p.Order) t WHERE t.id = :id这两条查询语句是等价的，产生的SQL语句如下：(产生了两条SQL)
Hibernate:
select
OrderItem0_.id as id1_,
OrderItem0_.ItemName as ItemName1_,
OrderItem0_.Order_id as Order3_1_
from
OrderItem OrderItem0_
inner join
Order Order1_
on OrderItem0_.Order_id=Order1_.id
where
Order1_.id=?
Hibernate:
select
Order0_.id as id2_0_,
Order0_.ItemName as ItemName2_0_
from
Order Order0_
where
Order0_.id=?
从Many关联到One的查询，还可以使用以下的查询语句：
SELECT p FROM OrderItem p WHERE p.Order.id = :id这条语句产生的SQL如下：(产生了两条SQL)
SELECT p FROM OrderItem p WHERE p.Order.id = :id
Hibernate:
select
OrderItem0_.id as id1_,
OrderItem0_.name as name1_,
OrderItem0_.Order_id as Order3_1_
from
OrderItem OrderItem0_
where
OrderItem0_.Order_id=?
Hibernate:
select
Order0_.id as id0_0_,
Order0_.name as name0_0_
from
Order Order0
以上从Many到One的关联查询都产生了两条SQL，还可以使用join fetch只产生一条SQL语句。查询语句如下：
SELECT p FROM OrderItem p JOIN FETCH p.Order t WHERE t.id = :id
这条查询语句产生的SQL如下：
Hibernate:
select
OrderItem0_.id as id1_0_,
Order1_.id as id2_1_,
OrderItem0_.name as name1_0_,
OrderItem0_.Order_id as Order3_1_0_,
Order1_.name as name2_1_
from
OrderItem OrderItem0_
inner join
Order Order1_
on OrderItem0_.Order_id=Order1_.id
where
Order1_.id=?
可参考： http://www.cnblogs.com/luxh/archive/2012/06/02/2531750.html