Hibernate3.6应用实例详解-阿里云开发者社区

开发者社区> 技术小胖子> 正文

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,如需转载请自行联系原作者


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

相关文章
使用OpenApi弹性释放和设置云服务器ECS释放
云服务器ECS的一个重要特性就是按需创建资源。您可以在业务高峰期按需弹性的自定义规则进行资源创建,在完成业务计算的时候释放资源。本篇将提供几个Tips帮助您更加容易和自动化的完成云服务器的释放和弹性设置。
7811 0
js之radio应用实例
radio和checkbox还有select,可谓是前后端常用三剑客啊!特别是checkbox和select,关于这两个今天不讲,因为在下面这几篇文章,我已经比较详细的讲解了。 SpringMVC之ajax+select下拉框交互常用方式 checkbox选中并通过ajax传数组到后台接收 关于checkbox自动选中 今天主要讲解的是radio。
969 0
实例应用:自动答卷评分【MATLAB实现】
  一则比较有意思的应用,来自斯坦福 EE368/CS232:Digital Image Processing 课程作业1 【另外,推荐大家去看看老外的课程设计,全是图像处理+android / ios,有题目,有代码,有说明,有海报及视频展示...
915 0
窗口子类化-实例应用
所谓窗口子类化:改变一个已经存在的窗口实例的性质:消息处理与其他实例属性。   通常在SDK中所谓的窗口子类化就是改变一个窗口函数(如GetWindowLong()和SetWindowLong())通过这两个函数来设置窗口的属性等;   而今天我们主要内容是介绍MFC中的子类化,它跟SDK中的子类化不太一样: 所有MFC窗口有相同的窗口函数,由该窗口函数根据窗口句柄查找窗口实例,在把消息映射到该窗口类(class)得消息处理函数上。
951 0
14077
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
文娱运维技术
立即下载
《SaaS模式云原生数据仓库应用场景实践》
立即下载
《看见新力量:二》电子书
立即下载