Spring对声明式事务管理的支持是通过它的AOP框架实现的。这样做是非常自然的，因为事务是系统级的，凌驾于应用的主要功能之上的。

    在Spring里，事务属性是对事务策略如何应用到方法的描述。这个描述包括：传播行为、隔离级别、只读提示、事务超时间隔
    传播行为：
    PROPAGATION_MANDATORY:表示该方法必须运行在一个事务中。如果当前事务不存在，将抛出一个异常。
    PROPAGATION_NESTED:表示如果当前已经存在一个事务，则该方法应当运行在一个嵌套的事务中。被嵌套的事务可以从当前事务中单独的提交或回滚。如果当前事务不存在，那么它看起来和PROPAGATION_REQUIRED没有两样。
    PROPAGATION_NEVER:表示当前的方法不应该运行在一个事务上下文中。如果当前存在一个事务，则会抛出一个异常。
    PROPAGATION_NOT_SUPPORTED:表示该方法不应在事务中运行。如果一个现有的事务正在运行中，它将在该方法的运行期间被挂起。
    PROPAGATION_REQUIRED:表示当前方法必须运行在一个事务中。如果一个现有的事务正在运行中，该方法将运行在这个事务中。否则的话，要开始一个新的事务。
    PROPAGATION_REQUIRES_NEW:表示当前方法必须运行在它自己的事务里。它将启动一个新的事务。如果有事务运行的话，将在这个方法运行期间被挂起。
    PROPAGATION_SUPPORTS:表示当前方法不需要事务处理环境，但如果有一个事务已经在运行的话，这个方法也可以在这个事务里运行。

   传播规则回答了一个问题：就是新的事务是否要被启动或是被挂起，或者方法是否要在事务环境中运行。

   隔离级别：在一个典型的应用中，多个事务并发运行，经常会操作同一个数据来完成它们的任务。并发，虽然是必须的，但会导致下面问题：
1、脏读：脏读发生在一个事务读取了被另一个事务改写但还未提交的数据时。如果这些改变在稍后被回滚，那么第一个事务读取的数据就是无效的。
2、不可重复读：不可重复读发生在一个事务执行相同的查询2次或2次以上，但每一次查询结果都不同时。这通常是由于另一个并发事务在2次查询之间更新了数据。
3、幻读：幻读和不可重复读相似。当一个事务读取几行纪录后，另一个并发事务插入一些记录，幻读就发生了。隔离级别有如下几个：
ISOLATION_DEFAULT:使用后端数据库默认的隔离级别
ISOLATION_READ_UNCOMMITTED:允许你读取还未提交的改变了的数据，可能导致脏读、幻读、不可重复读
ISOLATION_READ_COMMITTED:允许在并发事务已经提交后读取。可防止脏读，但幻读和不可重复读仍可能发生。
ISOLATION_REPEATABLE_READ:对相同字段的多次读取的结果是一致的，除非数据被事务本身改变。可防止脏读和不可重复读，但幻读仍可能发生。
ISOLATION_SERIALIZABLE:完全服从ACID的隔离级别，确保不发生脏读、不可重复读和幻读。这在所有隔离级别中也是最慢的。

    只读：如果一个事务只对后端是据库执行读操作，数据库就可能利用事务只读的特性，使用某些优化措施。通过声明一个事务为只读，你就给了后端数据库一个机会，来应用那些它认为合适的优化措施。因为只读的优化措施是在事务启动时由后端数据库实施的，所以，只有将那些具有可能启动新事务的传播行为的方法的事务标记成只读才有意义(PROPAGATION_REQUIRED,PROPAGATION_REQUIRES_NEW和PROPAGATION_NESTED) TransactionProxyFactoryBean参照一个方法的事务属性，决定如何在那个方法上执行事务策略。

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
    <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
        <property name="jndiName">
            <value>java:comp/env/jdbc/myDatasource</value>
        </property>
    </bean>
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>
    </bean>
    <!-- 这个对象有一个值为courseService的id.当应用从应用上下文里请求一个courseService时，它将得到一个被
    TransactionProxyFactoryBean包裹的实例。 -->
    <bean id="courseService" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <!-- 代理所实现的接口 -->
        <property name="proxyInterfaces">
            <list>
                <value>
                    com.springinaction.training.service.CourseService
                </value>
            </list>
        </property>
        <!-- 被代理的对象 -->
        <property name="target">
            <ref bean="courseServiceTarget"/>
        </property>
        <!-- 事务管理器 -->
        <property name="transactionManager">
            <ref bean="transactionManager"/>
        </property>
        <!-- 事务的属性源 -->
        <property name="transactionAttributeSource">
            <ref bean="transactionAttributeSource"/>
        </property>
    </bean>
    <!-- 要知道尽管可以改变MatchAlwaysTransactionAttributeSource的事务属性参数，但它总是返回相同的事务属性，而
    不关心参与交易的哪一个方法。当你有一个相对简单的应用，把同样的事务策略应用到所有方法都没问题时，使用MatchAlwaysT
    ransactionAttributeSource就相当好。但是，在那些更为复杂的应用中，你很可能需要对不同的方法应用不同的事务策略。在那样
    情况下，你需要在应用何种策略的问题上做更多精确的控制。 -->
    <bean id="transactionAttributeSource" class="org.springframework.transaction.interceptor.MatchAlwaysTransactionAttributeSource">
        <property name="transactionAttribute">
            <ref bean="myTransactionAttribute"/>
        </property>
    </bean>
    <!-- 定义事务策略 -->
    <bean id="myTransactionAttribute" class="org.springframework.transaction.interceptor.DefaultTransactionAttribute">
        <!-- 传播行为 -->
        <property name="propagationBehaviorName">
            <value>PROPAGATION_REQUIRES_NEW</value>
        </property>
        <!-- 隔离级别 -->
        <property name="isolationLevelName">
            <value>ISOLATION_REPEATABLE_READ</value>
        </property>
    </bean>
</beans>

除了将transactionAttributeSource对象织入到TransactionProxyFactoryBean的transactionAttributeSource属性中外，还有一种简单的方法。发展到现在，TransactionProxyFactoryBean也有一个transactionAttributes属性为transactionProperties.

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
    <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
        <property name="jndiName">
            <value>java:comp/env/jdbc/myDatasource</value>
        </property>
    </bean>
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>
    </bean>
    <!-- 这个对象有一个值为courseService的id.当应用从应用上下文里请求一个courseService时，它将得到一个被
    TransactionProxyFactoryBean包裹的实例。 -->
    <bean id="courseService" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <!-- 代理所实现的接口 -->
        <property name="proxyInterfaces">
            <list>
                <value>
                    com.springinaction.training.service.CourseService
                </value>
            </list>
        </property>
        <!-- 被代理的对象 -->
        <property name="target">
            <ref bean="courseServiceTarget"/>
        </property>
        <!-- 事务管理器 -->
        <property name="transactionManager">
            <ref bean="transactionManager"/>
        </property>
        <!-- 事务的属性源 -->
        <property name="transactionAttributeSource">
            <ref bean="transactionAttributeSource"/>
        </property>
    </bean>
    <!-- NameMatchTransactionAttributeSource的properties属性把方法名映射到事务属性描述器上。注意CourseException
    用一个负号标记。异常可以用负号或正号标记，当负号异常抛出时，将触发回滚;相反的，正号异常表示事务仍可提交，即使这个异常抛出 -->
    <bean id="transactionAttributeSource" class="org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource">
        <property name="properties">
            <props>
                <prop key="enrollStudentInCourse">
                    PROPAGATION_REQUIRES_NEW,ISOLATION_REPEATABLE_READ,readOnly,
                    -CourseException
                </prop>
                <!-- 还可以使用通配符 -->
                <prop key="get*">
                    PROPAGATION_SUPPORTS
                </prop>
            </props>
        </property>
    </bean>
</beans>

package com.testproject.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;

public class HibernateSqlQuery {
    Session session = null;
    public void querySql(){
        String sql = "select {usr.*} from T_User usr";
        List list = session.createSQLQuery(sql).addEntity("usr", TUser.class).list();
        Iterator it = list.iterator();
        while(it.hasNext()){
            TUser user = (TUser)it.next();
        }
    }
    public void queryMappingSql(){
        Query query = session.getNamedQuery("queryUser");
        query.setParameter("name","Erica");
        Iterator it = query.list().iterator();
        while(it.hasNext()){
            TUser user = (TUser)it.next();
        }
    }
}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.testproject.hibernate.TUser" table="T_USER">
        <id name="id" column="id">
            <generator class="native"></generator>
        </id>
    </class>
    <sql-query name="queryUser">
        <![CDATA[
            select {usr.*} from T_User usr where name=:name
        ]]>
        <return alias = "usr" class="com.testproject.hibernate.TUser"></return>
    </sql-query>
    <!-- 基于存储过程查询 sql-query节点的callable属性设定为true,指明当前查询基于存储过程定义-->
    <sql-query name="getUsersByAge" callable="true">
        <return alias="user" class="com.testproject.hibernate.TUser">
            <return-property name="id" column="ID"></return-property>
            <return-property name="name" column="NAME"></return-property>
            <return-property name="age" column="AGE"></return-property>
        </return>
        {?=call getUsersByAge(?)}
    </sql-query>
</hibernate-mapping>

    与HQL相同，Native SQL也可以在实体映射文件中进行配置：

    属性查询：有时我们并不需要获取完整的实体对象，只需要现实部分列，通过HQL也可以做到这点，如："select user.name,user.age form TUser user"表明我们需要读取name和age属性的内容，而此时，返回的list数据结构中，每个条目都是一个对象数组(Object[]),其中一次包含了我们所获取的属性数据。
    如果觉得返回数组的方式不够符合面向对象的风格，我们可以通过在HQL中动态构造对象实例的方法对这些平面化的数据进行封装。"select new TUser(user.name,user.age) from TUser user",我们通过HQL获取数据的部分属性值，与此同时，我们也可以在HQL的select字句中使用统计函数，甚至原生SQL函数，或者利用distinct关键字，剔除返回集中的重复记录。

    实体更新与删除：在Hibernate2中，HQL仅仅用于数据查询，而在Hibernate3中，HQL具备了更加强大的功能。实体更新与删除就是其中的主要特征之一。

    分组和排序：与SQL类似，HQL通过order by子句实现对查询结果的排序，order by子句可以指定多个排序条件："from TUser user order by user.name ,user.age desc"通过Group by子句可进行分组统计。如："select count(user),user.age from TUser user group by user.age",我们知道where子句可以对记录进行甄选。那么，对于Group by子句获得的结果集我们可以通过Having子句进行甄选。例如："select count(user),user.age from TUser user gourp by user.age having count(user)>10".

     参数绑定：类似JDBC中的SQL操作，我们可以通过顺序占位符"?"对参数进行标识，并在之后对参数内容进行填充。建议使用Query接口"from TUser user where user.name=? and user.age>?",这里除了顺序占位符，我们还可以使用引用占位符，如："from TUser where name=:name"参数绑定机制可以使得查询语法与具体参数数值相互独立。这样，对于参数不同，查询语法相同的查询操作，数据库即可实施性能优化策略。同时，参数绑定机制也杜绝了参数值对查询语法本身的影响。

     引用查询：SQL语句混杂在代码之间将破坏代码的可读性，并使得系统的可维护性降低。为了避免这样的情况出现，我们通常采取将SQL配置化的方式，也就是将SQL保存在配置文件中，需要调用的时候在进行读取。
<query name="queryByName">
 <![CDATA[
  from TUser user where user.name=:name
 ]]>
</query>
之后，我们可通过session.getNamedQuery方法从配置文件中调用引用的HQL.

     联合查询：inner join,left outer join,right outer join,full join
     子查询：如："from TUser user where (select count(*) from user.addresses)>1"HQL中，子查询必须出现在where子句中，且必须以一对圆括号包围。
     数据加载方式：Hibernate支持以下几种数据加载方式：
1、即时加载：当实体加载完毕后，立即加载其关联数据。
2、延迟加载：实体加载时，其关联数据并非即刻获取，而是当关联数据第一次被访问时再进行读取。
3、预先加载：预先加载时，实体及其关联对象同时读取，这与即时加载类似。
4、批量加载：对于即时加载和延迟加载，可以采用批量加载方式进行性能上的优化。

    在EJB领域中，客户并没有直接调用EJB实例，它们仅仅调用了EJB对象代理。借助于Home对象能够生成EJB对象。因此，对于定义在EJB Bean类中的各个ejbCreate()方法，在Home接口中也将存在对象的create()方法。当客户调用Home对象的create()方法时，容器将把调用请求委派给ejbCreate()方法。
    开发者可以通过多种方式查找实体Bean.需要在实体Bean的Home接口中列举出这些查找方法。我们称这些方法为"finder"方法。除了暴露创建、销毁实体Bean实例的方法外，Home接口还需暴露finder方法。这是实体Bean的Home接口同其他EJB类型中的Home接口的最明显区别。

    实体上下文，所有的EJB组件都存在上下文对象供组件访问到容器环境使用。这些上下文对象含有EJB容器设置的环境信息。因此EJB组件能够访问到上下文，从而获取各种信息，比如事务，安全性信息。对于实体Bean而言，存在javax.ejb.EntityContext上下文接口。它继承自EJBContext
public interface javax.ejb.EntityContext extends javax.ejb.EJBContext{
 public javax.ejb.EJBLocalObject getEJBLocalObject();
 public javax.ejb.EJBObject getEJBObject();
 public java.lang.Object getPrimarykey();
}
    通过调用getEJBObject()方法，当前客户能够获得某实体Bean实例对应的EJB对象。客户调用的是EJB对象，而不是实体Bean实例本身。因此，客户能够在应用中引用返回的EJB对象。
    实体Bean实例对应的主键可以通过getPrimaryKey()方法获得。主键唯一标识某实体Bean实例。当实体Bean实例存储到存储源中时，可以使用主键获得单个实体Bean实例。由于在RDBMS中也存在主键，因此主键能够唯一标识某个实体Bean实例。

    为了满足大量并发客户访问同一数据的要求，架构师需要借助于实体Bean设计出高性能的访问系统。如下给出一种解决方案：允许多个客户共享同一实体Bean实例。因此，实体Bean实例能够同时服务多个客户。尽管表面上看是可行的，但是对于EJB而言，这是行不通的。原因有亮点：其一，为实现实体Bean实例服务多个并发客户，必须保证实体Bean实例是线程安全的，开发线程安全的代码并不是一件容易的工作，而且经常会出现一堆错我。其二，底层事务系统几乎不可能控制多个线程的并发执行，事务往往同具体的线程绑定在一起。因此，基于上述理由，单个实体Bean实例只能够在单线程环境中运行。对于所有的EJB组件而言，包括会话Bean、消息驱动Bean、实体Bean，它们都是以单线程方式运行的。
    当然，强制要求各个实体Bean实例只能同时服务单个客户，将引入性能瓶颈。由于实例以单线程方式运行，客户需要排队等候实体Bean实例，从而获得对实体Bean实例的调用，这对于大型企业应用而言，是不允许出现的
    为了提供系统性能，EJB容器会实例化同一实体Bean的多个实例。这使得多个客户能够并发同不同实体Bean实例进行交互，而这些实体Bean实例代表了同一RDBMS数据。事实上，这就是EJB容器的运行行为。因此，客户再也不用排队等候实体Bean实例，因为存在多个实体Bean实例了。
    一旦多个实体Bean实例代表了同一RDBMS数据，则引入了另外一个问题：数据瘫痪。如果多个实体Bean实例代表的数据是通过缓存管理的，则需要在内存中拷贝多分缓存中的数据。显然，某些缓存中的数据将变得陈旧，因此会出现很多过期的数据。
    为了实现实体Bean实例的缓存一致性，各个实体Bean实例必须同底层存储元进行同步。EJB容器将通过调用ejbLoad(),ejbStore()方法同步这些实体Bean实例。
    至于实体Bean实例同底层RDBMS数据的同步频率，则取决于事务。事务将各个客户请求隔离起来。借助于事务实现数据同步。

    EJB容器提供的实例池是很有意义的。当然，并不是只有实体Bean才存在实例池。在将实体Bean实例重新分配给不同EJB对象时，会存在一些问题，并要求容器去解决。比如当实体Bean实例被指定给EJB对象时，它可能还持有资源(比如Socket连接)。如果将实体Bean实例放置在实例池中，Socket连接不在需要。因此为实现资源的获取和释放，实体Bean的Bean类需要实现如下2个回调方法：
1、ejbActivate().在将实体Bean实例从实例池中取出来时，EJB容器会自动调用它。该过程称之为激活。进而，EJB容器会将实体Bean实例分配给某EJB对象，并同时获得主键对象。在执行ejbActivate()方法期间，实例需要获得所需的资源，比如Socke,否则，在将实体Bean实例分配给某EJB对象时，无法对资源进行操作。
2、ejbPassivate().在将实体Bean实例放置到实例池中时，EJB容器会调用它。注意，它也是回调方法。这一过程称之为挂起。进而，EJB容器需要从某EJB对象中取回分配于它的实体Bean实例，并将实例的主键对象也收回。在执行ejbPassivate()方法期间，需要释放ejbActivate()执行期间获得的相关资源，比如：Socket.
    一旦实体Bean实例被挂起，不但要释放它持有的资源，还将实例的状态信息保存起来。因此，实体Bean实例最新的状态信息可以从RDBMS中找到了。为了保存实体Bean实例的域信息到RDBMS中，容器要在挂起实例前调用ejbStore()方法。类似的，一旦实体Bean被激活，不但要获得所需的资源，还要从RDBMS装载最新的数据，为了完成数据的读取，EJB容器将在激活实体Bean实例后调用ejbLoad()方法。