SessionFactory.getCurrentSession() 是 Hibernate 应用获取 Session 的常用方法。在调用该方法时，Hibernate 会从 interface CurrentSessionContext 获取当前的 Session，这是Hibernate 在不同组件中传递 Session 的方法。

CurrentSessionContext 有三个实现，分别是 ThreadLocalSessionContext、JTASessionContext 和 ManagedSessionContext。ThreadLocalSessionContext 将 Session 与当前线程绑定，是使用较多的一种方案；JTASessionContext 将 Session 与 JTA 事务绑定，在 JTA 环境中使用；ManagedSessionContext 使应用可以通过 bind() 和 unbind() 方法控制 Session 的绑定，主要在有 Conversation 的应用中使用（如果使用 ManagedSessionContext，开发人员要做的事情还是很多的）。CurrentSessionContext 实现的选择可以通过 hibernate.current_session_context_class 来配置。

另一种更常见的创建 Session 的方法是 openSession()。openSession() 与 getCurrentSession() 有何不同和关联呢？在 SessionFactory 启动的时候，Hibernate 会根据配置创建相应的 CurrentSessionContext，在 getCurrentSession() 被调用的时候，实际被执行的方法是 CurrentSessionContext.currentSession() 。在 currentSession() 执行时，如果当前 Session 为空，currentSession 会调用 SessionFactory 的 openSession。所以 getCurrentSession() 对于 Java EE 来说是更好的获取 Session 的方法。

再说 ManagedSessionContext，它提供了更灵活的绑定 Session 的方式，但是使用起来去不简单。在 Hibernate 的 CaveatEmptor 实例中有关于使用 ManagedSessionContext 的例子，但更好的选择是使用 Seam Framework。

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛

事务是企业应用开发中的重要概念，对于部分 Web 应用，事务也是非常重要的（试想一下，如果没有事务，ATM 和网银的操作将会使多么的危险）。下面我就对 Java EE 应用中各种事务技术做一个简介。

数据库：
       无论 Java EE 中采用了何种的事务技术，归根结底都是基于数据库的事务。不论是本地事务，还是分布式事务，都必须有数据库的支持才行。各种 Java EE 事务技术也都调用了数据库的事务功能。提到事务，必然要提到事务的四个基本特性：原子性、一致性、隔离性和持久性。Java EE 应用中的各种事务技术直接的或间接的都要保证这四个特性的实现。作为最底层的技术，数据库系统毫无疑问要保证这四个特性被完整的实现。

       数据库提供的事务功能是 Java EE 应用中事务的根本。数据库系统一般采用重执行日志保证事务的原子性、一致性和持久性。重执行日志记录了数据库变化的每一个动作，数据库系统会根据重执行日 志，在发生错误的时候撤销已执行的操作；或者在数据库重启时，将尚未持久化的数据重新执行操作。

      对于事务的隔离性，数据库系统采用锁机制来实现，这和 Java 采用的对象锁机制实现线程同步类似，只有持有锁的事务才能操作数据。数据库系统为用户提供了手工操作锁机制的功能，用户在执行 DML 操作和 SELECT FOR UPDATE 时都会获得行锁定，用户也可以进行表锁定。但是手工的操作锁必然是很麻烦的，也容易出现错误，所以数据库系统也提供了自动锁机制，这就引出了数据库的事务 隔离级别。只要用户指定会话的事务隔离级别，数据库就会自动的为事务操作加上适当的锁，并维护这些锁。SQL 92 标准定义了4个等级的事务隔离级别，不同的隔离级别对各种事务并发问题的解决能力是不同的。

JDBC：
      JDBC 是大家最为熟悉的技术之一，它是通过数据库系统来实现事务的，所以这里对它的介绍不多。只要调用相应的 API 就可以了，只要了解数据库系统的事务，理解 JDBC 的事务就非常容易了。使用 JDBC 需要数据库的支持，主流的数据库系统都支持单机的事务（相对分布式事务）。当然像一些内存数据库、文件数据库就不好说了。需要说明的是，JDBC 的事务只能在一个 Connection 内实现。

JTS 和 JTA：
      JTS 规定了 App Server 如何为应用程序提供容器级的事务支持。JTA 规定了 App Server 可以向用户提供哪些 API 用于控制事务。

      JTS/JTA 事务与 JDBC 的事务之间对大的不同是前者可以提供跨越多个数据库连接，而后者只能在单个数据库连接中实现事务。所以 JTS/JTA 事务对于企业级应用来说是非常重要的，也导致了大部分开发者对其不是很了解。

Hibernate：
      Hibernate 是最常用和最流行的 ORM 框架。Hibernate 也提供了基于 JDBC 和 JTA 的事务功能，这也是将 JTS/JTA 事务放在 Hibernate 前面的原因。
    
      因为 Hibernate 的事务是基于 JDBC 和 JTA 的，也可以使用容器管理事务，所以很多特性和 JDBC 和 JTA 等并无二异。需要特别提到的是 Hibernate 悲观锁和乐观锁这两个概念。Hibernate 的悲观锁利用的是数据库的行锁机制。使用悲观锁不仅可以保证本应用内的并发事务行，也可以保证使用相同数据库的其它应用不会访问或修改不应该的数据。但 是，悲观锁会影响到应用的并发访问性能。所以，在不是必须使用悲观锁的情况下可以使用乐观锁机制。乐观锁最常见的实现方式是使用 Version 字段，这也是 Hibernate 所推荐的方式。乐观锁可以保证事务和并发性能的兼得，但缺点是事务仅限于同一应用。关于悲观锁和乐观锁的详情很容易在书籍和网络上找到，这里我就不再拗 述。

Spring：
      Spring 在其它技术的基础上，为开发人员提供了一组统一的易于适用的 API。除了通过编程的方式实现事务外，在 Spring 环境中，也可以使用 XML 或 Annotation 来实现声明式事务。

      PlatformTransactionManager 在 Spring 的事务体系中是非常重要的一部分，它是一个抽象接口。HibernateTransactionManager、 JtaTransactionManager 等都实现了这个接口。这些 TransactionManager 的名字都很好理解，我也不多说了。

      Spring 事务最吸引人的特性是声明式事务。Spring 通过 AOP 技术提供了对声明式事务的支持。随着 Spring 版本的更迭，现在使用 Spring 的事务支持已经变得非常容易了。

     除此以外，Spring 还为 JMS 提供了本地事务功能，不过 JMS 的事务和数据库的事务有一定区别，我了解的也不是很多，所以在这里就不再介绍了。

     这篇文章简单总结了一下 Java EE 应用中不同技术所提供的事务支持，写的很粗，欢迎大家补充。打算以后再简要介绍一下 Seam 的事务，如果有必要的话，呵呵。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

没办法，对 Seam 十分感兴趣，而且目前的资料十分有限。对自己的英文有自信而且对 Seam 十分感兴趣的朋友还是可以看 《Seam in Action》的，虽然现在还是草稿。

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛

刚从网上下了本《Seam in Action》的 unedited draft 看。相信这最终是一本好书，但是现在的 draft 还是不推荐看，有很多语言需要调整。第一章读起来有点费劲。可能是 Seam 的只是不够丰富，所以很多地方看不懂，但是懂得多了也就用不着这本书了。总之，还是等正式版发行吧，再忍忍了。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师

本文将简单谈谈我对 EJB 3.0 的两种 Persistence Context 和 Seam-managed Persistence Context 的不同点的理解、所要解决的问题和我自己所疑惑的问题。

EJB 3.0 (JPA) 的 Persistence Context

        大家在使用 EJB 3.0 的时候会注意到 EJB 3.0 中的容器管理 Persistence Context 有两种类型，一种是 Transaction，另一种是 Extended。这是一个较 Hibernate 的 Session 所没有的概念，Session 没有两种不同的类型，而且最重要的是 Session 不是容器管理的，这里的容器指的是 App Server 容器。这里暂时不谈论 Persistence Context 与 Session 之间的异同，主要谈谈两种 Persistence Context 之间的不同。学过 ORM 的同学都知道，当 Persistence Context 是打开状态的时候，Model 就处于被管理的状态中；当 Persistence Context 关闭之后，Model 就处于了 Detached 状态。

       上面这些特性对于 Transaction 或 Extended 的 Persistence Context 都是一样的，不同的地方在于 Persistence Context 何时被打开关闭。由于绝大多数情况下 Persistence Context 是被容器管理的（如果你不嫌累也可以自己控制 Persistence Context），所以在 EJB 3.0 应用中看不到打开或关闭 Persistence Context 的代码（Spring + Hibernate 的应用也同样如此，Hibernate Session 的管理工作可以交给 Spring 来做）。

       其实，Transaction 和 Extended Persistence Context 的不同之处也就在于容器何时打开或关闭 Persistence Context。Transaction 类型的 Persistence Context 的打开和关闭是和事务的打开和关闭是同步的。也就是说在一个事务开始之后，Persistence Context 才会开始；在事务关闭的时候，相应的 Persistence Context 也会被关闭。

       Extended 类型的 Persistence Context 的打开和关闭是和 Stateful Session Bean 的生命周期同步的，是跨越事务的。也就是说，从 SFSB 的初始化开始，直到销毁，Persistence Context 都是存在的。你可以在事务之外执行写操作，但是这是并不会执行真正的数据库操作，写操作只是放入了队列，直到下一个事务，写操作才会真正地被执行。两者的不同简单说来就是 Extended Persistence Context 存在的时间更长。那为什么要有两种不同的 Persistence Context 呢？

       当一个 Web 请求到来时，服务器会打开一个线程，这个线程可能会调用一个事务方法，这是一个事务便开始了，当这个请求结束时，线程关闭，事务也随之结束。由于 Transaction 类型的 Persistence Context 的生存周期是在事务范围之内的，所以一个 Web 请求的结束也意味着相应的 Persistence Context 的关闭。由于多数 Web 应用在一次 Web 请求内即可完成一个独立的操作，所以大部分情况下 Transaction 的 Persistence Context 是适用的。但是对于一些复杂的应用，一次操作需要跨越多次请求。这种情况下，如果依旧使用 Transcation 的 Persistence Context，由于每次请求结束后，相应的 Persistence Context 都被关闭，相应的 Model 也就变为 Detached 状态。如果接下来的请求仍然需要这些已经变为 Detached 状态的 Model 就需要重新 load，使用 merge() 方法来持久化。稍有不适就会产生 LazyInitializationException 和 NonUniqueObjectException。同时，这也提高了操作的复杂程度。

       如果使用 Extended Persistence Context 就能解决这些问题。由于 Extended Persistence Context 的生命周期是与 SFSB 的生命周期同步的，所以只要多次请求调用的都是同一个 SFSB 中的方法，有多少次的请求，Persistence Context 总是同一个，其中的 Model 也始终是被管理的。很好地解决了 Persistence Context 在线程之间传递的问题，也不会有 LazyInitializationException 和 NonUniqueObjectException 问题的发生。

Seam-managed Persistence Context

       EJB 3.0 容器管理之下的 Persistence Context 很不错，能解决很多问题，但是还是有些问题无法解决。Seam 很强大，如果有些问题 EJB 容器解决不了了，没关系，把 Persistence Context 交由 Seam 来管理就 OK 了。那 Seam 都能解决哪些 EJB 不能解决的问题呢？先考虑下面两个问题：

1. Extended Persistence Context 虽然可以跨越多个事务，但是每个事务照旧调教不误，这对于想在想让整个操作作为一次事务的话，该如何去做
2. 如果一个业务的一组请求只是调用同一个 SFSB 的话，那么 EJB 的 Extended Persistence Context 可以在线程之间传递，使 SFSB 的整个生命周期都使用同一个 Persistence Context。但如果业务需要调用不同的 SFSB 的话，如何在 SFSB 之间传递。

       对于第一个问题，由于 Seam 的 JPA 实现提供者是 Hibernate，而且 Hibernate 提供了一个扩展的 FlushModeType - "Manual"。通过使用这个 FlushModeType，我们可以手工控制何时执行 flush() 操作。在 Seam 的文档中有关于这部分的介绍 《Seam-managed persistence contexts and atomic conversations 》。文档中使用了一段简单的代码展示 Seam 如何实现所谓的 "atomic conversations"（关于代码的内容我就不介绍了，大家通过我提供的链接来浏览 Seam 的文档）。通过这种方式，事务貌似是跨越了整个事务，但我认为 SFSB 中除了调用 flush() 的方法以外的其它方法不是事务的。其实也没有必要，因为这些方法并没有执行数据库操作，所以没有必要使用事务。当然，如果是乐观事物的话，使用了对性能影响也不大（这只是我的一点浅薄的理解，欢迎指出错误）。只有最后的调用了 flush() 的方法有事务的必要。

       这就引发了一个令我不解的问题。请先看这篇文章《Extended Persistence Context in Stateful Session Beans 》。在这篇文章介绍了如何只使用 EJB 3.0 去解决“问题1”。文中的 SFSB 的默认事务属性是 "NOT_SUPPORTED"，也就是说这个 SFSB 中的方法默认不是事务的。只有最后的调用 flush() 的方法使用了 "REQUIRED" 的事务属性去覆盖默认设置。也就是最后的方法是事务的，其它的不是。这和 Seam 所做的有区别吗？感觉没有区别。但我认为像 Gavin King 这样的大牛绝不会做无用功的，那问题就是 Seam 实现 "atomic conversations" 的内部细节到底是什么呢？欢迎大家回答这个问题。

       对于第二个问题，可以通过使用 Seam-Managed Persistence Context 来解决。Seam-manged Persistence Context 需要在 components.xml 文件中进行配置，并使用 @In 注入到 Seam 的组件中。由于 Seam 是一个比较新的框架技术，所以关于 Seam 是如何使 Persistence Context 在组件中传递并没有详细的介绍。应该只是声明，然后透明地使用即可。在一个 jBPM 流程中被使用到的 Seam 组件，其中的 Persistence Context 应该是可以很容易地被传递。（本不应该使用不确定的和模糊的词语，但无奈现在关于 Seam 的文章资料还是有限，所以我也没有找到关于 Persistence Context 在组件之间调用的例子）

结束语：这篇文章解释的问题不多，不过都是我自己的理解。可能有错误的地方，欢迎大家指出。同时，又有一些新问题产生了，应该可以通过阅读 Seam 提供的例子和源代码得到解释。但 Seam 的例子只看过三个，更多的还没有看。看过的 Seam 的源代码更可以忽略不计。继续努力吧！！

• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师

1. <security-constraint> 的子元素 <http-method> 是可选的，如果没有 <http-method> 元素，这表示将禁止所有 HTTP 方法访问相应的资源。
2. 子元素 <auth-constraint> 需要和 <login-config> 相配合使用，但可以被单独使用。如果没有 <auth-constraint> 子元素，这表明任何身份的用户都可以访问相应的资源。也就是说，如果 <security-constraint> 中没有 <auth-constraint> 子元素的话，配置实际上是不起中用的。如果加入了 <auth-constraint> 子元素，但是其内容为空，这表示所有身份的用户都被禁止访问相应的资源。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师

1. enum 能够让你摆脱掉大部分的“public static final”变量声明
2. 通常，你只需要用到 enum 的基本功能
3. enum 是 class，所以也可以有方法，也可以实现接口
4. enum 如此简单：

   public enum Grade {
        A, B, C, INCOMPLETE
   }
   

最后不需要分号（某本书上加了分号）
5. 从 Java SE 5.0 之后，switch 开始支持 enum

• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

<buildCommand>
    <name>org.eclipse.ui.externaltools.ExternalToolBuilder</name>
    <triggers>auto,full,incremental,</triggers>
    <arguments>
        <dictionary>
	    <key>LaunchConfigHandle</key>
	    <value><project>/explode.launch</value>
	</dictionary>
    </arguments>
</buildCommand>

<?xml version="1.0" encoding="UTF-8"?>
<launchConfiguration type="org.eclipse.ant.AntBuilderLaunchConfigurationType">
    <stringAttribute key="org.eclipse.ant.ui.ATTR_ANT_AFTER_CLEAN_TARGETS" value="clean,unexplode,restart,buildtest,"/>
    <stringAttribute key="org.eclipse.ui.externaltools.ATTR_RUN_BUILD_KINDS" value="full,incremental,auto,"/>
    <stringAttribute key="org.eclipse.ant.ui.ATTR_ANT_MANUAL_TARGETS" value="clean,unexplode,restart,buildtest,"/>
    <stringAttribute key="org.eclipse.ant.ui.ATTR_ANT_AUTO_TARGETS" value="explode,buildtest,"/>
    <stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="seamdemo"/>
    <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
        <listEntry value="/seamdemo/build.xml"/>
    </listAttribute>
    <stringAttribute key="org.eclipse.ui.externaltools.ATTR_LOCATION" value="${workspace_loc:/seamdemo/build.xml}"/>
</launchConfiguration>

<stringAttribute key="org.eclipse.ant.ui.ATTR_ANT_AUTO_TARGETS" value="explode,buildtest,"/>

1. auto,full,incremental 的具体含义；
2. 关于 *.launch 文件的根元素 “launchConfiguration” 的解释；
3. 。。。。。。

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• BPM，一路走来

• BPM≠Workflow＋EAI (上)
• BPM≠Workflow＋EAI (下)
• 面向大众的业务流程管理（BPM）

• BPEL 实例教程
• WS-BPEL 2.0 Tutorial

• 下一代软件架构--SOA
• BPM与SOA之间的区别及联系
• BPM技术促进SOA发展
• 浅谈：SOA实施现状及面临的挑战

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

• @Resource: 这个 Annotation 的作用就是提供了用 Annotation 的方式注入资源，不必在 xml 配置文件中显示声明了。还支持根据属性名或属性的类型进行自动的注入。
• @PostConstruct: 这个 Annotation 感觉暂时用不到（对我来说），所以没有细看。有兴趣的可以看原文。
• @PreDestroy: 同上。

• @Autowired: 这个 Annotation 支持更为灵活的注入。

@Autowired
public void setup(DataSource dataSource, AnotherObject o) { ... } 


原文这部分说的不是很详细，我的理解是如果 Application 上下文中存在类型是 DataSource 和 AnotherObject 的 Bean 的话，就会自动注入到 setup 方法中。如果是这样的话，@Autowired 是一个很不错的 Annotation，会使你的代码很好很强大，(*^__^*) 嘻嘻……
• @Qualifier: 也是用于细粒度注入的。
• @Service 和 @Controller: 这个好理解，不多说。反正我感觉这俩是不错东西，做项目的时候在仔细体会吧。
• @Scope: 就是 Spring 2.0 加入的 scope 属性的 Annotation。

• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

最近一段时间我在学习 Terracotta，一种 JVM 级的集群化技术。infoQ 上的<> 是一篇简要介绍 Terracotta 技术原理和应用的文章，适合大家为了解 Terracotta 而去阅读。为了能更好的理解这篇文章，也希望能够对大家了解 Terracotta 有所帮助，下面我将这篇文章从 Object Identity and Serialization 开始的部分的每段大意写了出来。写的不好，大家凑合看吧(*^__^*) 嘻嘻……

对象识别与序列化

Terracotta 不使用 Java 序列化去复制对象的改变。

这种方式要比使用 Java 序列化去复制对象的改变更有效率，因为这种方式仅仅在集群中移动被改变了的数据而不是序列化整个对象图。除了更有效率，这种方式还有另外一个好处：可以保持对象的识别符(ID)。

之所以许多其它的集群和缓存技术需要一个 GET/PUT API，是因为如果使用 Java 序列化在集群中移动改变了的数据，被改变的对象将要被反序列化，并且不得不替换存在了的对象实例。

Terracotta 没有这种限制。

(略)

在我们的例子中，Catalog 中的Product 对象与 shopping cart 中的 Products 是堆中的相同对象。

虚拟堆/网络附加存储

Terracotta 可以让我们有效率地使用有很大的对象图的本地 JVM 堆。Terracotta 会根据实例的使用模式去裁剪共享的对象图的本地实例。Terracotta 在集群对象图上维持一个可配置的窗口，不适应一定比例的堆的片段将根据一个缓存策略被清除。当需要那些丢失的片段的时候，它们将会重新从服务器中被载入(fault into?)。你可以将 Terracotta 集群看作是任意大的虚拟堆或network-attached memory。

这个特性将允许任意大的对象图“载入”标准大小的堆中。在我们的例子中，如果 Catalog 的数据量变得很大，在没有 Terracotta 的情况下，我们将投入大量的硬件资源去保持高可用性和高扩展性。

(略)

你怎样和什么时候使用 Terracotta？

下面列出的是四个有效使用 Terracotta 的用例：

• HTTP Session 复制
• 分布式缓存
• POJO 集群
• 协作、协调和事件

在一个多服务器环境中进行 HTTP Session 复制可能是最熟悉不过的用例了。现在应用程序的设计趋势是诸如购物车这样的应用程序状态信息存储在一个例如数据库的外部系统（注：放在关系型数据库中对应用程序的性能是有影响的，更好的做法是放在一个公共服务器的内存中），这被称作“无状态”应用程序设计。

这种“无状态”的方法并不是真的无状态。这种方法带来了两种负面影响，第一是对性能的影响，第二是对程序结构的影响。

Terracotta 的 Session 复制允许应用程序的 Session 数据保持原有的位置和形式，从而使网络应用程序的软件架构依旧简单。

Terracotta Session 复制通过允许任何应用程序去访问任何活动的 Session 来提供高可用性，无论那个 Session 是在哪里被创建的。它的扩展性很好，因为只有那些在 Session 中被改变了的数据会被复制，并且仅发送到需要它们的地方。如果没有其它的应用程序服务器在堆中拥有这个 Session，那么将没有其它的服务器会被发送这些修改。只有当服务器失败事件发生时，Session 数据才会被复制到其它应用程序服务器，并且仅发生在要求的时候。

有了 Terracotta，你只需像在单个 JVM 环境中去使用 Session 即可，Terracotta 会很好的完成其它事情。

在集群运行的时候，你能够看到整个集群中所有的 Session 的内容。在开发的时候，这被用来发现对 Session 的不恰当使用。在产品使用阶段，你能够立即观察到有多少活动的 Session，并且看到它们实时的变化。

Terracotta 可以和很多流行的 Web 框架工作，诸如 Struts、Spring Web Flow 和 Wicket。

POJO 和 Spring 集群

Terracotta 在集群中与 POJO 工作就如同是在单个 JVM 环境中简单，尤其是当你的应用程序使用了 Spring beans。

Terracotta for Spring 通过集群 Spring beans，从而在集群中非侵入式地维护 Spring Framework。你可以像平常那样开发 single-JVM 的 Spring 应用程序，然后定义你想集群哪些 Spring Context 和在这些 Context 下的哪些 Spring bean。Terracotta for Spring 也包含对 Spring Web Flow 的支持(continuations?)。这项特性使构建在 Terracotta 集群上的 Spring Web 应用程序能够失败转移会话状态。

分布式缓存

(略)

协作、协调和事件

Terracotta 的集群并发的特性使它成为 JVM 之间非常理想的信号量。

Terracotta 可以在集群上实现 Master-Worker 模式，从而处理并发事件。

总结
Terracotta 是一个新型轻量软件栈的基础（什么意思，Terracotta 规模还要做大？）。Terracotta使得开源组件诸如Tomcat、Spring、Geronimo 和开源应用程序框架的 host? 可以组装在一起，并且以企业级的可用性和可扩展性被部署的JVM 级的集群技术可以轻易的被使用。

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛

Table

Table用来定义entity主表的name，catalog，schema等属性。

元数据属性说明：

• name: 表名
• catalog: 对应关系数据库中的catalog
• schema：对应关系数据库中的schema
• UniqueConstraints:定义一个UniqueConstraint数组，指定需要建唯一约束的列

    
    @Entity
    @Table(name="CUST")
    public class Customer { ... }
　　

                
    @Entity
    @Table(name="CUSTOMER")
	@SecondaryTable(name="CUST_DETAIL",pkJoin=@PrimaryKeyJoinColumn(name="CUST_ID"))
	public class Customer { ... }
    
    

                
	@Table(name = "CUSTOMER")
	@SecondaryTables( value = {
	@SecondaryTable(name = "CUST_NAME", pkJoin = { @PrimaryKeyJoinColumn(name = "STMO_ID", referencedColumnName = "id") }),
	@SecondaryTable(name = "CUST_ADDRESS", pkJoin = { @PrimaryKeyJoinColumn(name = "STMO_ID", referencedColumnName = "id") }) })
	public class Customer {}
    
    

                
		@Entity
		@Table(name="EMPLOYEE",
			uniqueConstraints={@UniqueConstraint(columnNames={"EMP_ID", "EMP_NAME"})}
		)
		public class Employee { ... }
    
    

        
    public class Person {
	@Column(name = "PERSONNAME", unique = true, nullable = false, updatable = true)
	private String name;

	@Column(name = "PHOTO", columnDefinition = "BLOB NOT NULL", secondaryTable="PER_PHOTO")
	private byte[] picture;
		
    

                
	public class Custom {
	
    @OneToOne
	@JoinColumn(
	name="CUST_ID", referencedColumnName="ID", unique=true, nullable=true, updatable=true)
	public Order getOrder() {
		return order;
	}
    
    

                
	public class Custom {
    @OneToOne
	@JoinColumns({
    @JoinColumn(name="CUST_ID", referencedColumnName="ID"),
    @JoinColumn(name="CUST_NAME", referencedColumnName="NAME")
	})
	public Order getOrder() {
		return order;
	}
    
    

                
    @Entity
    @Table(name = "OTASK")
    public class Task {
	  @Id(generate = GeneratorType.AUTO)
	  public Integer getId() {
		  return id;
	  }
    }
    
    

                
    public class EmployeePK implements java.io.Serializable{
       String empName;
       Integer empAge;

	   public EmployeePK(){}

	   public boolean equals(Object obj){ ......}
	   public int hashCode(){......}
    }


    @IdClass(value=com.acme.EmployeePK.class)
    @Entity(access=FIELD)
    public class Employee {
        @Id String empName;
        @Id Integer empAge;
    }
    
    

                
    @Table(name = "PERSON")
    public class Person {

	@OneToMany(targetEntity = Book.class, cascade = CascadeType.ALL, mappedBy = "person")
	@MapKey(name = "isbn")
	private Map books = new HashMap();
    }
    
    

                
    @Table(name = "MAPKEY_PERSON")
    public class Person {

	@OneToMany(targetEntity = Book.class, cascade = CascadeType.ALL, mappedBy = "person")
	@OrderBy(name = "isbn ASC, name DESC")
	private List books = new ArrayList();
    }
    
    

            
    @Entity
    @Table(name="CUSTOMER")
	@SecondaryTable(name="CUST_DETAIL",pkJoin=@PrimaryKeyJoinColumn(name="CUST_ID"，referencedColumnName="id"))
	public class Customer { 
	 @Id(generate = GeneratorType.AUTO)
	  public Integer getId() {
		  return id;
	  }
	}
    
    

            
    @Table(name = "Employee")
    public class Employee {
	@OneToOne
	@PrimaryKeyJoinColumn(name = "id", referencedColumnName="INFO_ID")
	EmployeeInfo info;
	}
    
    

            
   @Entity
   @IdClass(EmpPK.class)
   @Table(name = "EMPLOYEE")
   public class Employee {

	private int id;

	private String name;

	private String address;

	@OneToOne(cascade = CascadeType.ALL)
	@PrimaryKeyJoinColumns({
	@PrimaryKeyJoinColumn(name="id", referencedColumnName="INFO_ID"),
	@PrimaryKeyJoinColumn(name="name" , referencedColumnName="INFO_NAME")})
	EmployeeInfo info;
    }

    @Entity
    @IdClass(EmpPK.class)
    @Table(name = "EMPLOYEE_INFO")
    public class EmployeeInfo {

	@Id
	@Column(name = "INFO_ID")
	private int id;

	@Id
	@Column(name = "INFO_NAME")
	private String name;
	}
    
    

    
    @Transient
    private String name;
    
    

                
    @Version
    @Column("OPTLOCK")
    protected int getVersionNum() { return versionNum; }
    
    

                
    @Lob
    @Column(name="PHOTO" columnDefinition="BLOB NOT NULL")
    protected JPEGImage picture;
    
    @Lob(fetch=EAGER, type=CLOB)
    @Column(name="REPORT")
    protected String report;
    
    

                
    @JoinTable(
    table=@Table(name=CUST_PHONE),
    joinColumns=@JoinColumn(name="CUST_ID", referencedColumnName="ID"),
    inverseJoinColumns=@JoinColumn(name="PHONE_ID", referencedColumnName="ID")
    )
    
    

                
    @Entity public class Employee {
    ...
    @TableGenerator(name="empGen",
    table=@Table(name="ID_GEN"),
    pkColumnName="GEN_KEY",
    valueColumnName="GEN_VALUE",
    pkColumnValue="EMP_ID",
    allocationSize=1)
    @Id(generate=TABLE, generator="empGen")
    public int id;
    ...
    }
    
    @Entity public class Address {
    ...
    @TableGenerator(name="addressGen",
    table=@Table(name="ID_GEN"),
    pkColumnValue="ADDR_ID")
    @Id(generate=TABLE, generator="addressGen")
    public int id;
    ...
    }
    
    

                
    @SequenceGenerator(name="EMP_SEQ", allocationSize=25)	
    
    

                
    @Entity
    @Table(name="CUST")
    @Inheritance(strategy=SINGLE_TABLE,
        discriminatorType=STRING,
       discriminatorValue="CUSTOMER")
    @DiscriminatorColumn(name="DISC", length=20)
    public class Customer { ... }
    
    

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！