Java提供了SAX和DOM两种方式用于解析XML,但即便如此,要读写一个稍微复杂的XML,也不是一件容易的事.

　　二、XMLBean简介

　 　Hibernate已经成为目前流行的面向Java环境的对象/关系数据库映射工具.在Hibernate等对象/关系数据库映射工具出现之前,对数据 库的操作是通过JDBC来实现的,对数据库的任何操作,开发人员都要自己写SQL语句来实现. 对象/关系数据库映射工具出现后,对数据库的操作转成对JavaBean的操作,极大方便了数据库开发. 所以如果有一个类似的工具能够实现将对XML的读写转成对JavaBean的操作,将会简化XML的读写,即使对XML不熟悉的开发人员也能方便地读写 XML. 这个工具就是XMLBean.

　　三、准备XMLBean和XML文档

　　XMLBean是Apache的一个开源项目,可以从http://www.apache.org下载,最新的版本是2.0. 解压后目录如下:

xmlbean2.0.0
     +---bin
     +---docs
     +---lib
     +---samples
     +---schemas

　　另外还要准备一个XML文档(customers.xml),

　　在本文的例子里,我们将对这个文档进行读写操作. 文档源码如下:

<?xml version="1.0" encoding="UTF-8"?>
<Customers>
    <customer>
            <id>1</id>
            <gender>female</gender>
            <firstname>Jessica</firstname>
            <lastname>Lim</lastname>
            <phoneNumber>1234567</phoneNumber>
            <address>
                <primaryAddress>
                        <postalCode>350106</postalCode>
                        <addressLine1>#25-1</addressLine1>
                        <addressLine2>SHINSAYAMA 2-CHOME</addressLine2>
                </primaryAddress>
                <billingAddress>
                        <receiver>Ms Danielle</receiver>
                        <postalCode>350107</postalCode>
                        <addressLine1>#167</addressLine1>
                        <addressLine2>NORTH TOWER HARBOUR CITY</addressLine2>
                </billingAddress>
            </address>
    </customer>
    <customer>
            <id>2</id>
            <gender>male</gender>
            <firstname>David</firstname>
            <lastname>Bill</lastname>
            <phoneNumber>808182</phoneNumber>
            <address>
                <primaryAddress>
                        <postalCode>319087</postalCode>
                        <addressLine1>1033 WS St.</addressLine1>
                        <addressLine2>Tima Road</addressLine2>
                </primaryAddress>
                <billingAddress>
                        <receiver>Mr William</receiver>
                        <postalCode>672993</postalCode>
                        <addressLine1>1033 WS St.</addressLine1>
                        <addressLine2>Tima Road</addressLine2>
                </billingAddress>
            </address>
    </customer>
</Customers>

　 　这是一个客户的数据模型,每个客户都有客户编号(ID),姓名,性别(gender),电话号码(phoneNumber)和地址,其中地址有两个: 首要地址(PrimaryAddress)和帐单地址(BillingAddress),每个地址有邮编,地址1,和地址2组成.其中帐单地址还有收件人 (receiver).此外,还要准备一个配置文件(文件名customer.xsdconfig),这个文件的作用我后面会讲,它的内容如下:

<xb:config xmlns:xb="http://xml.apache.org/xmlbeans/2004/02/xbean/config">

  <xb:namespace>
    <xb:package>sample.xmlbean</xb:package>
  </xb:namespace>

</xb:config>

　　四、XMLBean使用步骤

　　和其他面向Java环境的对象/关系数据库映射工具的使用步骤一样,在正式使用XMLBean前,我们要作两个准备.

　　1. 生成XML Schema文件

　 　什么是XML Schema文件? 正常情况下,每个XML文件都有一个Schema文件,XML Schema文件是一个XML的约束文件,它定义了XML文件的结构和元素.以及对元素和结构的约束. 通俗地讲,如果说XML文件是数据库里的记录,那么Schema就是表结构定义.

　　为什么需要这个文件? XMLBean需要通过这个文件知道一个XML文件的结构以及约束,比如数据类型等. 利用这个Schema文件,XMLBean将会产生一系列相关的Java Classes来实现对XML的操作. 而作为开发人员,则是利用XMLBean产生的Java Classes来完成对XML的操作而不需要SAX或DOM.怎样产生这个Schema文件呢? 如果对于熟悉XML的开发人员,可以自己来写这个Schema文件,对于不熟悉XML的开发人员,可以通过一些工具来完成.比较有名的如XMLSPY和 Stylus Studio都可以通过XML文件来生成Schema文件. 加入我们已经生成这个Schema文件(customer.xsd):

       <?xml version="1.0" encoding="UTF-8"?>
       <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
                  elementFormDefault="qualified">
         <xs:element name="Customers">
           <xs:complexType>
             <xs:sequence>
               <xs:element maxOccurs="unbounded" name="customer"
                           type="customerType"/>
             </xs:sequence>
           </xs:complexType>
         </xs:element>
       <xs:complexType name="customerType">
             <xs:sequence>
               <xs:element name="id" type="xs:int"/>
               <xs:element name="gender" type="xs:string"/>
               <xs:element name="firstname" type="xs:string"/>
               <xs:element name="lastname" type="xs:string"/>
               <xs:element name="phoneNumber" type="xs:string"/>
               <xs:element name="address" type="addressType"/>
             </xs:sequence>
       </xs:complexType>
         <xs:complexType name="addressType">
             <xs:sequence>
               <xs:element name="primaryAddress" type="primaryAddressType"/>
               <xs:element name="billingAddress" type="billingAddressType"/>
             </xs:sequence>
         </xs:complexType>

         <xs:complexType name="primaryAddressType">
             <xs:sequence>
               <xs:element name="postalCode" type="xs:string"/>
               <xs:element name="addressLine1" type="xs:string"/>
               <xs:element name="addressLine2" type="xs:string"/>
             </xs:sequence>
         </xs:complexType>
         <xs:complexType name="billingAddressType">
             <xs:sequence>
                   <xs:element name="receiver" type="xs:string"/>
               <xs:element name="postalCode" type="xs:string"/>
               <xs:element name="addressLine1" type="xs:string"/>
               <xs:element name="addressLine2" type="xs:string"/>
             </xs:sequence>
         </xs:complexType>
       </xs:schema>

　　2. 利用scomp来生成Java Classes

　　scomp是XMLBean提供的一个编译工具,它在bin的目录下. 通过这个工具,我们可以将以上的Schema文件生成Java Classes.scomp的语法如下:-

　　scomp [options] [dirs]* [schemaFile.xsd]* [service.wsdl]* [config.xsdconfig]*

　　主要参数说明:

　　-src [dir] -- 生成的Java Classes存放目录

　　-srconly -- 不编译Java Classes,不产生Jar文件

　　-out [jarFileName] -- 生成的Jar文件,缺省是xmltypes.jar

　　-compiler -- Java编译器的路径,即Javac的位置

　　schemaFile.xsd -- XML Schema文件位置

　　config.xsdconfig -- xsdconfig文件的位置, 这个文件主要用来制定生成的Java Class的一些文件名规则和Package的名称,在本文,package是sample.xmlbean

　　在本文,我是这样运行的:

      scomp -src build\src  -out build\customerXmlBean.jar schema\customer.xsd
             -compiler C:\jdk142_04\bin\javac customer.xsdconfig

　 　这个命令行的意思是告诉scomp生成customerXmlBean.jar,放在build目录下,同时生成源代码放在build\src下, Schema文件是customer.xsd,xsdconfig文件是customer.xsdconfig.其实, 生成的Java源代码没有多大作用,我们要的是jar文件.我们先看一下build\src\sample\xmlbean下生成的Classes.

　　CustomersDocument.java -- 整个XML文档的Java Class映射

　　CustomerType.java -- 节点sustomer的映射

　　AddressType.java -- 节点address的映射

　　BillingAddressType.java -- 节点billingAddress的映射

　　PrimaryAddressType.java -- 节点primaryAddress的映射

　　好了,到此我们所有的准备工作已经完成了. 下面就开始进入重点:利用刚才生成的jar文件读写XML.

　　五、利用XMLBean读XML文件

　　新建一个Java Project,将XMLBean2.0.0\lib\下的Jar文件和刚才我们生成的customerXmlBean.jar加入到Project的ClassPath.

　　新建一个Java Class: CustomerXMLBean. 源码如下:

    package com.sample.reader;

    import java.io.File;
   
    import sample.xmlbean.*;
    import org.apache.commons.beanutils.BeanUtils;
    import org.apache.xmlbeans.XmlOptions;
    public class CustomerXMLBean {
    private String filename = null;
   
    public CustomerXMLBean(String filename) {
            super();
            this.filename = filename;
    }

    public void customerReader() {
            try {
              File xmlFile = new File(filename);
              CustomersDocument doc = CustomersDocument.Factory.parse(xmlFile);
              CustomerType[] customers = doc.getCustomers().getCustomerArray();
         
              for (int i = 0; i < customers.length; i++) {
                CustomerType customer = customers[i];
                println("Customer#" + i);
                println("Customer ID:" + customer.getId());
                println("First name:" + customer.getFirstname());
                println("Last name:" + customer.getLastname());
                println("Gender:" + customer.getGender());
                println("PhoneNumber:" + customer.getPhoneNumber());
                // Primary address
                PrimaryAddressType primaryAddress = customer.getAddress().getPrimaryAddress();
                println("PrimaryAddress:");
                println("PostalCode:" + primaryAddress.getPostalCode());
                println("AddressLine1:" + primaryAddress.getAddressLine1());
                println("AddressLine2:" + primaryAddress.getAddressLine2());
                // Billing address
                BillingAddressType billingAddress = customer.getAddress().getBillingAddress();
                println("BillingAddress:");
                println("Receiver:" + billingAddress.getReceiver());
                println("PostalCode:" + billingAddress.getPostalCode());
                println("AddressLine1:" + billingAddress.getAddressLine1());
                println("AddressLine2:" + billingAddress.getAddressLine2());
           
              }
            } catch (Exception ex) {
                    ex.printStackTrace();
            }
    }
    private void println(String str) {
          System.out.println(str);
    }
   public static void main(String[] args) {
      String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers.xml";
                  
     CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);
                   customerXMLBean.customerReader();
    }

    }

　　运行它,参看输出结果:

       Customer#0
       Customer ID:1
       First name:Jessica
       Last name:Lim
       Gender:female
       PhoneNumber:1234567
       PrimaryAddress:
       PostalCode:350106
       AddressLine1:#25-1
       AddressLine2:SHINSAYAMA 2-CHOME
       BillingAddress:
       Receiver:Ms Danielle
       PostalCode:350107
       AddressLine1:#167
       AddressLine2:NORTH TOWER HARBOUR CITY

       Customer#1
       Customer ID:2
       First name:David
       Last name:Bill
       Gender:male
       PhoneNumber:808182
       PrimaryAddress:
       PostalCode:319087
       AddressLine1:1033 WS St.
       AddressLine2:Tima Road
       BillingAddress:
       Receiver:Mr William
       PostalCode:672993
       AddressLine1:1033 WS St.
       AddressLine2:Tima Road

　　怎么样,是不是很轻松? XMLBean的威力.

　　六、利用XMLBean写XML文件

　　利用XMLBean创建一个XML文档也是一件轻而易举的事.我们再增加一个Method,

　　请看一下的Java Class:

    public void createCustomer() {
    try {
        // Create Document
        CustomersDocument doc = CustomersDocument.Factory.newInstance();
        // Add new customer
        CustomerType customer = doc.addNewCustomers().addNewCustomer();
        // set customer info
        customer.setId(3);
        customer.setFirstname("Jessica");
        customer.setLastname("Lim");
        customer.setGender("female");
        customer.setPhoneNumber("1234567");
        // Add new address
        AddressType address = customer.addNewAddress();
        // Add new PrimaryAddress
        PrimaryAddressType primaryAddress = address.addNewPrimaryAddress();
        primaryAddress.setPostalCode("350106");
        primaryAddress.setAddressLine1("#25-1");
        primaryAddress.setAddressLine2("SHINSAYAMA 2-CHOME");

        // Add new BillingAddress
        BillingAddressType billingAddress = address.addNewBillingAddress();
        billingAddress.setReceiver("Ms Danielle");
        billingAddress.setPostalCode("350107");
        billingAddress.setAddressLine1("#167");
        billingAddress.setAddressLine2("NORTH TOWER HARBOUR CITY");

        File xmlFile = new File(filename);
        doc.save(xmlFile);
        } catch (Exception ex) {
                ex.printStackTrace();
        }

  }

　　修改main method.

    public static void main(String[] args) {
    String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers_new.xml";
        CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);
        customerXMLBean.createCustomer();
    }

　　运行,打开customers_new.xml:

    <?xml version="1.0" encoding="UTF-8"?>
    <Customers>
    <customer>
            <id>3</id>
            <gender>female</gender>
            <firstname>Jessica</firstname>
            <lastname>Lim</lastname>
            <phoneNumber>1234567</phoneNumber>
            <address>
                    <primaryAddress>
                         <postalCode>350106</postalCode>
                         <addressLine1>#25-1</addressLine1>
                                       <addressLine2>SHINSAYAMA 2-CHOME</addressLine2>
                    </primaryAddress>
                    <billingAddress>
                        <receiver>Ms Danielle</receiver>
                        <postalCode>350107</postalCode>
                       <addressLine1>#167</addressLine1>
                       <addressLine2>NORTH TOWER HARBOUR CITY</addressLine2>
                    </billingAddress>
                    </address>
            </customer>
    </Customers>

　　七、利用XMLBean修改XML文件

　　我们再增加一个Method:

      public void updateCustomer(int id,String lastname) {
         try {
        File xmlFile = new File(filename);
        CustomersDocument doc = CustomersDocument.Factory.parse(xmlFile);
        CustomerType[] customers = doc.getCustomers().getCustomerArray();
     
        for (int i = 0; i < customers.length; i++) {
           CustomerType customer = customers[i];
          if(customer.getId()==id){
                customer.setLastname(lastname);
                break;
            }
        }
        doc.save(xmlFile);
         } catch (Exception ex) {
          ex.printStackTrace();
         }
           }

　　main method:

    public static void main(String[] args) {
     String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers_new.xml";
                   
    CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);
                   
    customerXMLBean.updateCustomer(3,"last");
    }

　　运行之后,我们将会看到客户编号为3的客户的lastname已经改为last.

　　八、利用XMLBean删除一个customer

　　再增加一个Method:

    public void deleteCustomer(int id) {
     try {
      File xmlFile = new File(filename);
     CustomersDocument doc = CustomersDocument.Factory.parse(xmlFile);
    CustomerType[] customers = doc.getCustomers().getCustomerArray();

   for (int i = 0; i < customers.length; i++) {
        CustomerType customer = customers[i];
        if(customer.getId()==id){
                        customer.setNil() ;
                        break;
               }
   }
   doc.save(xmlFile);
   } catch (Exception ex) {
        ex.printStackTrace();
        }
   }

　　main method:

    public static void main(String[] args) {
    String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers_new.xml";
                   
    CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);
                   
    customerXMLBean.deleteCustomer(3);
    }

　　运行,我们将会看到客户编号为3的客户的资料已经被删除.

　　九、查询XML

　　除了本文在以上讲述的,利用XMLBean能轻轻松松完成XML的读写操作外,结合XPath和XQuery,XMLBean还能完成象SQL查询数据库一样方便地查询XML数据. 关于XML查询以及如何创建XML数据库, 我将在另一篇文章里讨论.

　　十、结束语

　　XMLBean能帮助我们轻易读写XML,这将有助于我们降低XML的学习和使用,有了这个基础,开发人员将为学习更多地XML相关技术和Web Services,JMS等其他J2EE技术打下良好地基础.

先从RetentionPolicy这个开始把，RetentionPolicy是一个枚举，他是对于编译器的一个声明。
然而Annotations在编译的过程会中记录到类文件。
RetentionPolicy的枚举成员一共有三个
SOURCE 编译器要丢弃的注释。
CLASS 编译器将把注释记录在类文件中，但在运行时 VM 不需要保留注释。
RUNTIME 编译器将把注释记录在类文件中，在运行时 VM 将保留注释，因此可以反射性地读取。(激发注解在运行时生效)
－－－－在这里注意一下java.lang.reflect.AnnotatedElement这个接口主要定义了获得注解和判断注解是否描述了某个java元素。

在说一下这两个
Retention，Target （jdk提供的注解）

示例
Target 源码：
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    ElementType[] value();
}

说明：
      1.自己可以描述自己，ElementType 描述声明类型（该注解可以用于哪些元素上边）。
      2.这个注解是用来描述自己定义的元数据，也应该叫做元注解，然而我们定义的元数据通常是为类或者方法而声明的。
      3.@Retention(RetentionPolicy.RUNTIME )用来保证在java运行时运行注解。

其实注解就是变向的简化java的反射以及把spring等容器ioc和aop的相关概念从往常的xml作为元数据提了一个高度声明至类中，摒弃掉了项目 扩大时冗长的xml的配置。

一般通过类或者方法的反射调用注解的方式如下
            for (Method m : Class.forName(className).getMethods()) {
               if (m.isAnnotationPresent(MyAnnotation.class)) {
                  try {
                     m.invoke(null);//根据方法有无参数设置是否为null
                  } catch (Throwable ex) {
                     System.out.printf("失败");
                  }
               }

概念上应注意的几点：
1.在Annotation中，没有默认值的成员必须有一个成员值。而如何理解默认值是如何被处理就是一个很重要的细节：annotation类型所定义的

成员默认值被存储在class文件中，不被编译到annotation里面。如果我们修改一个annotation类型使其成员的默认值发生了改变，这个改变对 于所有此类型的annotation中没有明确提供成员值的成员产生影响（即修改了该成员的成员值）。即使在annotation类型使其成员的默认值被 改变后annotation从没被重新编译过，该类型的annotation(改变前已经被编译的)也受到影响。

这篇基本先写到这里，java元数据其实是很大的一块，我只是粗略的看了一下基本的概念，用来学习ejb作一个铺垫。关于annotation的详情介 绍可以阅读参考文献中的两篇文章。在下一章中我要介绍一下ejb中常用的annotation。

参考文献：
   jdk源码
   Java Annotation入门 http://www.matrix.org.cn/resource/article/44/44048_Java+Annotation.html
   Java Annotation手册 http://www.matrix.org.cn/resource/article/44/44055_Java+Annotation+Reflect.html

    在使用Hibernate的应用中, Spring的对DAO对象通常的事务管理特别应该引起关注。它的目的就是分离数据访问和事务处理，使事务性业务对象不与任何特殊的数据访问或者事务策略绑在一起，从而不影响业务对象的可复用性。这种划分既可以经由事务模板（TransactionTemplate）用编程的方式实现，也可以经由面向方面（AOP）事务拦截器（TransactionTemplate）用声明的方式实现。无论是本地的Hibernate / JDBC事务，还是JTA事务都支持对象外的事务策略，这对于本地的无状态会话Bean（Stateless Session Beans）是一个非常有用的选择。

    Spring的HibernateTemplate类提供了一个简单的方式实现了Hibernate-based DAO对象而不必关心如何获得Hibernate的Session实例，也不必关心多方参与的事务处理。无需使用try-catch块，也无需进行事务检查。一个简单的Hibernate访问方法就完全解决了些麻烦! 无论是在多个DAO接口还是在多方事务的情况下，Spring使得多种DAO对象无缝地协同工作。例如：某些DAO对象可能是基于plain JDBC的实现，更适合于经由Spring的JdbcTemplate来避免手动的异常处理。

      你可以单独地使用许多Spring特性，因为Spring的所有对象都是设计成可复用的JavaBean对象的集合。也不要因为Spring可以提供一个完整的应该框架而气馁！使用其他的Spring特性时，应用配置概念是一个附加的特性，并不是一个必须的特性。无论如何，当你要决定去构建一个象Spring这样的内在的基础架构的时候，在使用Spring的路途上没有什么范围上的限制。

1. 介绍: 资源管理

       典型的业务应用系统常常由于重复的资源管理代码而导致混乱。许多项目试着用自己的方法来解决这个问题，有时要为此付出失败的代价，Spring针对适当的资源管理提倡了一种引人注目的简单方法：即经由模板来倒置控制（Inversion of control），例如：基础类使用回调接口，或者应用AOP拦截器。其基础核心是适当的资源处理和将特殊的API异常转换为一个unchecked的基础异常。

       Spring引入了一个DAO异常层适用于任何数据访问策略。对于直接的JDBC，JdbcTemplate类关注于连接处理，并且关注于对SQLException转换为适当的DataAccessException，包括对特殊的数据库SQL错误转换为有意义的异常。 经由不同的事务管理对象，Spring支持JTA和JDBC事务。Spring 也提供对Hibernate和JDO的支持，它的这种支持由与JdbcTemplate类的作用相类似的HibernateTemplate类和JdoTemplate类, 以及HibernateInterceptor类、JdoInterceptor类，还有Hibernate、JDO 事务管理类组成。

       最主要的目的是要使应用的层次分明，为此将数据访问和事务处理同应用对象分离开来。所有的业务对象都不再依赖数据访问或者事务策略。不再有硬编码的资源查找代码，不再有难以替换的单例对象，也不再需要定制服务注册。

      所有的单独的数据访问特性均无需依赖于Spring，可以单独使用，无需让Spring知道，同时也可以通过Spring的应用配置（提供基于XML的配置和对普通JavaBean实例的交叉引用）来进行装配。在一个典型的Spring应用中，大部分重要的对象都是普通的JavaBean：数据访问模板对象（data access templates）、数据访问对象（使用数据访问模板对象的对象）、事务管理对象及业务对象（使用数据访问对象和事务对象的对象），web表示分解对象、web控制对象（使用业务对象的对象）等等。

2. 应用配置中的资源定义

    为了避免应用对象将资源查找的代码硬编码，Spring允许在应用配置中将一个如JDBC DataSource或者Hibernate SessionFactory定义为一个Bean。应用对象如果需要访问资源只需要通过Bean引用（DAO定义在下一部分说明）接受先前定义的实例的引用。以下的内容引用自一个应用配置定义，显示了如何建立一个JDBC DataSource和一个Hibernate的SessionFactory：

      注意选择是用JNDI来定位数据源还是从一个象Jakarta Commons DBCP BasicDataSource这样的本地定义取得一个数据源，只是一个改变配置的事：

       你也可以使用一个JNDI查找SessionFactory，但是通常对于EJB环境之外的应用来说并不是需要的（参考"container resources vs local resources"部分的讨论）。

3. 倒置控制（Inversion of Control）: 模板和回调

    模板的基本编程模式就象你将在下面看到那样，至于方法就如同任何定制的数据访问对象或者业务的对象的方法一样。除了需要向其提供一个Hibernate的SessionFactory之外，再没有对周围执行对象的信赖的限制。虽然最好是从一个Spring的应用配置中经由一个简单setSessionFactory bean的属性设置使用Bean引用来获得它，但随后你可以从任何地方获得它。随后的引用片段包括一段在Spring应用配置中对DAO定义的配置，其中引用了在其前面定义的SessionFactory，和一段DAO方法的实现的例子。

												<beans>

<bean id="myProductDao" class="product.ProductDaoImpl">
<property name="sessionFactory">
<ref bean="mySessionFactory"/>
</property>
</bean>

...

</beans>
										

												
														public class ProductDaoImpl implements ProductDao {

private SessionFactory sessionFactory;

public void setSessionFactory(SessionFactory 
												
												
														   sessionFactory) {
this.sessionFactory = sessionFactory;
}

public List loadProductsByCategory(final String 
												
												
														  category) {
HibernateTemplate hibernateTemplate =
new HibernateTemplate(this.sessionFactory);

return (List) hibernateTemplate.execute(
new HibernateCallback() {
public Object doInHibernate(Session session) throws
												
												
														 HibernateException {
List result = session.find(
"from test.Product product where product.category=?",
category, Hibernate.STRING);
// do some further stuff with the result list
return result;
}
}
);
}
}
												
										

       一个回调的实现可以被有效地用在任何Hibernate数据访问中。在任何情况下都由HibernateTemplate来管理Session的开闭和自动的多方事务。模板实例是线程安全和可重用的，因此它们可以做为其他类的变量。

       对于简单的单步的动作，象find, load, saveOrUpdate或者delete的调用，HibernateTemplate提供更为便利的选择以代替象一行的回调的执行。此外，Spring提供了一个方便的基本类，就是HibernateDaoSupport类，它提供了setSessionFactory方法来接受一个SessionFactory，同时提供了getSessionFactory和getHibernateTemplate方法供其继承类使用。将这些结合起来，允许对于典型的需求给出了非常简单的DAO实现：

												
														
																public class ProductDaoImpl extends HibernateDaoSupport implements
														
														
																 ProductDao {

public List loadProductsByCategory(String category) {
return getHibernateTemplate().find(
"from test.Product product where product.category=?", category,
Hibernate.STRING);
}
}
														
												
										

4. 应用一个AOP拦截器代替一个模板

   除使用HibernateTemplate之外的另一个选择就是使用Spring的AOP HibernateInterceptor。用直接在一个委托的try/catch块中编写Hibernate代码，配合相应的在应用配置中分别的拦截器配置来代替执行回调。下面的片段显示了一个Spring应用配置中的DAO, interceptor和proxy的各自的定义，同时给出了一个DAO方法实现的例子：

												
														
																
																		<beans>

...

<bean id="myHibernateInterceptor"
      class="org.springframework.orm.hibernate
																
																
																		.HibernateInterceptor">
<property name="sessionFactory">
<ref bean="mySessionFactory"/>
</property>
</bean>

<bean id="myProductDaoTarget" class="product.ProductDaoImpl">
<property name="sessionFactory">
<ref bean="mySessionFactory"/>
</property>
</bean>

<bean id="myProductDao" class="org.springframework.aop
																
																
																		.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>product.ProductDao</value>
</property>
<property name="interceptorNames">
<list>
<value>myHibernateInterceptor</value>
<value>myProductDaoTarget</value>
</list>
</property>
</bean>

...

</beans>
																
														
												
										

												
														
																 
																
																		public class ProductDaoImpl extends HibernateDaoSupport 
																
																
																		   implements ProductDao {

public List loadProductsByCategory(final String category)
																
																
																		 throws MyException {
Session session = SessionFactoryUtils
																
																
																		.getSession(getSessionFactory(), false);
try {
List result = session.find(
"from test.Product product where product.category=?",
category, Hibernate.STRING);
if (result == null) {
throw new MyException("invalid search result");
}
return result;
}
catch (HibernateException ex) {
throw SessionFactoryUtils.convertHibernateAccessException(ex);
}
}
}

																
														
												
										

        这个方法将只在有一个与它配合的HibernateInterceptor时才能正常工作，HibernateInterceptor为它负责在方法调用前线程绑定Session的开启和方法调用后的关闭。getSession方法调用中的"false"标志是要确认Session必须是已经存在的，如果没有发现任何一个Session，SessionFactoryUtils将会为其创建一个。如果已经有一个Session句柄绑定在本线程上，比如是由一个HibernateTransactionManager事务绑定的，在任何情况下SessionFactoryUtils会自动接入这个Session。HibernateTemplate在底层也使用SessionFactoryUtils，与以上说的方式基本是一样的。

       HibernateInterceptor的主要益处是它允许在数据访问代码中抛出checked application exception，而HibernateTemplate由于受限于回调只能在其中抛出unchecked exceptions。注意到这点我们可以推迟各自的检验，同时在回调后抛出应用异常。拦截方式的主要缺点是它需要在配置中进行特殊的配置。HibernateTemplate在大多数情况下都是一种简单好用的方法。

5. 程序事务划分

   在这种底层的数据访问服务之上，事务处理可以在更高的应用层被划分 ，形成一些操作。这里除了需要一个Spring的PlatformTransactionManager对象外，对于周围运行的业务对象也没有任何限制。同样的，其后你可以从任何地方获得它们，但是经由Bean引用的方式通过setTransactionManage方法获得更为适合，象productDAO要经由一个setProductDao方法获得一样。下面的引用片段显示了在一个Spring应用配置中的事务管理对象和业务对象的定义，并且还提供了一个业务方法实现的例子：

												
														
																
																		<beans>

...

<bean id="myTransactionManager"
      class="org.springframework.orm.hibernate
																
																
																		.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="mySessionFactory"/>
</property>
</bean>

<bean id="myProductService" class="product.ProductServiceImpl">
<property name="transactionManager">
<ref bean="myTransactionManager"/>
</property>
<property name="productDao">
<ref bean="myProductDao"/>
</property>
</bean>

</beans>
																
														
												
										

												
														
																 
																
																		public class ProductServiceImpl implements ProductService {

private PlatformTransactionManager transactionManager;
private ProductDao productDao;

public void setTransactionManager(PlatformTransactionManager 
																
																
																		  transactionManager) {
this.transactionManager = transactionManager;
}

public void setProductDao(ProductDao productDao) {
this.productDao = productDao;
}

public void increasePriceOfAllProductsInCategory(final String 
																
																
																		  category) {
TransactionTemplate transactionTemplate =
new TransactionTemplate(this.transactionManager);
transactionTemplate.setPropagationBehavior(TransactionDefinition
																
																
																		    .PROPAGATION_REQUIRED);
transactionTemplate.execute(
new TransactionCallbackWithoutResult() {
public void doInTransactionWithoutResult(TransactionStatus 
																
																
																		  status) {
List productsToChange = productDAO.loadProductsByCategory(category);
...
}
}
);
}
}
																
														
												
										

6. 声明性事务划分

       我们还可以选择使用Spring的AOP TransactionInterceptor通过在应用配置中定义拦截器配置来代替事务划分代码的事务处理方式。这允许我们保持业务对象独立于每个业务对象中重复的事务划分代码。此外，事务行为和隔离层次的变化可以通过一个配置文件来改变而不需要对业务对象的实现造成影响。

												
														<beans>

...

<bean id="myTransactionManager"
      class="org.springframework.orm.hibernate
												
												
														.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="mySessionFactory"/>
</property>
</bean>

<bean id="myTransactionInterceptor"
      class="org.springframework.transaction
												
												
														.interceptor.TransactionInterceptor">
<property name="transactionManager">
<ref bean="myTransactionManager"/>
</property>
<property name="transactionAttributeSource">
<value>
product.ProductService.increasePrice*=PROPAGATION_REQUIRED
product.ProductService.someOtherBusinessMethod=
												
												
														PROPAGATION_MANDATORY
</value>
</property>
</bean>

<bean id="myProductServiceTarget" class="product
												
												
														.ProductServiceImpl">
<property name="productDao">
<ref bean="myProductDao"/>
</property>
</bean>

<bean id="myProductService" class="org.springframework.aop
												
												
														.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>product.ProductService</value>
</property>
<property name="interceptorNames">
<list>
<value>myTransactionInterceptor</value>
<value>myProductServiceTarget</value>
</list>
</property>
</bean>

</beans>
												
										

												 
												
														public class ProductServiceImpl implements ProductService {

private ProductDao productDao;

public void setProductDao(ProductDao productDao) {
this.productDao = productDao;
}

public void increasePriceOfAllProductsInCategory(final String
												
												
														 category) {
List productsToChange = this.productDAO
												
												
														.loadProductsByCategory(category);
...
}
}
												
										

      如同使用HibernateInterceptor一样，TransactionInterceptor允许任何checked application exception从回调代码中抛出，而TransactionTemplate受回调限制在其内部抛出unchecked exceptions，在出现一个unchecked application exception的情况时，TransactionTemplate将引发一个回滚或者这个事务由应用（通过事务状态）标记为回滚。TransactionInterceptor默认情况也是同样的行为，但是允许为每一个方法制定回滚策略。
       建立声明性事务的一个便利的方式是使用TransactionProxyFactoryBean，特别是如果没有其他AOP拦截器的话，TransactionProxyFactoryBean将联合定义为代理的自身与一个特殊的目标Bean的事务配置。这将减少一个代理Bean对应一个目标Bean的配置情况。此外，你不必指定哪个接口或者哪个类必须定义事务方法。

												
														
																
																		<beans>

...

<bean id="myTransactionManager"
      class="org.springframework.orm.hibernate
																
																
																		.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="mySessionFactory"/>
</property>
</bean>

<bean id="myProductServiceTarget" class="product
																
																
																		.ProductServiceImpl">
<property name="productDao">
<ref bean="myProductDao"/>
</property>
</bean>

<bean id="myProductService"
      class="org.springframework.transaction.interceptor
																
																
																		.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref bean="myTransactionManager"/>
</property>
<property name="target">
<ref bean="myProductServiceTarget"/>
</property>
<property name="transactionAttributes">
<props>
<prop key="increasePrice*">PROPAGATION_REQUIRED</prop>
<prop key="someOtherBusinessMethod">PROPAGATION_MANDATORY</prop>
</props>
</property>
</bean>

</beans>

																
														
												
										

7. 事务管理策略

          对于Hibernate应用来说，无论是TransactionTemplate还是TransactionInterceptor都是委托验实际的事务处理给PlatformTransactionManager实例，可以是一个HibernateTransactionManager（由一个单一的Hibernate的SessionFactory，使用一个ThreadLocal Session）或者可以是一个JtaTransactionManager（代理容器的JTA子系统）。甚至你可以使用一个自定义的PlatformTransactionManager实现。
       如果选择从本地Hibernate事务管理转为由JTA来进行事务管理，例如：当你的应用的部署面对分布的事务需求时，也仅仅是改变一下配置的事。只要简单地将Hibernate的事务管理换为JTA事务实现即可。所有的事务划分和数据访问无需做任何变动仍可以继续工作，因为他们使用的都是普通的事务管理API。
       对于分布式的事务会跨越多个Hibernate的session factories，仅仅是联合JtaTransactionManager与多个LocalSessionFactoryBean定义作为事务策略。你的每一个DAO将通过它们各自的Bean属性得到一个特殊的SessionFactory的引用。如果这一切都是在下面的JDBC数据源是事务容器，一个业务对象可以划分事务跨越很多DAO和很多session factories而无需做特别的处理，对于使用JtaTransactionManager做为事务策略也是一样的。

												
														
																 
																
																		<beans>

<bean id="myDataSource1" class="org.springframework.jndi
																
																
																		.JndiObjectFactoryBean">
<property name="jndiName">
<value>jdbc/myds1</value>
</property>
</bean>

<bean id="myDataSource2" class="org.springframework.jndi.
																
																
																		JndiObjectFactoryBean">
<property name="jndiName">
<value>jdbc/myds2</value>
</property>
</bean>

<bean id="mySessionFactory1"
      class="org.springframework.orm.hibernate.
																
																
																		LocalSessionFactoryBean">
<property name="mappingResources">
<list>
<value>product.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">net.sf.hibernate.dialect.
																
																
																		MySQLDialect</prop>
</props>
</property>
<property name="dataSource">
<ref bean="myDataSource1"/>
</property>
</bean>

<bean id="mySessionFactory2"
      class="org.springframework.orm.hibernate.
																
																
																		LocalSessionFactoryBean">
<property name="mappingResources">
<list>
<value>inventory.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">net.sf.hibernate.
																
																
																		dialect.OracleDialect</prop>
</props>
</property>
<property name="dataSource">
<ref bean="myDataSource2"/>
</property>
</bean>

<bean id="myTransactionManager"
      class="org.springframework.transaction.jta.
																
																
																		JtaTransactionManager"/>

<bean id="myProductDao" class="product.ProductDaoImpl">
<property name="sessionFactory">
<ref bean="mySessionFactory1"/>
</property>
</bean>

<bean id="myInventoryDao" class="product.InventoryDaoImpl">
<property name="sessionFactory">
<ref bean="mySessionFactory2"/>
</property>
</bean>

<bean id="myProductServiceTarget" class="product.
																
																
																		ProductServiceImpl">
<property name="productDao">
<ref bean="myProductDao"/>
</property>
<property name="inventoryDao">
<ref bean="myInventoryDao"/>
</property>
</bean>

<bean id="myProductService"
      class="org.springframework.transaction.interceptor.
																
																
																		TransactionProxyFactoryBean">
<property name="transactionManager">
<ref bean="myTransactionManager"/>
</property>
<property name="target">
<ref bean="myProductServiceTarget"/>
</property>
<property name="transactionAttributes">
<props>
<prop key="increasePrice*">PROPAGATION_REQUIRED</prop>
<prop key="someOtherBusinessMethod">PROPAGATION_MANDATORY</prop>
</props>
</property>
</bean>

</beans>
																
														
												
										

       无论是HibernateTransactionManager还是JtaTransactionManager允许适当的对Hibernate的在JVM层次的缓存处理-不需要容器-提供特殊的事务查找或者JCA连接器（只要不使用EJB发起事务）。另外，HibernateTransactionManager能输出JDBC连接供通常的JDBC访问代码使用。这样就允许在高层次上的事务划分是混合了Hibernate与JDBC而不要JTA的，只要只是访问一个数据库就可以！

8. 使用Spring管理应用的Bean

        一个Spring应用配置定义可以被多种配置实现所加载，从FileSystemXmlApplicationContext和ClassPathXmlApplicationContext到XmlWebApplicationContext。这就允许在各种环境下重用Spring管理的数据访问和业务对象。默认情况下，一个Web应用将有它自己的定义在“WEB-INF/applicationContext.xml”中的根配置。
       在任何一个Spring应用中，一个应用配置定义在一个XML格式的文件中用来对应用的所有有关的Bean进行装配，从Hibernate的session factory到自定义的数据访问和业务对象（象上面所有的Bean那样）。他们中的大多数不需要Spring容器知道他们，甚至即使是与其他Bean合作时也一样，因为他们只是简单的JavaBean之间的协作。下面的Bean定义可能是一个Spring Web 的MVC配置中用来访问业务对象的配置的一部分。

												 
												
														
																<bean id="myProductList" class="product.ProductListController">
<property name="productService">
<ref bean="myProductService"/>
</property>
</bean>
														
												
										

      Spring的Web控制器经由Bean引用拥有它们需要的所有的业务和数据访问对象，因此它们无需在应用配置中做任何手工的Bean查找。但是当使用Spring管理的Beans用于Struts或者是在EJB实现，或者一个applet中时常常是需要必须手工查找一个Bean的。因此Spring的Bean可以被用在任何地方。也许只是需要是一应用配置的引用，或者经由一个web容器的Servlet配置属性，或者从一个文件中或者类路径的资源中创建它。

												
														ApplicationContext context =WebApplicationContextUtils.
												
												
														getWebApplicationContext(servletContext);
ProductService productService =
(ProductService) context.getBean("myProductService");
												
										

												 ApplicationContext context =
new FileSystemXmlApplicationContext("C:/myContext.xml");
ProductService productService =
(ProductService) context.getBean("myProductService");

										

												 ApplicationContext context =
new ClassPathXmlApplicationContext("myContext.xml");
ProductService productService =
(ProductService) context.getBean("myProductService");
										

9. 容器资源VS本地资源

       Spring的资源管理允许简单地在一个JNDI SessionFactory和一个本地SessionFactory间做选择，同样允许在一个JNDI DataSource与本地DataSource间做选择，而无需改变应用的一行代码。在容器中保存资源定义还是在应用本地保存，主要是一个事务策略方面的事。比较一个Spring定义的本地SessionFactory与一个手工注册的JNDI SessionFactory没有任何益处。如果经由Hibernate的JCA连接器注册，才会有加入JTA事务的明显益处，特别是对EJB。

       一个重要的Spring事务提供的好处是它不与任何容器绑定。定义包括JTA在内的策略，它都可以独立工作或者在一个试验环境中工作。特别是对典型的一个数据库的事务来说，对于JTA这是一个非常轻量的和强大的选择。当使用本地EJB SLSB的事务时，你将同时依赖EJB容器和JTA-即使你只是访问一个数据库，即使只是使用SLSBs经由CMT来声明事务。选择使用 JTA编程也需要一个J2EE环境。

       就JTA自身和JNDI数据源来说JTA不只是包括容器依赖。对于不使用Spring的JTA驱动的Hibernate事务，你必须使用HibernateJCA连接器或者在合适的JVM缓冲层专门写Hibernate的事务代码配置JTA事务。在只访问一个数据库的情况下，Spring驱动的事务可以与一个本地定义的Hibernate的SessionFactory配合良好，就如同与一个本地JDBC数据源相配合一样。因此当面对分布的事务需求时，你只需要转换为Spring的JTA事务策略即可。

       要注意一个JCA连接器需要特别的容器的部署步骤，并且显然首先得支持JCA。这比使用本地资源定义和Spring驱动事务来部署一个简单的Web应用有更多的争议。而且你常常需要企业版本的容器支持，象WebLogic Express就不提供JCA。一个只用一个数据库的使用本地资源和事务的Spring应用可以在任何J2EE的Web容器中工作，Web容器不必支持JTA, JCA和EJB，如：Tomcat, Resin甚至最小的Jetty。另外，这样一个中间层就可以很容易地在桌面应用或者在测试套件中被重用。

       所有考虑过的事情包括：如果你不使用EJB，坚持使用本地SessionFactory，使用SpringHibernateTransactionManager或者JtaTransactionManager，你将获得包括适当处理的JVM层的缓存和分布事务的所有益处，而无需引起任何关于容器部署的争论。经由JCA连接器的一个Hibernate的SessionFactory的JNDI注册只是在使用EJB的情况中才会有明显的附加值。

10. Skeletons和例子

      配置使用Spring和HIbernate的一个J2EE的Web应用的注释和细节最好去看看在Spring Framework的例子中的“典型的Web应用”Skeletons，它给出了适合于JDBC 和 Hibernate应用的多种数据源及事务管理的配置项，仔细看一下事务拦截器的配置，它也同样向你展示了如何配置AOP拦截器。

      在Spring的1.0 M2版中，例子Petclinic提供了JDBC和Hibernate的DAO实现和应用配置的选择。Petclinic
可以作为一个可工作的简单应用说明如何在一个Spring web 应用中使用Hibernate，同样也包括根据不同的事务策略来声明事务划分。

Links

Spring Framework website

Spring Framework documentation

我们使用Sub Version（简称SVN）作为版本管理工具。这里着重介绍SVN作为跨平台的多人协作使用方法。在多个程序员管理同一段代码的过程中，版本的管理显得尤为重要，使用SVN可以方便的进行分支、合并，记录下所有的版本。

在开始某项软件、文档的开发与撰写时，首先由配置管理负责人建立SVN仓库、用户名及其权限，并通知相关人员SVN仓库地址、SVN仓库负责人。

SVN仓库的负责人把工程的tsvn:logminisize设置为1，以便强制注释。设置方法：在你的工程文件夹右键->属性中，进入Subversion标签，选中tsvn: logminisize，确保复选框recursive选中，然后点击Set按钮把它的值设为1，其意思是指提交的注释最短长度为一个字。如图：

图 2 . 1

l        忽略文件

在 SVN 的 [Setting] 的 [General] 中 ， 设置需要忽略的文件以便忽略掉一些临时的、无用的文件 ， 常被忽略的文件有 *.opt *.ncb *.suo *.plg *.pch *.idb *.pdb *.scc *.obj Debug Release *.o *.bin *.out *.ilk *.aps debug release *.clw *.bak 。每个程序员可以根据自己的需要进行修改忽略文件，上面只是使用VC++与Tornado编程时常用的一些忽略文件。

图 2 . 2

以上说的忽略文件是指全局的忽略文件。SVN还能在特定的目录中指定需要忽略的文件。忽略文件支持通配符。

l        合并比较工具

在Merge Tool中可以选择用来合并的工具，强烈推荐用Araxis Merge。在[Setting]->[Diff]中填入"C:\Program Files\Araxis\Araxis Merge v6.5\Merge.exe"；在[Setting]->[Merge]的选项中，填入"C:\Program Files\Araxis\Araxis Merge v6.5\Merge.exe" %theirs %mine %merged ；其中"C:\Program Files\Araxis\Araxis Merge v6.5\Merge.exe"是指合并工具的路径，%theirs %mine %merged分别指..将要合并到主干的分支，主干，及合并后的结果。

图 2 . 3

SVN仓库的负责人规划好仓库的目录结构。推荐的目录结构如下图所示。

仓库的一级目录只有两个，分别为code和doc。其中，doc主要用来放置先期的文档，code主要用来放置工程的代码，也可以包含后期的文档。

仓库的二级目录只可以是branch与trunk两个目录，分别存放主干与分支。trunk目录下直接存放工程文件。branch目录下包括一些子目录分别对应各个分支。

图 2 . 4

从 SVN 仓库中取出代码时 ，一定 不要把整个仓库取出来 ， 而应该只取出 trunk 目录 ， 或只取出 branch 下的某个分支目录 （比 如上图中的 svn:\\code\branch\xw_051206 ） 。

一个项目会有多个人共同合作开发完成。基本流程是：

l        各开发成员建立自己的分支，并在此分支上开发；

l        各开发成员把分支合并到主干上并形成较为稳定的版本；

l        各个成员重新从主干上建立新的分支，在此分支上开发 ( 即回到第一步 )

l        循环往复，直到工程结束。

下面我用一个例子来说明合作开发的基本流程。

现在xb与lzj两个开发人员要共同开发一个工程onlytest，其这个工程的主干的SVN仓库地址如下图。

图 2 . 5

xb与lzj分别在onlytest这个工程中建立两个分支，分别为xb _051115和lz_051115。

在这里分支命名要采用[姓名缩写_6个数的日期_后缀(可选)]的形式，比如xb_051208_1，xb_051212之类的。创建完分支后我们可以看到这个工程的目录结构如下图所示：

图 2 . 6 分支目录

建完之后， xb和lzj分别在本地取出对应的分支进行开发。

当 程序到达一个比较稳定的阶段，就需要把分支合并到主干上，下面讲述一下合并的流程。

在本节中继续使用上一节中所示的工程与SVN仓库讲解。

现在 ， 主干上的 test_SVN.txt 是空文档。

由 xb 与 lzj 修改提交后 ， 两个分支中 test_SVN.txt 分别如下两图所示 ：

图 2 . 7 xb_051129 分支下的 test_SVN.txt

图 2 . 8 lzj_051129 分支下的 test_SVN.txt

xb 先把主干 check out 到本地。然后在主干的目录上右键 选择svn->merge，弹出如下窗口：

图 2 . 9 合并对话框

此对话框的含义是把From指定的分支版本到To指定的分支版本之间的差异合并到主干上。

在这里分支选的是xb_051129。版本号的选定方法是点击From中的Show Log，在Log窗口中按住Ctrl键，点击选择”made a copy”之上的那个版本，以及最顶上的那个版本，如图2.11所示。然后点击确定回到上图中的对话框，会自动填写From与To中的Revision号。

2 . 10 选择需要合并的版本

然后直接点击merge进行合并，你也可以通过dry run来看是不是两者之间有差异。由于没有其它人修改主干，所以合并的很顺利，下图是xb_051115与主干合并后的结果。合并完毕之后，由xb对主干进行提交。

图 2 . 11 合并后，主干上的 test_SVN.txt

xb合并完毕之后，lzj要将他的分支合并到主干上去，方法同上。但是由于xb已经修改过主干，所以产生了冲突，会弹出一个冲突对话框。双击对话框中的产生冲突的文件名，就可以调出工具对此文件进行合并，下图是我们用merge工具显示的界面。

图 2 . 12

l        首先比较第一个窗口与第二个窗口，把结果修改合并到第二个窗口。

l        然后确保光标处于第二个窗口时，点击上图中红色圈圈所示的按钮。这样会把第二个窗口的内容全部复制到第三个容口。之后保存，退出。

l        然后在工程目录上点右键，进行SVN->Resolved。这样会删除无用的临时文件。

l        最后提交所作的修改，并添加详细的注释。

与CVS不同，使用SVN时不用专门为目录添加标签，因为SVN也对目录进行版本管理。

我们在提交时写好注释（比如重要的版本提交时使用 051201 之类的日期作为开头），就可以通过注释来查找比较重要的目录版本号，相当于 CVS 或 VSS 中的标签。

另外，每个工程都会有一个版本说明文件，通过此文件可以查找关键版本。

你可以重命名、移动或删除你的文件或文件夹，但请使用SVN进行这些操作，否则之前的版本信息会丢失。

使用SVN删除、移动与重命名文件夹的方法是在文件/文件夹上点右键进行SVN操作，或直接在资源浏览器中使用右键拖放（会弹出SVN选项）。

文件的删除、移动与重命名之前，必须保证工作目录是最新的版本；进行这些操作之后，需要进行提交。

在代码的编写过程中，难免会有不尽人意的地方，你也许需要回退到某一个版本，但是在这个过程中可能有一些文件你想保留，也有一些文件你不想保留，这就牵扯到很复杂的版本管理过程，在这里给大家推荐几种方法。

1.        若是你编辑了工程，在没有提交的前提下，你想放弃这些修改，你可以直接选择 revert 就可以更新到工程的最新的版本。

2.        若是你想退回到某一个版本，你就可以直接选择 update to reversion 如图 , 这样我们就可以把我们的版本回退到你选中的版本去，这种情况下 SVN 并没有显示出有什么冲突，并且新建立的文件也还在，但是在这种情况下你并不能直接在你回退后的版本上进行编辑，因为 SVN 的版本控制还是在最新的主干上。我们需要 update 并解决冲突。

3.        你可以直接选择 revert changes from this revision 如图，这样的话你可以直接解决冲突并提交。不过这种方法的不足是，你新建的文件都没有了，整个工程都回退到之前的版本了。

4.        我推荐的一种方法是，直接 export 一个你需要的版本，然后用你 export 的版本覆盖你的最新的版本，这样你就可以不丢失你新建的文件，同时获得 head 的 SVN 控制文件。

图 13

每个工程会有很多个小模块，当某个模块达到稳定的时候，你就需要提交一次，以免写下个模块代码的时候出现不可恢复的错误。

每一次提交需要前，需要通过pclint检查，保证是一个编译没有错误的版本。当提交比较稳定的版本的时候，同时要修改你的版本号。

版本说明文件为xml表格，可用excel编辑，它会记录下关键的版本信息。

版本说明文件内容如下表。发布版本是指用户对外公布的版本号，后文中有详细描述；Revision是SVN内部的工程文件夹的版本号。一个发布版本可能对应多个Revision：

快门和光圈优先：

   为了得到正确的曝光量，就需要正确的快门与光圈的组合。快门快时，光圈就要大些；快门慢时，光圈就要小些。快门优先是指由机器自动测光系统计算出暴光量的 值，然后根据你选定的快门速度自动决定用多大的光圈。光圈优先是指由机器自动测光系统计算出暴光量的值，然后根据你选定的光圈大小自动决定用多少的快门。 拍摄的时候，用户应该结合实际环境把使曝光与快门两者调节平衡，相得益彰。

    光圈越大，则单位时间内通过的光线越多，反之则越少。光圈的一般表示方法为字母“F+数值”，例如F5.6、F4等等。这里需要注意的是数值越小，表示光 圈越大，比如F4就要比F5.6的光圈大，并且两个相邻的光圈值之间相差两倍，也就是说F4比F5.6所通过的光线要大两倍。相对来说快门的定义就很简单 了，也就是允许光通过光圈的时间，表示的方式就是数值，例如1/30秒、1/60秒等，同样两个相邻快门之间也相差两倍

    光圈和快门的组合就形成了曝光量，在曝光量一定的情况下，这个组合不是惟一的。例如当前测出正常的曝光组合为F5.6、1/30秒，如果将光圈增大一级也 就是F4，那么此时的快门值将变为1/60，这样的组合同样也能达到正常的曝光量。不同的组合虽然可以达到相同的曝光量，但是所拍摄出来的图片效果是不相 同的。

   快门优先是在手动定义快门的情况下通过相机测光而获取光圈值。举例说明，快门优先多用于拍摄运动的物体上，特别是在体育运动拍摄中最常用。很多朋友在拍摄 运动物体时发现，往往拍摄出来的主体是模糊的，这多半就是因为快门的速度不够快。在这种情况下你可以使用快门优先模式，大概确定一个快门值，然后进行拍 摄。因为快门快了，进光量可能减少，色彩偏淡，这就需要增加曝光来加强图片亮度。物体的运行一般都是有规律的，那么快门的数值也可以大概估计，例如拍摄行 人，快门速度只需要1/125秒就差不多了，而拍摄下落的水滴则需要1/1000秒。

手动曝光模式：

    手控曝光模式每次拍摄时都需手动完成光圈和快门速度的调节，这样的好处是方便摄影师在制造不同的图片效果。如需要运动轨迹的图片，可以加长曝光时间，把快 门加快，曝光增大；如需要制造暗淡的效果，快门要加快，曝光要减少。虽然这样的自主性很高，但是很不方便，对于抓拍瞬息即逝的景象，时间更不允许。

AE模式：

    AE全称为Auto Exposure，即自动曝光。模式大约可分为光圈优先AE式，快门速度优先AE式，程式AE式，闪光AE式和深度优先AE式。光圈优先AE式是由拍摄者 人为选择拍摄时的光圈大小，由相机根据景物亮度、CCD感光度以及人为选择的光圈等信息自动选择合适曝光所要求的快门时间的自动曝光模式，也即光圈手动、 快门时间自动的曝光方式。这种曝光方式主要用在需优先考虑景深的拍摄场合，如拍摄风景、肖像或微距摄影等。

多点测光：

    多点测光是通过对景物不同位置的亮度，通过闪光灯补偿等办法，达到最佳的摄影效果，特别适合拍摄别光物体。首先，用户要对景物背景，一般为光源物体进行测 光，然后进行AE锁定；第二步是对背光景物进行测光，大部分的专业或准专业相机都会自动分析，并用闪光灯为背光物体进行补光。