從Spring到Java EE 6

我最近在一個非常復雜的項目中工作，其中融合了許多Java EE 6技術（例如JPA，JAXB，JMS，JTA，JAX-RS等）。出于生產力和計劃方面的原因，將原型應用程序設計為獨立的純Spring應用程序。當實際應用程序的開發開始時，我們重新挑戰了最初的選擇（即Spring v3），并分析了切換到Java EE 6應用服務器（例如GlassFish或JBoss）的興趣。
這最終導致兩個主要問題：

我們可以在Java EE 6中完成Spring可以做的一切嗎？
我們可以像在Spring那樣簡單嗎？

好吧，我要說的是，在全球范圍內，答案是：是的，我們可以！

我不想重新開始（無休止的）辯論，要知道在Spring和Java EE 6之間哪個是最好的。不，我只想與您分享我有關遷移的經驗。我曾經是，現在仍然是一個真正的Spring狂熱愛好者（從歷史上來說，我是在EJB 1.0令人反感之后才發現的），但我也知道最近在Linux中引入的進展，而不僅僅是簡化。這些年來的Java EE，以及Java EE 6應用程序服務器方面令人印象深刻的速度改進。

現在讓我們詳細研究“企業”應用程序的一些典型要求，并比較在兩種情況下要產生的代碼：

上下文和依賴注入
訊息傳遞
交易管理
網頁服務

如果您不愿從一種技術遷移到另一種技術，那么這種比較應該為您提供一些具體的決策要素……

第一部分：上下文和依賴注入（CDI）

Spring允許您使用各種構造型（例如@ Repository，@ Service，@ Controller和@Component）定義bean。選擇的選項不是那么重要（這不是完全正確。例如，將DAO標記為@Repository將添加SQL異常的自動翻譯），因為這種區別主要是針對IDE的（以便對bean進行分類）。（可選）您可以為您的bean命名。

public interface MyInterface {...}

import org.springframework.stereotype.Component;@Component("firstBean")
public class MySpringBean implements MyInterface {...}@Component("firstBeanMock")
public class MockImpl implements MyInterface {...}

Java EE提供了非常相似的注釋（@Named），但其使用應僅限于純pojo。如果是面向服務的Bean（尤其是事務性粗粒度服務），請考慮使用（最好是無狀態的）EJB，即因為它們提供了更好的可伸縮性。

import javax.inject.Named;@Named("firstBean")
public class MyJeeBean implements MyInterface {...}

import javax.ejb.Stateless;@Stateless(name="firstService")
public class MyJeeService implements MyInterface {...}

還應注意，與Spring相反，應在Java EE中將單例顯式標記為：

import javax.inject.Singleton;@Singleton
public class MyJeeSingleton implements MyInterface {...}

備注：在“ javax.inject.Singleton”和“ javax.ejb.Singleton”之間進行選擇時，您可能會感到困惑。第一個定義由容器（在Java EE世界中也稱為“ Managed Bean ”）管理的標準POJO，而第二個定義“ Enterprise Bean”。請記住，后者是為并發訪問而設計的（客戶端無需擔心可能同時調用單例相同方法的任何其他客戶端），并且還提供了事務管理功能（請參閱進一步）。

現在我們已經注冊了（并可以選擇命名）我們的bean，我們可以將它們注入其他bean中。再一次，雙方的程序有點類似：

彈簧

import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;@Component
public class UseCaseHandler {@Autowired@Qualifier("firstBean")private MyInterface serviceFacade;}

JAVA EE 6

import javax.inject.Named;
import javax.inject.Inject;@Named
public class UseCaseHandler {@Inject@Named("firstBean")  private MyInterface serviceFacade;}

備注：JSR-330統一了注入托管bean的方式。具體來說，這意味著@Inject批注可用于注入簡單的POJO和EJB（從而使@EJB批注過時）。

很好！但是，在現實世界中，我們要注入的bean的名稱（例如“ firstBean”）可能是動態的。當您使用行為模式，泛型等時，尤其如此。

在Spring，這非常容易。例如，您可以使您的bean能夠識別ApplicationContext，以便隨后可以使用注入的Spring上下文來查找特定的bean實例：

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Service;import com.javacodegeeks.Request;@Service
public class Dispatcher implements ApplicationContextAware {private ApplicationContext appContext;public void setApplicationContext(ApplicationContext ctx) throws BeansException {appContext = ctx;}public void dispatch(Request request) throws Exception {String beanName = "requestHandler_" + request.getRequestTypeId();RequestHandler myHandler = appContext.getBean(beanName, RequestHandler.class);myHandler.handleRequest(request);}}

public interface RequestHandler  {public void handleRequest(Request request);
}

@Component("requestHandler_typeA")
public class HandlerA implements RequestHandler {...}

@Component("requestHandler_typeB")
public class HandlerB implements RequestHandler {...}

在Java EE 6中，這是可能的，但是需要更多的代碼行（可以集中在幫助程序類中）：

import java.util.Set;
import javax.inject.Inject;
import javax.inject.Named;
import javax.enterprise.context.spi.CreationalContext;
import javax.enterprise.inject.spi.Bean;
import javax.enterprise.inject.spi.BeanManager;import com.javacodegeeks.Request;@Named
public class Dispatcher @Injectprivate BeanManager beanManager;public void dispatch(Request request) throws Exception {String beanName = "requestHandler_" + request.getRequestTypeId();RequestHandler myHandler = this.getBean(beanName, RequestHandler.class);myHandler.handleRequest(request);}@SuppressWarnings("unchecked")private <T> T getBean(String name, Class<T> clazz) throws Exception {Set<Bean<?>> founds = beanManager.getBeans(name);if ( founds.size()==0 ) {throw new Exception("No such bean found: "+name);} else {Bean<T> bean = (Bean<T>) founds.iterator().next();CreationalContext<T> cc = beanManager.createCreationalContext(bean);T instance = (T) beanManager.getReference(bean, clazz, cc);return instance;}}}

public interface RequestHandler  {public void handleRequest(Request request);
}

@Named("requestHandler_typeA")
public class HandlerA implements UseCaseHandler {…}

@Named("requestHandler_typeB")
public class HandlerB implements UseCaseHandler {...}

第二部分：JMS

Java Messaging Service簡化了松散耦合的分布式通信的實現。
這就是為什么它已成為企業應用程序集成（EAI）中的經典技術的原因。

Spring具有出色的JMS支持。您可以非常快速地設置JMS生產者或使用者，
使用目標解析器，還可以選擇將JMS消息自動轉換為pojos（反之亦然）。另一方面，J2EE帶有一組豐富的注釋，以便訪問或定義JMS資源，例如隊列/主題，連接或面向消息的Bean。

讓我們從接收消息的JMS客戶端開始，該客戶端是消息使用者（或訂戶）：

彈簧

<bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate"><property name="environment"><props>…</props></property>
</bean><bean id="jmsConnectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean"><property name="jndiTemplate" ref="jndiTemplate" /><property name="jndiName" value="java:/JmsXA" />
</bean><bean id="jndiDestResolver"class="org.springframework.jms.support.destination.JndiDestinationResolver"><property name="jndiTemplate" ref="jndiTemplate" />
</bean><bean id="jmsContainer"class="org.springframework.jms.listener.DefaultMessageListenerContainer"><property name="connectionFactory" ref="jmsConnectionFactory"/>   <property name="destinationResolver" ref="jndiDestResolver"/>  <property name="destinationName" value="queue/myQueue"/><property name="messageListener" ref="myMsgConsumer" />
</bean><bean id="myMsgConverter" class="com.javacodegeeks.MsgToRequestConverter"/><bean id="myMsgConsumer" class="com.javacodegeeks.MsgConsumer"/>

import javax.jms.Message;
import javax.jms.MessageListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.support.converter.MessageConverter;import com.javacodegeeks.Request;
import com.javacodegeeks.Dispatcher;/*** Example of message consumer (Message-Driven-Pojo) in Spring*/
public class MsgConsumer implements MessageListener {@Autowiredprivate MessageConverter msgConverter;@Autowiredprivate Dispatcher dispatcher;public void onMessage(Message message) {       try { Request request = (Request) msgConverter.fromMessage(message);dispatcher.dispatch(request); } catch (Exception e) {e.printStackTrace();    } }}

JAVA EE 6

import javax.inject.Inject;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.ejb.MessageDriven;
import javax.ejb.ActivationConfigProperty;import com.javacodegeeks.Request;
import com.javacodegeeks.Dispatcher ;
import com.javacodegeeks.MsgToRequestConverter;/*** Example of message consumer (Message-Driven-Bean) in JEE*/
@MessageDriven(activationConfig = { @ActivationConfigProperty(propertyName="destinationType", propertyValue="javax.jms.Queue"),@ActivationConfigProperty(propertyName="destination", propertyValue="queue/myQueue") 
} )     
public class MsgConsumer implements MessageListener  {@Injectprivate MsgToRequestConverter msgConverter;@Inject private Dispatcher dispatcher;public void onMessage(Message message) {       try { Request request = msgConverter.fromMessage(message);dispatcher.dispatch(request);      } catch (Exception e) {e.printStackTrace();     } }}

現在，讓我們編寫一個用于創建和發送消息的JMS客戶端，即消息生產者（或發布者）：

彈簧

<bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate"><property name="environment"><props>…</props></property>
</bean><bean id="jmsConnectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean"><property name="jndiTemplate" ref="jndiTemplate" /><property name="jndiName" value="java:/JmsXA" />
</bean><bean id="jndiDestResolver"class="org.springframework.jms.support.destination.JndiDestinationResolver"><property name="jndiTemplate" ref="jndiTemplate" />
</bean><bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate"><property name="connectionFactory" ref="jmsConnectionFactory" /><property name="destinationResolver" ref="jndiDestResolver" /><property name="messageConverter" ref="myMsgConverter" />
</bean><bean id="myMsgConverter" class="com.javacodegeeks.MsgConverter">

import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import com.javacodegeeks.Request;/*** Example of message producer component in Spring*/
@Component 
public class MsgProducer {@Autowiredprivate JmsTemplate jmsTemplate;public void postRequest(Request request) throws Exception {jmsTemplate.convertAndSend("queue/myQueue", request);}}

JAVA EE 6

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
import javax.inject.Inject;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.ejb.Stateless;
import javax.ejb.EJBException;import com.javacodegeeks.Request;
import com.javacodegeeks.MsgToRequestConverter;/*** Example of message producer (here a session bean) in JEE*/
@Stateless(name="msgProducer")
public class MsgProducer {@Injectprivate MsgToRequestConverter msgConverter;@Resource(mappedName="java:/JmsXA")private ConnectionFactory connectionFactory;@Resource(mappedName="queue/myQueue")private Queue queue;private Connection jmsConnection;@PostConstructprivate void initialize() {try {jmsConnection = connectionFactory.createConnection();} catch (JMSException e) {throw new EJBException(e);}}@PreDestroyprivate void cleanup() {try {if (jmsConnection!=null) jmsConnection.close();} catch (JMSException e) {throw new EJBException(e);}}public void postRequest(Request request) throws Exception { Session session = null;MessageProducer producer = null;try {session = jmsConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);producer = session.createProducer(queue);Message msg = msgConverter.toMessage(request, session);producer.send(msg);  } finally { try { if (producer!=null) producer.close();if (session!=null) session.close();} catch (Exception e) {System.err.println("JMS session not properly closed: "+ e);}}}}

備注：

不要忘記，與JMS連接和JMS隊列相反，JMS會話不是線程安全的。因此，會話不應由所有bean實例共享，也不應在構造函數或PostConstruct方法中創建。
PostConstruct和PreDestroy方法應該只拋出運行時異常。這就是為什么必須將JMS異常（例如）包裝到EJB異常中的原因。

第三部分：交易管理

事務的需求在系統體系結構中至關重要，尤其是在SOA出現時。在這樣的體系結構中，可以通過組裝現有的（可能還有交易的）較小的服務（“ 微服務 ”）來構建粗粒度的交易服務。

Spring和Java EE都通過提供強大的聲明式（基于注釋）事務管理來滿足這一需求。

彈簧

<!-- Recognize @Transactional annotations in our beans --> 
<tx:annotation-driven transaction-manager="txManager"/><!-- The transaction manager to use (here the JPA implementation) --> 
<bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">...
</bean>

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.annotation.Propagation;import com.javacodegeeks.Request;
import com.javacodegeeks.RequestProcessor;@Service
public class RequestProcessorImpl implements RequestProcessor {@Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class)public void process(Request request) throws Exception {...}}

JAVA EE 6

import javax.ejb.Stateless;
import javax.ejb.TransactionAttribute;
import javax.ejb.TransactionAttributeType;
import javax.ejb.TransactionManagement;
import javax.ejb.TransactionManagementType;import com.javacodegeeks.Request;
import com.javacodegeeks.RequestProcessor;@Stateless
@TransactionManagement(value=TransactionManagementType.CONTAINER)
public class RequestProcessorImpl implements RequestProcessor {@TransactionAttribute(TransactionAttributeType.REQUIRED)public void process(Request request) throws Exception {...}}

對Java EE中的運行時/未經檢查的異常要非常小心。默認情況下，它們被EJB容器自動包裝到EJBException中，這可能會導致令人驚訝的結果（尤其是在try…catch語句中！）。如果您需要對回滾情況進行更好的調整，請考慮使用@ApplicationException批注或通過如下擴展ejb描述符將此類運行時異常標記為適用性異常：

<ejb-jar><assembly-descriptor><application-exception><exception-class>java.lang.NullPointerException</exception-class><rollback>true</rollback></application-exception></assembly-descriptor>
</ejb-jar>

第四部分：寧靜的Web服務

企業應用程序通常需要通過Internet將其某些服務公開給外界。這就是Web服務發揮作用的地方。與JMS（用于異步通信）一樣，Web服務是另一種經典的集成技術，用于使用XML（或JSON）作為交換格式實現面向請求響應的同步通信。

彈簧

<servlet><servlet-name>ws</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping><servlet-name>ws</servlet-name><url-pattern>/services/*</url-pattern>
</servlet-mapping>

<!-- Dispatch requests to controllers + use JAXB (if found in the classpath) -->
<mvc:annotation-driven />

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;import com.javacodegeeks.Geek;
import com.javacodegeeks.GeekService;@Controller
@RequestMapping("/geeks")
public class GeekWebService {@AutowiredGeekService bizService;@RequestMapping(value="/{id}", method=RequestMethod.GET)@ResponseBodypublic Geek getGeek(@PathVariable("id") long geekId) {return bizService.findGeek(geekId);}}

import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;@XmlRootElement(name="geek")
public class Geek {private String name;private Long id;@XmlElementpublic String getName() {return name;}public void setName(String name) {this.name = name;}@XmlAttributepublic Long getId() {return id;}public void setId(Long id) {this.id = id;}}

JAVA EE 6

import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;import com.javacodegeeks.Geek;
import com.javacodegeeks.GeekService;@Path("/geeks")
@Produces(MediaType.APPLICATION_XML)
public class GeekWebService {@InjectGeekService bizService;@GET@Path("/{id}")public Geek getGeek(@PathParam("id") long geekId) {return bizService.findGeek(geekId);}}

import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;@XmlRootElement(name="geek")
public class Geek {private String name;private Long id;@XmlElementpublic String getName() {return name;}public void setName(String name) {this.name = name;}@XmlAttributepublic Long getId() {return id;}public void setId(Long id) {this.id = id;}}

備注：一些JAX-RS實現，例如JBoss RestEasy，不需要修改web.xml即可配置和安裝Web服務…

第五部分：結論

認為與Java EE相比，Spring中的事情要簡單得多，輕得多是不正確的。這只是一個品味問題。此外，最近的Java EE 6應用服務器（例如GlassFish 3或JBoss 6和7）的啟動速度非常快，實際上幾乎與Spring應用程序一樣快。然而，從“同類最佳”的角度來看，將兩種技術結合起來可能仍然很有趣。這將是我下一期JCG文章的主題：-)

參考： 從Spring到我們的W4G合作伙伴 Bernard Ligny的 Java EE 6 。

相關文章：