从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 。

相关文章：