【IT168 专稿】在Spring 和 EJB 3.0 两种主流技术之间作出选择是非常艰难的。本文探讨了两者间的异同，并阐述了进行技术比较的关键环节。

一、简介

    如今的软件开发人员面临的各种技术选择令人眼花缭乱。涉及到具体项目案例时，很难说哪一种技术更优。在基于java平台的企业开发领域，针对Spring框架和EJB 3.0之间的辩论异常激烈。众说纷纭，莫衷一是。本文尽量从客观的视角比较两者的优劣。 
  
    Spring 和 EJB 在概念上属于两个不同的范畴，Spring是一种技术实现，EJB则是技术规范。但两者确实存在交叉重叠，比如他们都提供了为java应用递送中间件服务的机制。Spring框架的推出正是针对EJB的，两者之间自然就存在着可比性。随着EJB最新版本3.0的发布，对于先前版本的缺欠做出了很大改进。那么Spring如何能持续地提供超越EJB的特性呢？

本文撷取了企业级应用开发环境内，Spring和EJB 3各自最重要的特性。文中以机票预定系统为案例阐述每个特性的要旨，涉及业务领域模型以及企业级应用开发中的并发控制、事务处理、消息处理、任务调度等范畴。

定义  

在深入比较分析之前，先看一下Spring 和EJB各自声称要实现的是什么。在Spring的网站上，Spring被定义为“基于Java/J2EE分层应用框架”。而EJB则将自己定义为“分布式面向对象企业级应用的组件架构”。

图一. 航班预订模型。模型涉及了对象－关系映射的诸多概念：组合，双向和三向关联等。

如下的单元测试用来验证机票对象生成、与航班关联、分配座位、最后结果存入数据库。

    public void testSave()

    ...{

        Ticket ticket = TicketMother.create();

        Flight outboundFlight = flightDAO.findById(1);

        Flight returnFlight = flightDAO.findById(2);

        ticket.setOutboundFlight(outboundFlight);

        ticket.setReturnFlight(returnFlight);

        ticket.getPassenger().setFlightDetails(outboundFlight,

            new PassengerFlightDetails(getSeatForFlight(outboundFlight, "2A")));

        ticket.getPassenger().setFlightDetails(returnFlight,

                new PassengerFlightDetails(getSeatForFlight(returnFlight, "2B")));

        ticketDAO.save(ticket);

        ticket = ticketDAO.findById(ticket.getId());

        assertEquals("John", ticket.getPassenger().getFirstName());

        assertEquals("2A", ticket.getPassenger().getDetailsForFlight

(ticket.getOutboundFlight())

                .getSeat().getNumber());

    }

以上测试在Spring and EJB 3.0环境下都成功通过。这说明Spring 和 EJB 3.0在基本的ORM持久化方面功能相当，并且其实现方式非常相似。Hibernate是最流行的对象关系映射工具，以下是Spring/Hibernate组合的TicketDAO类的实现：

public class TicketSpringDAO extends HibernateDaoSupport implements TicketDAO

...{

    public Ticket save(Ticket ticket)

    ...{

        getHibernateTemplate().saveOrUpdate(ticket);
        return ticket;
    }

    ...

}
EJB 3.0的实现如下：
@Stateless
public class TicketEJBDAO implements TicketDAO
...{
    @PersistenceContext(unitName = "flightdb")
    private EntityManager em;
    public Ticket save(Ticket ticket)
    ...{
        em.persist(ticket);
        return ticket;
    }
    ...
}

显然，从实现的角度来看，两个产品非常相似。Spring设计了HibernateDaoSupport类，将Spring与Hibernate间的交互操作抽象出来，通过HibernateDaoSupport类可访问Hibernate的诸多特性，以及Spring的Hibernate模版。而在EJB 3.0中，则是凭借容器来注入实体对象管理器。

Hibernate的Session和JPA的实体对象管理器功用相当，但其间细微的差别值得重视。Hibernate的Session是实体对象的缓存同时也是对象－关系映射引擎的接口。而在JPA中，持久化场景承担了缓存的角色，实体管理器则承担接口的角色。

在映射方式方，基于Spring/Hibernate的应用以XML映射文件的方式实现。

<hibernate-mapping package="org.jug.flight.domain" default-lazy="false">

  <class name="Ticket">

    <id name="id" column="id">

      <generator class="native" />

    </id>

    <property name="status" type="Status" />

    <many-to-one name="outboundFlight" column="outbound_flight" />

    <many-to-one name="returnFlight" column="return_flight" />

    <many-to-one name="passenger" column="passenger_id" cascade="all" />

  </class>

</hibernate-mapping>

基于JPA的应用通常采用注释的方式，好处是减少了配置以及映射数据毗邻相关实体对象的工作量，从而提高了可视性。 

@Entity

public class Ticket implements Serializable

...{
    @Id
    @GeneratedValue
    private long id;
    private Status status;
    private double price;

    @ManyToOne(cascade = CascadeType.PERSIST)

    private Passenger passenger;

    private Flight outboundFlight;

    private Flight returnFlight;

    ...

}

     Spring/Hibernate 和 EJB 3.0/JPA在通过ORM实现持久化方面功能相似。

    以下以机票预订系统为例，阐述Spring和EJB 3.0提供的事务处理功能。

图二. 购票流程序列图。如果中间任一步骤失败，应确保系统状态的一致性。

 

如下的单元测试验证购票操作流程以事务方式运作：

 

 

   public void testPurchaseTicket_DebitFailure() throws Exception
    ...{
        // 创建机票对象
        Ticket ticket = createTicket();
        // 保存数据库中机票数量
        int count = ticketDAO.findAll().size();
        // 设置信用卡授权
        setupMockAuthorizer(true);
        try
        ...{
            bookingAgent.purchaseTicket(ticket, true);
            fail("System failure was not thrown as was intended");
        }
        catch (InsufficientFundsException e)
        ...{
            // 纠正异常行为
        }
        // 验证事务回滚
        assertEquals(count, ticketDAO.findAll().size());
    }

此测试在Spring 和 EJB 3.0中均能通过。下面是Spring的实例类：

 

    public Ticket purchaseTicket(Ticket ticket)
    ...{
        creditAuthorizer.authorize(ticket.getPrice(), null);
        ticket.setStatus(Status.PURCHASED);
        ticketDAO.save(ticket);
        creditAuthorizer.debit(ticket.getPrice());
        return ticket;
    }

以下是EJB 3.0的实例类

    public Ticket purchaseTicket(Ticket ticket)
    ...{
        creditAuthorizer.authorize(ticket.getPrice(), null);
        ticket.setStatus(Status.PURCHASED);
        ticketDAO.save(ticket);
        creditAuthorizer.debit(ticket.getPrice());
        return ticket;
    }

Spring和 EJB 3.0在处理方式上都不必直接和事务管理细节打交道。这说明了声明式编程的优势。事务管理可以模块化的方式在整个应用范围内重用，以避免业务逻辑混乱,从而使开发人员可将主要精力用在处理业务问题方面。

<bean id="bookingAgent" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <property name="transactionManager" ref="transactionManager" />
    <property name="target" ref="bookingAgentSpring" />
    <property name="transactionAttributes">
        <props>
            <prop key="*">PROPAGATION_REQUIRED</prop>
        </props>
    </property>
</bean>

<bean id="bookingAgentSpring" class="org.jug.flight.booking.spring.BookingAgentSpring">
    <property name="flightDAO" ref="flightDAO" />
    <property name="ticketDAO" ref="ticketDAO" />
    <property name="screener" ref="screener" />
</bean>
 

    图3通过机票预订流程的各个步骤，阐述了Spring 和 EJB 3.0管理状态的方式。

   public void testPurchaseTicket_UseCase() throws Exception
    ...{
//开始购票会话
        FlightCriteria flightCriteria = new FlightCriteria("DFW", "AUS", DateUtilities.parseDate("2006-01-15"));
        bookingAgent.bookRoundTripTicket(flightCriteria);

        //选择离港航班
        List outboundFlights = bookingAgent.listOutboundFlights();
        assertEquals(3, outboundFlights.size());
        bookingAgent.selectOutboundFlight(selectFlight(outboundFlights, 1));

        //选择返程航班
        List<Flight> returnFlights = bookingAgent.listReturnFlights();
        assertEquals(3, returnFlights.size());
        bookingAgent.selectReturnFlight(selectFlight(returnFlights, 2));

        //选择旅客
        Passenger passenger = new Passenger("Rod", "Coffin");
        bookingAgent.selectPassenger(passenger);

        //选择座位
        bookingAgent.selectOutboundSeat(selectSeat
(bookingAgent.retrieveCurrentTicket().getOutboundFlight(), "1B"));
        bookingAgent.selectReturnSeat(selectSeat
(bookingAgent.retrieveCurrentTicket().getReturnFlight(), "1A"));

        //购票
        Ticket ticket = bookingAgent.purchaseTicket();
        assertTrue(ticket.getId() != 0);
    }

以下是基于Spring的实现：

public class BookingAgentSpring implements BookingAgent
...{
    private FlightCriteria outboundCriteria;
    private FlightCriteria returnCriteria;
    private Ticket ticket;

    public Ticket bookRoundTripTicket(FlightCriteria flightCriteria)
    ...{
        outboundCriteria = flightCriteria;
        returnCriteria = reverseCriteria(flightCriteria);
        ticket = new Ticket();
        ticketDAO.save(ticket);
        return ticket;
    }
    ...
}

@Stateful
public class BookingAgentEJB implements BookingAgent
...{
    private FlightCriteria outboundCriteria;
    private FlightCriteria returnCriteria;
    private Ticket ticket;

    public Ticket bookRoundTripTicket(FlightCriteria flightCriteria)
    ...{
        outboundCriteria = flightCriteria;
        returnCriteria = reverseCriteria(flightCriteria);
        ticket = new Ticket();
        ticketDAO.save(ticket);
        return ticket;
    }
    ...
}

以上实例演示了Spring 和 EJB 3.0如何实现有状态的对象。尽管在功能方面相近，处理方式上则有明显的差异。

                                                    图4. 客户端的状态管理。Spring将状态组件存储在由web容器管理的HttpSession内。

图5. EJB的状态管理。客户端通过代理对象与EJB组件交互。这样组件的状态可由EJB容器管理。

 

EJB采用SFSB的方式有几个优点。第一，在设计上允许SFSB在内存和持久性存储之间交换，使应用服务器可以平衡资源分配以改善性能。第二：SFSB运行在单独的进程内，应用系统的各层可以独立地配置和维护。第三，SFSB可以实现SessionSynchronization接口，这样事务回滚事件发生时，可以返回到bean的初始状态。

 

对于SFSB的批评一般集中在：与无状态的架构相比，性能和伸缩性不够好。针对这一点，Spring框架设计为以无状态为主。对于很多应用来说，状态是个重要指标。通常保存状态的几种方式是：数据库，HTTP Session,或内存。在上例中，基于Spring的购票代理可采用任一种方式管理状态，见表4。

 

表4. Spring中状态会话 Bean的替代方案

SFSB 的替代方案	优点	缺点
数据库	所有应用服务器共享	应用各层中最不灵活的层，如果设置二级缓存，则需复制数据。
HTTP Session	易用	必须复制数据，不能感知事务。
内存	所有应用服务器共享，效率高于数据库	必须复制数据，不能感知事务。

 

对于SFSB伸缩性问题的指责同样适用于表中的各方案，另外还需要重新开发SFSB已经具备的功能。在确定状态管理模式时，这些因素需要综合加以考虑。

 

Spring和EJB 3.0均提供了组件扩展点，使开发人员可将组件绑定到托管bean的生命周期。Spring提供了InitializingBean 和 DisposableBean接口，在bean初始化后和销毁前得到通知。EJB组件在创建后、销毁和钝化前、激活后，可通过设置获得通知。

 

最后，将bean的会话状态和事务同步是另一个要重点解决的问题。默认情况下，在事务回滚时，所有和事务相关的资源也相应回滚（如数据库和消息系统）。如果bean是有状态的，就会产生bean的状态同持久性数据存储不一致的问题。

EJB 3.0中SFSB基于容器管理的事务管理方式可实现SessionSynchronization接口以获取事务通知。基于Spring的方案则需以定制的方式实现相应的功能。

 

状态管理——小结

 

Spring 和EJB 3.0 都支持应用的状态管理机制。EJB 3.0采用SFSB实现状态管理，而Spring通过原型bean达到同一目标，这时性能和伸缩性是主要的考虑因素。两者的比较见图5。

 

图5. Spring 和 EJB 3.0.状态处理的比较

特性	Spring	EJB 3.0
表示状态的结构	原型bean	状态会话 Bean
实例管理	单例、原型、请求、会话、全局会话	每次生成新实例
生命周期管理	√ (初始化/销毁)	√ (创建/销毁、激活、钝化)
事务感知	--	√(SessionSynchronization 接口)
标准化	没有	√

 

五、结论

本文对于Spring应用框架和EJB 3.0规范在持久化、事务处理、状态管理等方面做了技术上的比较。两者有很多相近之处，其主要的差异体现在：状态管理模式、配置方式、扩展性。如果要开发的应用在状态管理方面需求很高，应优先考虑EJB 3.0 SFSB的方案。如果应用中交互会话强度较高，SEAM（基于SFSBs 和 JSF）是好的选择。

 

Spring在应用开发的很多方面提供了比EJB更灵活的选择，这一点在持久化和事务管理提供程序方面尤为显著。另一方面，也无疑增加了配置的复杂性。EJB 3.0虽欠灵活，但以其紧凑的技术架构、基于注释的配置方式、异常处理的配置方案等特性简化了应用开发过程。

 

标准化问题：Spring框架中集成了很多行业标准，比如JTA, JDBC, and JMS等，但Spring还不是一个java标准。

 

非常幸运的是，Spring和EJB 3.0之间并不是相互排斥的。可以将两种技术结合起来以取长补短。