hibernate注解配置

最新推荐文章于 2020-05-09 22:10:55 发布

Dzq_Boyka

最新推荐文章于 2020-05-09 22:10:55 发布

阅读量256

点赞数

分类专栏：框架

框架专栏收录该内容

60 篇文章 0 订阅

订阅专栏

原文：http://blog.csdn.net/he90227/article/details/39205281

1.双向多对一和一对多注解版

双向一对多关系，一是关系维护端（owner side），多是关系被维护端（inverse side）。在关系被维护端需要通过@JoinColumn建立外键列指向关系维护端的主键列。

publicclass Order implements Serializable {

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 ;

}

publicclass OrderItem implements Serializable {

private Order order ;

。。。。

@ ManyToOne (cascade=CascadeType. REFRESH ,optional= false )

@ JoinColumn (name = "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>fatch

可选择项包括： FetchType.EAGER 和 FetchType.LAZY 。前者表示关系类 ( 本例是 OrderItem 类 ) 在主类 ( 本例是 Order 类 ) 加载的时候同时加载，后者表示关系类在被访问时才加载。默认值是 FetchType.LAZY 。

@JoinColumn(name = "order_id") 注释指定OrderItem映射表的order_id列作为外键与Order 映射表的主键列关联。

@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;

}

利用ThreadLocal管理Hibernate的Session

在利用Hibernate开发DAO模块时，我们和Session打的交道最多，所以如何合理的管理Session，避免Session的频繁创建和销毁，对于提高系统的性能来说是非常重要的，以往是通过eclipse的插件来自动完成这些代码的，当然效果是不错的，但是总是觉得不爽(没有读懂那些冗长的代码)，所以现在打算自己实现Session管理的代码。我们知道Session是由SessionFactory负责创建的，而SessionFactory的实现是线程安全的，多个并发的线程可以同时访问一个SessionFactory并从中获取Session实例，那么Session是否是线程安全的呢？很遗憾，答案是否定的。Session中包含了数据库操作相关的状态信息，那么说如果多个线程同时使用一个Session实例进行CRUD，就很有可能导致数据存取的混乱，你能够想像那些你根本不能预测执行顺序的线程对你的一条记录进行操作的情形吗？
      在Session的众多管理方案中，我们今天来认识一种名为ThreadLocal模式的解决方案。
      早在Java1.2推出之时，Java平台中就引入了一个新的支持：java.lang.ThreadLocal，给我们在编写多线程程序时提供了一种新的选择。ThreadLocal是什么呢？其实ThreadLocal并非是一个线程的本地实现版本，它并不是一个Thread，而是thread local variable(线程局部变量)。也许把它命名为ThreadLocalVar更加合适。线程局部变量(ThreadLocal)其实的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有一个该变量。
      ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。比如下面的示例实现(为了简单，没有考虑集合的泛型)：

public class ThreadLocal {
　    private Map values = Collections.synchronizedMap(new HashMap());
　    public Object get() {
　　      Thread currentThread = Thread.currentThread();
　     　 Object result = values.get(currentThread);
　　      if(result == null&&!values.containsKey(currentThread)) {
　　　        result = initialValue();
　　　        values.put(currentThread, result);
　　      }
　　      return result;
　    }
　    public void set(Object newValue) {
　　      values.put(Thread.currentThread(), newValue);
　    }
   　 public Object initialValue() {
　　      return null;
　    }
}

      那麽具体如何利用ThreadLocal来管理Session呢？Hibernate官方文档手册的示例之中，提供了一个通过ThreadLocal维护Session的好榜样：

public class HibernateUtil {
       public static final SessionFactory sessionFactory;
       static {
           try {
                 sessionFactory = new Configuration().configure()
                                   .buildSessionFactory();
           } catch (Throwable ex) {
                throw new ExceptionInInitializerError(ex);
           }
       }
       public static final ThreadLocal<session></session> session =
                                            new ThreadLocal<session></session>();
       public static Session currentSession() throws HibernateException {
               Session s = session.get();
               if(s == null) {
                     s = sessionFactory.openSession();
                     session.set(s);
               }
               return s;
       }
       public static void closeSession() throws HibernateException {
                Session s = session.get();
                if(s != null) {
                      s.close();
                }
                session.set(null);
       }
}

     只要借助上面的工具类获取Session实例，我们就可以实现线程范围内的Session共享，从而避免了线程中频繁的创建和销毁Session实例。当然，不要忘记在用完后关闭Session。

2、多对一

@ManyToOne注解的这端，是多端

1.在注释@ManyToOne(cascade=CascadeType.REFRESH,optional=true)中将属性optional设置为true，这可以使得即使外键为空时仍可以向表中添加数据。

2.假设Person和Book是一对多的关系，其中Person的成员变量为：

private Integer personId;

private String name;

private Short age;

private List<Book> bookList=new ArrayList<Book>();

对应在MySql中表的结构为：Person(personId,name,age),不必有bookList一项，在getBookList上方通过注释:@OneToMany(mappedBy="person",cascade=CascadeType.ALL)

@OrderBy(value="bookId ASC")

与Book关系形成一对多的关系。Book的成员变量是：

private int bookId;

private String title;

private double price;

private Person person;

对应在MySql中表的结构为：Book(bookId,title,price,personId),注意要有Person表的主键personId，这样在插入记录时才不会产生异常。在getPerson上方有注释：

@ManyToOne(cascade=CascadeType.REFRESH,optional=true)

@JoinColumn(name="personId")

与@OneToMany形成呼应。

在EJB3.0 规范中多对一与一对多的双向关系，多对一（就是@ManyToOne注解的这端，是多端哦不要搞混了）这端总是双向关联端的主题(owner)端，而一对多端的关联注解为 @OneToMany（mappedBy=" " ）其值是：多对一端的属性

demo：

被动方：其实也就是一方或者说（OneToMany方）

@Entity
public class Customer extends AbstractEntity {

private String name;

@OneToMany(mappedBy="customer",cascade=CascadeType.ALL)
private Set<Order> orders;

public void addOrder(Order order){
if(orders == null){
orders = new HashSet<Order>();
}
orders.add(order);
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<Order> getOrders() {
return orders;
}
public void setOrders(Set<Order> orders) {
this.orders = orders;
}

}

主动方：1.关系的维护方2.ManyToOne方3.多方

@Entity
@Table(name="orders")
public class Order extends AbstractEntity {

private String name;

@ManyToOne(cascade=CascadeType.ALL)
private Customer customer;

public Customer getCustomer() {
return customer;
}

public void setCustomer(Customer customer) {
this.customer = customer;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}
}

以上是实体

下面是测试用列哦

public void testCRUD() {
// 第一种情况：调用的被动方的Dao 绑定主动方关系，但主动方没有绑定被动方
Customer entity = new Customer();
entity.setName("customer1");
Order order = new Order();
order.setName("order1");
entity.addOrder(order);
entity = customerDao.create(entity); // 这种情况下 orders.customer_id == null
//控制台的信息
//Hibernate: insert into Customer (name, id) values (?, ?)
//这里的customer_id 为null
//Hibernate: insert into orders (name, customer_id, id) values (?, ?, ?)
System.out.println("entity id = " + entity.getId());
System.out.println("order id = "+ order.getId());
System.out.println("1111********************** over");

// 第二种情况：调用的被动方的Dao 绑定主动方关系，并且主动方也绑定被动方
entity = new Customer();
entity.setName("customer2");
order = new Order();
order.setName("order2");
entity.addOrder(order);
order.setCustomer(entity); //这里进行双向关联
entity = customerDao.create(entity);
//
//Hibernate: insert into Customer (name, id) values (?, ?)
//这里的customer_id 有值哦
//Hibernate: insert into orders (name, customer_id, id) values (?, ?, ?)
System.out.println("entity id = " + entity.getId());
System.out.println("order id = "+ order.getId());
System.out.println("2222********************** over");
// 第三种情况：调用的主动方的Dao 绑定被动方关系，但是被东方不绑定主动方
entity = new Customer();
entity.setName("customer3");
order = new Order();
order.setName("order3");
order.setCustomer(entity); //绑定被动方
orderDao.create(order);
//Hibernate: insert into Customer (name, id) values (?, ?)
//Hibernate: insert into orders (name, customer_id, id) values (?, ?, ?)
System.out.println("entity id = " + entity.getId());
System.out.println("order id = "+ order.getId());
System.out.println("3333********************** over");

// 第四种情况：调用的主动方的Dao 绑定被动方关系，并且被东方也绑定主动方
entity = new Customer();
entity.setName("customer4");
order = new Order();
order.setName("order4");
order.setCustomer(entity); //绑定被动方
orderDao.create(order);
System.out.println("entity id = " + entity.getId());
System.out.println("order id = "+ order.getId());
System.out.println("4444********************** over");
//Hibernate: insert into Customer (name, id) values (?, ?)
//Hibernate: insert into orders (name, customer_id, id) values (?, ?, ?)

//总结：经测验二三四种方法结果都是一样都能持久化到数据库，并且关系也建立好了
// 也就说只要主动方绑定了被动方关系就维护好了
}

*****************************************做级联删除测试************************************************************

public void testCascade(){

//1. 做个级联删除吧测试删除主动方是否删除关联方
// 这里会级联删除主动方的关联对象，以及该关联对象（被动方）所关联的所有主动方都会被级联删除
orderDao.delete("order_id_1");
//Hibernate: delete from orders where id=?
// Hibernate: delete from orders where id=?
// Hibernate: delete from orders where id=?
// Hibernate: delete from orders where id=?
// Hibernate: delete from orders where id=?
// Hibernate: delete from Customer where id=?
assertNull( orderDao.findById("orderDao"));

//2. 做个级联删除吧测试删除被动方是否删除关联方
//删除该被动方，以及所关联的所有主动方（维护关系方or多方）与上面的调用主动方的结果一样
//Hibernate: delete from orders where id=?
// Hibernate: delete from orders where id=?
// Hibernate: delete from orders where id=?
// Hibernate: delete from orders where id=?
// Hibernate: delete from orders where id=?
// Hibernate: delete from Customer where id=?
customerDao.delete("2");
assertNull( customerDao.findById("2"));

}