)
Hibernate关联关系
关联指的是类之间的引用关系。如果类A与类B关联，那么被引用的类B将被定义为类A的属性。例如:
订单和订单项
一个订单对应多个订单项
Order.java
package entity; import java.io.Serializable; import java.util.HashSet; import java.util.Set; public class Order implements Serializable { private static final long serialVersionUID = -1737859893948370664L; private Integer orderId; private String orderNo; private Set<OrderItem> orderItem = new HashSet<OrderItem>(); public Order() { super(); } public Integer getOrderId() { return orderId; } public void setOrderId(Integer orderId) { this.orderId = orderId; } public String getOrderNo() { return orderNo; } public void setOrderNo(String orderNo) { this.orderNo = orderNo; } public Set<OrderItem> getOrderItem() { return orderItem; } public void setOrderItem(Set<OrderItem> orderItem) { this.orderItem = orderItem; } @Override public String toString() { return "Order [orderId=" + orderId + ", orderNo=" + orderNo + "]"; } }订单配置文件Order.hbm.xml
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="entity.Order" table="t_order"> <id name="orderId" column="order_id" type="integer"> <generator class="native"></generator> </id> <property name="orderNo" column="order_no" type="string"></property> <!-- lazy：是否懒加载，默认是懒加载的true 懒汉模式 name：类的关联属性名 cascade：级联关系 级联新增与修改 inverse：关联关系交给对方控制 默认是true，当前类不维护关联关系 子标签key:column:主表的主键，从表的外键 --> <set name="orderItem" inverse="true" cascade="save-update"> <key column="oid"></key> <one-to-many class="entity.OrderItem"/> </set> </class> </hibernate-mapping>订单项
OrderItem.java
package entity; import java.io.Serializable; public class OrderItem implements Serializable{ private static final long serialVersionUID = 7224901622594643894L; private Integer orderItemId; private Integer productId; private Integer quantity; private Integer oid; //如果类OrderItem与Order关联，那么被引用的类Order将被定义为类OrderItem的属性 private Order order; public OrderItem() { super(); } public Integer getOrderItemId() { return orderItemId; } public void setOrderItemId(Integer orderItemId) { this.orderItemId = orderItemId; } public Integer getProductId() { return productId; } public void setProductId(Integer productId) { this.productId = productId; } public Integer getQuantity() { return quantity; } public void setQuantity(Integer quantity) { this.quantity = quantity; } public Integer getOid() { return oid; } public void setOid(Integer oid) { this.oid = oid; } public Order getOrder() { return order; } public void setOrder(Order order) { this.order = order; } @Override public String toString() { return "OrderItem [orderItemId=" + orderItemId + ", productId=" + productId + ", quantity=" + quantity +"]"; } }订单项配置文件OrderItem.hbm.xml
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="entity.OrderItem" table="t_order_item"> <id name="orderItemId" column="order_item_id" type="integer"> <generator class="native"></generator> </id> <property name="productId" column="product_id" type="integer"></property> <property name="quantity" column="quantity" type="integer"></property> <property insert="false" update="false" name="oid" column="oid" type="integer"></property> <many-to-one name="order" class="entity.Order" column="oid"></many-to-one> </class> </hibernate-mapping>编写Junit测试类
OrderDAOTest
package dao; import org.junit.Before; import org.junit.Test; import entity.Order; import entity.OrderItem; public class OrderDAOTest { private OrderDAO orderDAO; private Order order; @Before public void setUp() throws Exception { orderDAO = new OrderDAO(); order = new Order(); } @Test public void testAdd() { order.setOrderNo("p3"); OrderItem orderItem = null; for (int i = 1; i <= 10; i++) { orderItem = new OrderItem(); orderItem.setProductId(i); orderItem.setQuantity(i+1); orderItem.setOrder(order); order.getOrderItem().add(orderItem); } orderDAO.add(order); } @Test public void testLoad() { order.setOrderId(3); Order load = orderDAO.load(order); System.out.println(load.getOrderId()); System.out.println(load.getOrderNo()); System.out.println(load.getOrderItem().size()); } }懒汉模式：加载是不创建实例，用户获取时才真正判断是否为空，如果为空才创建实例
public class Singleton2 { //构造方法私有化，不允许外面直接创建对象 private Singleton2(){} //声明类的唯一实例，使用private static 修饰 private static Singleton2 instance; //提供一个获取实例的方法，使用 public staitc修饰 public static Singleton2 getInstance() { if(instance==null) { instance=new Singleton2(); } return instance; } } public class Test { public static void main(String[] args) { Singleton2 s3=Singleton2.getInstance(); Singleton2 s4=Singleton2.getInstance(); if(s3==s4) System.out.println("s1和s2是同一个实例"); else System.out.println("s1和s2不是同一个实例"); } }懒加载(lazy)：就是延时加载，延迟加载。
lazy有三个属性：true、false、extra（集合属性时候使用）
true:默认取值，它的意思是只有在调用这个集合获取里面的元素对象时，才发出查询语句，加载其集合元素的数据。
false:取消懒加载特性，即在加载对象的同时，就发出第二条查询语句加载其关联集合的数据。
extra:一种比较聪明的懒加载策略，即调用集合的size/contains等方法的时候，hibernate并不会去加载整个集合的数据，而是发出一条聪明的SQL语句，以便获得需要的值，只有在真正需要用到这些集合元素对象数据的时候，才去发出查询语句加载所有对象的数据。extra能够更高性能的提升Hibernate的查询效率。
 agent和组件)