从Spring到Java EE 6

最新推荐文章于 2022-02-25 09:14:35 发布

dnc8371

最新推荐文章于 2022-02-25 09:14:35 发布

阅读量157

点赞数

我最近在一个非常复杂的项目中工作，其中融合了许多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 
 
 @Inject
 private 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 {
 
    @Autowired
    private MessageConverter msgConverter;
 
    @Autowired
    private 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  {
 
 @Inject
     private 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 {

 @Autowired
 private 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 {
 
 @Inject
     private MsgToRequestConverter msgConverter;

 @Resource(mappedName="java:/JmsXA")
 private ConnectionFactory connectionFactory;
 
 @Resource(mappedName="queue/myQueue")
 private Queue queue;
 
 private Connection jmsConnection;


 @PostConstruct
 private void initialize() {
  try {
   jmsConnection = connectionFactory.createConnection();
  } catch (JMSException e) {
   throw new EJBException(e);
  }
 }
 
 
 @PreDestroy
 private 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 {
 
   @Autowired
   GeekService bizService;
   
  @RequestMapping(value="/{id}", method=RequestMethod.GET)
  @ResponseBody
  public 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;
 
 @XmlElement
 public String getName() {
  return name;
 }
 
 public void setName(String name) {
  this.name = name;
 }
 
 @XmlAttribute
 public 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 {

 @Inject
  GeekService 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;
 
 @XmlElement
 public String getName() {
  return name;
 }
 
 public void setName(String name) {
  this.name = name;
 }
 
 @XmlAttribute
 public 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 。

相关文章：