开发者社区> 技术小胖子> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

Hibernate3.6应用实例详解

简介:
+关注继续查看

Hibernate是一个非常著名的的对象--关系映射工具,本文使用的是Hibernate3.6的版本。本文通过建立一个工程,来引导大家学习hibernate,对hibernate有个认识。有些代码、概念不清楚没关系,后文会慢慢的介绍。文中也有大量的注释,附件会上传本文所有的源码。

首先建立一个Web Project,然后在WEB-INF/lib下添加相关的jar包。项目结构如下图1所示。jar包介绍如下:

 

图1

hibernate-distribution-3.6.0.Final-dist\hibernate-distribution-3.6.0.Final\lib\required 目录下相应的jar包:

  • antlr-2.7.6.jar:HQL-->SQL的转换
  • commons-collections-3.1.jar:Apache的集合类工具
  • dom4j.jar:解析XML文档
  • hibernate3.jar:hibernate核心API实现
  • javassist-3.12.0.GA.jar:动态Java代码生成工具
  • jta-1.1.jar:标准的Java事务处理接口
  • slf4j-api-1.6.1.jar:日志管理API
  • slf4j-nop-1.6.1.jar:日志管理。

一.持久化类如下:

Customer.java


  1. package com.yaxing.entity;  
  2.  
  3. import java.util.HashSet;  
  4. import java.util.Set;  
  5. /**  
  6.  * 顾客类  
  7.  * */ 
  8. public class Customer {  
  9.     private Long id;  
  10.     private String name;  
  11.     private Set<Order> orders = new HashSet<Order>();  
  12.  
  13.     public Long getId() {  
  14.         return id;  
  15.     }  
  16.  
  17.     public void setId(Long id) {  
  18.         this.id = id;  
  19.     }  
  20.  
  21.     public String getName() {  
  22.         return name;  
  23.     }  
  24.  
  25.     public void setName(String name) {  
  26.         this.name = name;  
  27.     }  
  28.  
  29.     public Set<Order> getOrders() {  
  30.         return orders;  
  31.     }  
  32.  
  33.     public void setOrders(Set<Order> orders) {  
  34.         this.orders = orders;  
  35.     }  
  36.  
  37. }  

Order.java


  1. package com.yaxing.entity;  
  2. /**  
  3.  * 订单类  
  4.  * */ 
  5. public class Order {  
  6.     private Long id;  
  7.     private Customer customer;  
  8.     private String orderNumber;  
  9.  
  10.     public Long getId() {  
  11.         return id;  
  12.     }  
  13.  
  14.     public void setId(Long id) {  
  15.         this.id = id;  
  16.     }  
  17.  
  18.     public Customer getCustomer() {  
  19.         return customer;  
  20.     }  
  21.  
  22.     public void setCustomer(Customer customer) {  
  23.         this.customer = customer;  
  24.     }  
  25.  
  26.     public String getOrderNumber() {  
  27.         return orderNumber;  
  28.     }  
  29.  
  30.     public void setOrderNumber(String orderNumber) {  
  31.         this.orderNumber = orderNumber;  
  32.     }  
  33.  
  34. }  

说明如下:这是一种典型的一对多的关联关系。即一个客户会有多个订单,而一个订单必然会属于一个客户,因此对于一个订单来说,如果其客户不存在,则此订单是没有任何意义的。这里设置的是双向的关联关系。因为可能业务中会存在大量的这样的需求:

  • 查询客户的所有订单
  • 根据所给的订单,查询订单所属的客户

类与类之间建立关联关系,可以很方便的从一个对象导航到另外一个对象,建立关系如下:


  1. /**  
  2.  * 订单类  
  3.  * */ 
  4. public class Order {  
  5.     private Long id;  
  6.     private Customer customer;  
  7.          //...  
  8. }  

这样就从order对象导航到了customer对象,

从order对象到customer对象的导航如下:即给定了order对象,获得了与他所关联的costomer对象.


  1. Customer customer = order.getCustomer(); 

那么对于给定的costomer对象,如何从customer对象导航到order对象呢?因为customer对象里面包含一组order,即一个客户会存在多个订单。

因此对于给定的客户,要查询所有的订单,代码如下:

返回的是一个Set集合。


  1. customer.getOrders();//返回一个set集合,用迭代器访问。 

关于集合类的操作,也不是本文的内容,读者可以参考其他文章。不清楚的,可以本文后面留言。

二.数据库和配置文件.

建立的数据库如图2所示下:

 

图2

 

注意,Id都是自增numeric类型。这里的Orders表的取名问题:因为order是关键字,作为表名的时候,会报错的,Sql Server 中对关键字作为表名字段名的处理是:使用的时候加上中括号[],有时开发中也没注意到这点,判断错误起来也麻烦,关于这点,参见博客另外一篇文章:因使用关键字做为表名引起的Hibernate报错。

配置文件如下:Customer.hbm.xml


  1. <?xml version="1.0" encoding="utf-8"?> 
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 
  4.  
  5. <hibernate-mapping> 
  6.     <class name="com.yaxing.entity.Customer" table="Customer"> 
  7.         <id name="id" type="java.lang.Long" column="Id"> 
  8.               
  9.             <generator class="identity"></generator> 
  10.         </id> 
  11.         <property name="name" column="Name" type="string"></property> 
  12.         <set name="orders" cascade="all" inverse="true"> 
  13.             <key column="CustomerId"/><!-- 对应着外键 --> 
  14.             <one-to-many class="com.yaxing.entity.Order"/> 
  15.         </set> 
  16.     </class> 
  17. </hibernate-mapping> 

说明如下:

①<class>元素指定类和表的映射,如果没有指定table属性,则hibernate将类名做为表名。一个<class>包括一个<id>子元素和多个<property>子元素。

②<id>元素设定持久化类的OID(Object Identifier)和表的主键的映射,上述配置代码表示Customer类的id属性和Customer表的Id字段对应。

③<id>元素的<generator>子元素用于指定对象标识符生成器,它负责为OID生成唯一标识符。后文将介绍常见的对象标识符生成器的介绍。本文使用的是 native表示hibernate根据底层数据库来选择。

④<property>子元素设定类的属性和表的字段的映射,常见的属性包括

  • name:指定持久化类的属性的名字
  • type:指定hibernate映射类型,hibernate映射类型是在java类型和Sql类型之间的一个桥梁。比如java.lang.String 对应 type则为string。详细情况可以参见三者之间的对应关系。如果没有为某个属性设置映射类型,hibernate会利用java的放射机制先识别出持久化类的属性的java的类型,然后自动使用与之对应的hibernate映射类型。
  • column:指定与持久化类的属性映射的表的字段名,上述代码表示Customer类的name属性对应的是Customer表的Name字段。
  • not-null:是否允许为空,默认为false。程序中经常碰到为空的异常,此处的配置需特别引起注意!
  • <set>元素:表示Customer类的orders属性为Set集合,<one-to-many>表示orders里面存放的是一组Order对象,<key>表示数据库中Orders表通过外键CustomerId参照Customer表。<cascade>表示级联保存,默认为none,取值可以有all 、           save-update 、delete、 delete-orphan ,各参数具体的含义后文有介绍。

Order.hbm.xml


  1. <?xml version="1.0" encoding="utf-8"?> 
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 
  4.  
  5. <hibernate-mapping> 
  6.     <class name="com.yaxing.entity.Order" table="Orders"> 
  7.         <id name="id" type="java.lang.Long" column="Id"> 
  8.             <generator class="identity"></generator> 
  9.         </id> 
  10.         <property name="orderNumber" column="OrderNumber" type="string"></property> 
  11.         <many-to-one name="customer" column="CustomerId" 
  12.             class="com.yaxing.entity.Customer" cascade="all" lazy="false" 
  13.             not-null="true"></many-to-one> 
  14.     </class> 
  15. </hibernate-mapping> 

说明:<many-to-one>表示 建立了customer属性和Orders表的外键CustomerId之间的映射,name为持久化类的属性的名字,column为持久化类的属性对应的表的外键CustomerId,class为持久化类的属性的类型,not-null表示是否允许为空,默认值为false.lazy是hibernate的检索策略,后文将有介绍。

三.测试代码和测试结果.

 CustomerAction.java

 


  1. package com.yaxing.test;  
  2.  
  3. import java.util.Iterator;  
  4. import java.util.List;  
  5.  
  6. import org.hibernate.Query;  
  7. import org.hibernate.Session;  
  8. import org.hibernate.Transaction;  
  9.  
  10. import com.yaxing.entity.Customer;  
  11. import com.yaxing.util.HibernateUtil;  
  12.  
  13. public class CustomerAction {  
  14.     private Customer customer;  
  15.     private List<Customer> listCustomer;  
  16.  
  17.     public Customer getCustomer() {  
  18.         return customer;  
  19.     }  
  20.  
  21.     public void setCustomer(Customer customer) {  
  22.         this.customer = customer;  
  23.     }  
  24.  
  25.     public List<Customer> getListCustomer() {  
  26.         return listCustomer;  
  27.     }  
  28.  
  29.     public void setListCustomer(List<Customer> listCustomer) {  
  30.         this.listCustomer = listCustomer;  
  31.     }  
  32.     /**  
  33.      * 添加客户  
  34.      * */ 
  35.     public void addCustomer(Customer customer) {  
  36.         Session s = null;  
  37.         Transaction tx = null;  
  38.         try {  
  39.             s = HibernateUtil.getSession();  
  40.             tx = s.beginTransaction();  
  41.             s.save(customer);  
  42.             tx.commit();  
  43.         }catch(Exception e){  
  44.             if(tx!=null){  
  45.                 tx.rollback();  
  46.             }  
  47.             e.printStackTrace();  
  48.         }finally{  
  49.             if(s!=null){  
  50.                 s.close();  
  51.             }     
  52.         }  
  53.     }  
  54.     /**  
  55.      * 删除客户  
  56.      * */ 
  57.     public void deleteCustomer(Customer customer) {  
  58.         Session s = null;  
  59.         Transaction tx = null;  
  60.         try {  
  61.             s = HibernateUtil.getSession();  
  62.             tx = s.beginTransaction();  
  63.             s.delete(customer);  
  64.             tx.commit();  
  65.         }catch(Exception e){  
  66.             if(tx!=null){  
  67.                 tx.rollback();  
  68.             }  
  69.             e.printStackTrace();  
  70.         }finally{  
  71.             if(s!=null){  
  72.                 s.close();  
  73.             }     
  74.         }  
  75.     }  
  76.     /**  
  77.      * 更新客户  
  78.      * */ 
  79.     public void update(Customer customer,String name) {  
  80.         Session s = null;  
  81.         Transaction tx = null;  
  82.         try {  
  83.             s = HibernateUtil.getSession();  
  84.             tx = s.beginTransaction();  
  85.             customer.setName(name);  
  86.             s.update(customer);  
  87.             tx.commit();  
  88.         }catch(Exception e){  
  89.             if(tx!=null){  
  90.                 tx.rollback();  
  91.             }  
  92.             e.printStackTrace();  
  93.         }finally{  
  94.             if(s!=null){  
  95.                 s.close();  
  96.             }     
  97.         }  
  98.     }  
  99.     /**  
  100.      * 查询客户  
  101.      * */ 
  102.     public Customer findCustomer(Long id) {  
  103.         Session s = null;  
  104.         Transaction tx = null;  
  105.         try {  
  106.             s = HibernateUtil.getSession();  
  107.             tx = s.beginTransaction();  
  108.             customer = (Customer) s.get(Customer.class, id);  
  109.             tx.commit();  
  110.         }catch(Exception e){  
  111.             if(tx!=null){  
  112.                 tx.rollback();  
  113.             }  
  114.             e.printStackTrace();  
  115.         }finally{  
  116.             if(s!=null){  
  117.                 s.close();  
  118.             }     
  119.         }  
  120.         return customer;  
  121.     }  
  122.     /**  
  123.      * 查找所有的客户  
  124.      * */ 
  125.     public List<Customer> findAll() {  
  126.         Session s = null;  
  127.         Transaction tx = null;  
  128.         try {  
  129.             s = HibernateUtil.getSession();  
  130.             tx = s.beginTransaction();  
  131.             Query query = s.createQuery("from Customer as a order by id asc");  
  132.             listCustomer = query.list();  
  133.             for(Iterator iter=listCustomer.iterator();iter.hasNext();){  
  134.                 Customer customer = (Customer) iter.next();  
  135.                 System.out.println("客户ID是:"+customer.getId()+"客户姓名是:"+customer.getName());  
  136.             }     
  137.             tx.commit();  
  138.         }catch(Exception e){  
  139.             if(tx!=null){  
  140.                 tx.rollback();  
  141.             }  
  142.             e.printStackTrace();  
  143.         }finally{  
  144.             if(s!=null){  
  145.                 s.close();  
  146.             }     
  147.         }  
  148.         return listCustomer;  
  149.     }  
  150. }  

OrderAction.java的代码和Customer.java代码类似。

 


  1. package com.yaxing.test;  
  2.  
  3. import java.util.Iterator;  
  4. import java.util.List;  
  5.  
  6. import org.hibernate.Query;  
  7. import org.hibernate.Session;  
  8. import org.hibernate.Transaction;  
  9.  
  10. import com.yaxing.entity.Order;  
  11. import com.yaxing.util.HibernateUtil;  
  12.  
  13. public class OrderAction {  
  14.     private Order order;  
  15.     private List<Order> listorder;  
  16.  
  17.     public Order getorder() {  
  18.         return order;  
  19.     }  
  20.  
  21.     public void setorder(Order order) {  
  22.         this.order = order;  
  23.     }  
  24.  
  25.     public List<Order> getListorder() {  
  26.         return listorder;  
  27.     }  
  28.  
  29.     public void setListorder(List<Order> listorder) {  
  30.         this.listorder = listorder;  
  31.     }  
  32.  
  33.     public void addorder(Order order) {  
  34.         Session s = null;  
  35.         Transaction tx = null;  
  36.         try {  
  37.             s = HibernateUtil.getSession();  
  38.             tx = s.beginTransaction();  
  39.             s.save(order);  
  40.             tx.commit();  
  41.         }catch(Exception e){  
  42.             if(tx!=null){  
  43.                 tx.rollback();  
  44.             }  
  45.             e.printStackTrace();  
  46.         }finally{  
  47.             if(s!=null){  
  48.                 s.close();  
  49.             }     
  50.         }  
  51.     }  
  52.     /**  
  53.      * 删除用户  
  54.      * */ 
  55.     public void deleteorder(Order order) {  
  56.         Session s = null;  
  57.         Transaction tx = null;  
  58.         try {  
  59.             s = HibernateUtil.getSession();  
  60.             tx = s.beginTransaction();  
  61.             s.delete(order);  
  62.             tx.commit();  
  63.         }catch(Exception e){  
  64.             if(tx!=null){  
  65.                 tx.rollback();  
  66.             }  
  67.             e.printStackTrace();  
  68.         }finally{  
  69.             if(s!=null){  
  70.                 s.close();  
  71.             }     
  72.         }  
  73.     }  
  74.  
  75.     public void update(Order order,String number) {  
  76.         Session s = null;  
  77.         Transaction tx = null;  
  78.         try {  
  79.             s = HibernateUtil.getSession();  
  80.             tx = s.beginTransaction();  
  81.             order.setOrderNumber(number);  
  82.             s.update(order);  
  83.             tx.commit();  
  84.         }catch(Exception e){  
  85.             if(tx!=null){  
  86.                 tx.rollback();  
  87.             }  
  88.             e.printStackTrace();  
  89.         }finally{  
  90.             if(s!=null){  
  91.                 s.close();  
  92.             }     
  93.         }  
  94.     }  
  95.  
  96.     public Order findorder(Long id) {  
  97.         Session s = null;  
  98.         Transaction tx = null;  
  99.         try {  
  100.             s = HibernateUtil.getSession();  
  101.             tx = s.beginTransaction();  
  102.             order = (Order) s.get(Order.class, id);  
  103.             tx.commit();  
  104.         }catch(Exception e){  
  105.             if(tx!=null){  
  106.                 tx.rollback();  
  107.             }  
  108.             e.printStackTrace();  
  109.         }finally{  
  110.             if(s!=null){  
  111.                 s.close();  
  112.             }     
  113.         }  
  114.         return order;  
  115.     }  
  116.  
  117.     public List<Order> findAll() {  
  118.         Session s = null;  
  119.         Transaction tx = null;  
  120.         try {  
  121.             s = HibernateUtil.getSession();  
  122.             tx = s.beginTransaction();  
  123.             Query query = s.createQuery("from Order as a order by id asc");  
  124.             listorder = query.list();  
  125.             for(Iterator iter=listorder.iterator();iter.hasNext();){  
  126.                 Order order = (Order) iter.next();  
  127.                 System.out.println("订单ID是:"+order.getId()+"订单数目是:"+order.getOrderNumber());  
  128.             }     
  129.             tx.commit();  
  130.         }catch(Exception e){  
  131.             if(tx!=null){  
  132.                 tx.rollback();  
  133.             }  
  134.             e.printStackTrace();  
  135.         }finally{  
  136.             if(s!=null){  
  137.                 s.close();  
  138.             }     
  139.         }  
  140.         return listorder;  
  141.     }  
  142. }  

HibernateUtil.java如下:


  1. package com.yaxing.hibernate.util;  
  2.  
  3. import org.hibernate.Session;  
  4. import org.hibernate.SessionFactory;  
  5. import org.hibernate.cfg.Configuration;  
  6.  
  7. public final class HibernateUtil {  
  8.     private static SessionFactory sessionFactory;  
  9.     private HibernateUtil(){  
  10.           
  11.     }  
  12.     static {  
  13.         Configuration cfg = new Configuration();  
  14.         cfg.configure();  
  15.         sessionFactory=cfg.buildSessionFactory();  
  16.     }  
  17.     public static SessionFactory getSessionFactory() {  
  18.         return sessionFactory;  
  19.     }  
  20.     public static Session getSession(){  
  21.         return sessionFactory.openSession();  
  22.     }  
  23.  
  24. }  

测试代码如下:


  1. package com.yaxing.test;  
  2.  
  3. import com.yaxing.entity.Customer;  
  4.  
  5. public class Test {  
  6.     public  static void main(String args[]){  
  7.         Customer customer = new Customer();  
  8.         customer.setName("51CTO");  
  9.         CustomerAction ca = new CustomerAction();  
  10.         /**  
  11.          * 添加对象  
  12.          * */ 
  13.         ca.addCustomer(customer);  

允许之后,打印出来的SQL语句如下:


  1. Hibernate:   
  2.     insert   
  3.     into 
  4.         Customer  
  5.         (Name)   
  6.     values 
  7.         (?) 

接下来,我们到数据库中看看记录被插入进来了没有:

 

图3

可以看到,如图3所示,记录插入成功!

接下来我们看看查询所有的:

 


  1. /**  
  2.          * 查询所有  
  3.          * */ 
  4.         ca.findAll(); 

输出:


  1. Hibernate:   
  2.     select 
  3.         customer0_.Id as Id1_,  
  4.         customer0_.Name as Name1_   
  5.     from 
  6.         Customer customer0_   
  7.     order by 
  8.         customer0_.Id asc 
  9. 客户ID是:2客户姓名是:null 
  10. 客户ID是:4客户姓名是:51CTO  
  11. 客户ID是:5客户姓名是:51CTO  
  12. 客户ID是:6客户姓名是:51CTO  
  13. 客户ID是:7客户姓名是:51CTO  
  14. 客户ID是:8客户姓名是:51CTO 

接下来,我们删除刚测试的ID为8的记录,


  1. /**  
  2.          * 删除指定对象  
  3.          * */ 
  4.         Customer customer = ca.findCustomer(8L);  
  5.         ca.deleteCustomer(customer); 

运行的SQL语句如下:

 


  1. Hibernate:   
  2.     select 
  3.         customer0_.Id as Id1_0_,  
  4.         customer0_.Name as Name1_0_   
  5.     from 
  6.         Customer customer0_   
  7.     where 
  8.         customer0_.Id=?  
  9. Hibernate:   
  10.     select 
  11.         orders0_.CustomerId as CustomerId1_1_,  
  12.         orders0_.Id as Id1_,  
  13.         orders0_.Id as Id0_0_,  
  14.         orders0_.OrderNumber as OrderNum2_0_0_,  
  15.         orders0_.CustomerId as CustomerId0_0_   
  16.     from 
  17.         Orders orders0_   
  18.     where 
  19.         orders0_.CustomerId=?  
  20. Hibernate:   
  21.     delete   
  22.     from 
  23.         Customer   
  24.     where 
  25.         Id=?  

可以查看下,Id为8的记录删除了!

最后来个级联保存的:

 


  1. /**  
  2.          * 保存订单  
  3.          * 级联保存  
  4.          * */ 
  5.         Customer customer = new Customer();  
  6.         customer.setName("google");  
  7.         ca.addCustomer(customer);  
  8.         Order order = new Order();  
  9.         order.setOrderNumber("5箱");  
  10.         order.setCustomer(customer);  
  11.         oa.addorder(order); 

执行的SQL语句如下:

 


  1. Hibernate:   
  2.     insert   
  3.     into 
  4.         Customer  
  5.         (Name)   
  6.     values 
  7.         (?)  
  8. Hibernate:   
  9.     insert   
  10.     into 
  11.         Orders  
  12.         (OrderNumber, CustomerId)   
  13.     values 
  14.         (?, ?)  
  15. Hibernate:   
  16.     update 
  17.         Customer   
  18.     set 
  19.         Name=?   
  20.     where 
  21.         Id=?  

可以查看下记录:

最后帖上hibernate的配置代码:

 


  1. <?xml version='1.0' encoding='UTF-8'?> 
  2. <!DOCTYPE hibernate-configuration PUBLIC  
  3.           "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
  4.           "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> 
  5.  
  6. <hibernate-configuration> 
  7.     <session-factory> 
  8.         <property name="dialect"> 
  9.             org.hibernate.dialect.SQLServerDialect  
  10.         </property> 
  11.         <property name="connection.url"> 
  12.             jdbc:jtds:sqlserver://server:1434/hibernateTest  
  13.         </property> 
  14.         <property name="connection.username">sa</property> 
  15.         <property name="connection.password">711</property> 
  16.         <property name="connection.driver_class"> 
  17.             net.sourceforge.jtds.jdbc.Driver  
  18.         </property> 
  19.         <property name="hibernate.show_sql">true</property> 
  20.         <property name="format_sql">true</property> 
  21.         <property name="myeclipse.connection.profile">jtds</property> 
  22.         <mapping resource="com/yaxing/entity/Order.hbm.xml" /> 
  23.         <mapping resource="com/yaxing/entity/Customer.hbm.xml" /> 
  24.     </session-factory> 
  25.  
  26. </hibernate-configuration> 

 源代码下载地址:http://down.51cto.com/data/317785



 本文转自 w156445045 51CTO博客,原文链接:http://blog.51cto.com/enetq/759123,如需转载请自行联系原作者


版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Hibernate详细教程
一、搭建Hibernate环境 1.在src目录下创建hibernate.cfg.xml配置文件 PS:文件的名字不能改! root 1234 com.
869 0
Hibernate之多对多表,操作实例
多表操作之多对多关系简介 思路就是: 在数据库底层通过添加中间表来指定关联关系。 在双方的实体中添加一个保存对方的集合 在双方的配置文件中使用set标签和many-to-many标签来进行关联关系的配置。
846 0
浅谈hibernate+入门实例
    Hibernate是对jdbc进一步的封装,随着项目的开展,小编开始接触到这个概念,一开始接触的时候并没有觉得hibernate有多神秘,没有进一步的研究,只是简单的知道她是对jdbc的进一步的封装,可是这并不是学习的目的,到了目前这个学习的...
973 0
Hibernate注解
前言:   最近正在学习Hibernate通过注解(annotation)来管理映射关系,以前都是通过XML映射文件。下面拿个小例子说一下。 数据库物理模型: 数据库的描述:   一篇博客随笔可以分到不同的类中,一个类中又可以包含许多不同的博客随笔。
735 0
Hibernate杂问
1 谈谈你对ORM框架的基本思想的了解?    首先 ORM是 对象关系映射,是为了解决类似于JDBC实现对象持久化的问题开发的。     框架的基本特征:完成面向对象的编程语言到关系数据库之间的映射。
729 0
hibernate 注解
   在配置文件中直接使用如下 &lt;mapping class="com.bjsxt.hibernate.Husband"/&gt;&lt;mapping class="com.bjsxt.hibernate.Wife"/&gt; 在java中要使用如下来过的sessionfactory Configuration cfg = new AnnotationConfigura
1019 0
hibernate一对多
多对一或者一对多 1、单端关联:  指的是持久化类和映射文件的单端关联  和表的结构没有任何关系  可以从一个持久化类访问到另外一个持久化类,但是反之则访问不到 2、双向关联:  可以从一个持久化类访问到另外一个持久化类,但是反之则也可以 说明:单端关联或者双向关联针对的是持久化类和映射文件。   多对一的关系的维护: 1、关系:专指外码    维护外码 在hibernate中,从持久化类中看
1026 0
Hibernate 3入門
原文链接 : http://www.javaworld.com.tw/confluence/pages/viewpage.action?pageId=3077 Hibernate 是「物件/關係對應」(Object/Relational Mapping)的解決方案,簡寫為ORM,簡單的說就是將 Java 中的物件與物件關係,映射至關聯式資料庫中的表格與表格之間的關係, Hibernate 提供了這個過程中自動對應轉換的方案。
778 0
21114
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载