{"id":666,"date":"2011-11-27T14:12:00","date_gmt":"2011-11-27T14:12:00","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/2012\/10\/from-spring-to-java-ee-6.html"},"modified":"2012-10-22T19:00:15","modified_gmt":"2012-10-22T19:00:15","slug":"from-spring-to-java-ee-6","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html","title":{"rendered":"From Spring to Java EE 6"},"content":{"rendered":"<div dir=\"ltr\" style=\"text-align: left\">I recently worked on a quite complex project mixing many Java EE 6 technologies (such as JPA, JAXB, JMS, JTA, JAX-RS, etc&#8230;). For productivity and planning reasons, the prototyped application was designed as a standalone pure Spring application. When the development of the real application started, we re-challenged our initial choice (i.e. Spring v3) and analyzed the interest of switching to a Java EE 6 app server like GlassFish or JBoss.<br \/>\nThis finally ended up in two major questions:<\/p>\n<ul style=\"text-align: left\">\n<li>can we do in Java EE 6 everything we can do in Spring ?<\/li>\n<li>can we do that as easy as in Spring ?<\/li>\n<\/ul>\n<p>Well, I would say that, globally, the answer is: yes we can !<\/p>\n<p>I do not want to reopen the (endless) debate of knowing which one, between Spring and Java EE 6, is the best. No, I just want to share with you my experience regarding this migration. I was &#8211; and I am still &#8211; a real Spring fanboy (which I, historically speaking, discovered after having been literally disgusted by EJB&#8217;s 1.0), but I am also aware of the recent progress, not to say simplifications, that have been introduced in Java EE &nbsp;these last years, as well as the impressive speed improvements on the side of Java EE 6 application servers.<\/p>\n<p>Let us now study in details some typical requirements of \u201centerprise\u201d applications, and compare the  code to produce in both worlds for:<\/p>\n<ul style=\"text-align: left\">\n<li>Contexts &amp; Dependency Injection<\/li>\n<li>Messaging<\/li>\n<li>Transaction management<\/li>\n<li>Web services<\/li>\n<\/ul>\n<p>This comparison should provide you with some concrete decision elements in the event you hesitate to migrate from one technology to the other&#8230;<\/p>\n<h2>  Part I : Contexts &amp; Dependency Injection (CDI)<\/h2>\n<p>Spring allows you to define beans using various stereotypes (eg @Repository, @Service, @Controller, and @Component). The one to choose is not that important (that&#8217;s not entirely true. For instance, tagging your DAO as @Repository will add the automatic translation of SQL exceptions) as this distinction is mostly intended to IDE&#8217;s (in order to categorize beans). Optionally, you can give your bean an alias.<\/p>\n<pre class=\"brush:java\">public interface MyInterface {...}\r\n<\/pre>\n<pre class=\"brush:java\">import org.springframework.stereotype.Component;\r\n\r\n@Component(\"firstBean\")\r\npublic class MySpringBean implements MyInterface {...}\r\n\r\n@Component(\"firstBeanMock\")\r\npublic class MockImpl implements MyInterface {...}\r\n<\/pre>\n<p>Java EE provides a very similar annotation (@Named) but its use should be limited to pure pojo&#8217;s.  In case of service-oriented beans (especially transactional coarse-grained services), consider using a (preferably stateless) EJB &#8211; namely because they offer better scalability.<\/p>\n<pre class=\"brush:java\">import javax.inject.Named;\r\n\r\n@Named(\"firstBean\")\r\npublic class MyJeeBean implements MyInterface {...}\r\n<\/pre>\n<pre class=\"brush:java\">import javax.ejb.Stateless;\r\n\r\n@Stateless(name=\"firstService\")\r\npublic class MyJeeService implements MyInterface {...}\r\n<\/pre>\n<p>Also beware that, in contrary to Spring, singletons should be explicitly marked as such in Java EE:<\/p>\n<pre class=\"brush:java\">import javax.inject.Singleton;\r\n\r\n@Singleton\r\npublic class MyJeeSingleton implements MyInterface {...}\r\n<\/pre>\n<p>Remark: you may get confused when choosing between a \u201cjavax.inject.Singleton\u201d and a \u201cjavax.ejb.Singleton\u201d. The first one defines a standard POJO managed by the container (aka a \u201c<a href=\"http:\/\/www.oracle.com\/technetwork\/articles\/javaee\/javaee6overview-141808.html\">Managed Bean<\/a>\u201d in the Java EE world), while the second one defines an \u201cEnterprise Bean\u201d. Remember that the later is designed for concurrent access (a client doesn\u2019t need to worry about any other clients that may be simultaneously invoking the same methods of the singleton) and also offers transaction management facilities (see further).<\/p>\n<p>Now that we have registered (and optionally named) our beans, we can inject them in other beans. Once again, the procedure is somewhat similar at both sides:<\/p>\n<p>SPRING<\/p>\n<pre class=\"brush:java\">import org.springframework.stereotype.Component;\r\nimport org.springframework.beans.factory.annotation.Autowired;\r\nimport org.springframework.beans.factory.annotation.Qualifier;\r\n\r\n@Component\r\npublic class UseCaseHandler {\r\n\r\n  @Autowired\r\n  @Qualifier(\"firstBean\")\r\n  private MyInterface serviceFacade;\r\n  \r\n}\r\n<\/pre>\n<p>JAVA EE 6<\/p>\n<pre class=\"brush:java\">import javax.inject.Named;\r\nimport javax.inject.Inject;\r\n\r\n@Named\r\npublic class UseCaseHandler {\r\n\r\n  @Inject\r\n  @Named(\"firstBean\")  \r\n  private MyInterface serviceFacade;\r\n  \r\n}\r\n<\/pre>\n<p>Remark: The JSR-330 has unified the way to inject managed beans. This concretely means that the @Inject annotation can be used to inject simple POJOs as well as EJB&#8217;s (making thereby the @EJB annotation a bit obsolete).<\/p>\n<p>Fine ! However, in the real world, the name (eg &#8220;firstBean&#8221;) of the beans we want to inject might be dynamic. This is particularly true as soon as you play with behavioral patterns, generics, etc&#8230;<\/p>\n<p>In Spring, this is pretty easy. You can for instance make your bean ApplicationContext-aware, so that you can then use the injected Spring context in order to lookup for specific bean instances:<\/p>\n<pre class=\"brush:java\">import org.springframework.beans.BeansException;\r\nimport org.springframework.context.ApplicationContext;\r\nimport org.springframework.context.ApplicationContextAware;\r\nimport org.springframework.stereotype.Service;\r\n\r\nimport com.javacodegeeks.Request;\r\n\r\n@Service\r\npublic class Dispatcher implements ApplicationContextAware {\r\n \r\n private ApplicationContext appContext;\r\n\r\n public void setApplicationContext(ApplicationContext ctx) throws BeansException {\r\n  appContext = ctx;\r\n }\r\n \r\n public void dispatch(Request request) throws Exception {\r\n  String beanName = \"requestHandler_\" + request.getRequestTypeId();\r\n  RequestHandler myHandler = appContext.getBean(beanName, RequestHandler.class);\r\n  myHandler.handleRequest(request);\r\n }\r\n \r\n}\r\n<\/pre>\n<pre class=\"brush:java\">public interface RequestHandler  {\r\n public void handleRequest(Request request);\r\n}\r\n<\/pre>\n<pre class=\"brush:java\">@Component(\"requestHandler_typeA\")\r\npublic class HandlerA implements RequestHandler {...}\r\n<\/pre>\n<pre class=\"brush:java\">@Component(\"requestHandler_typeB\")\r\npublic class HandlerB implements RequestHandler {...}\r\n<\/pre>\n<p>In Java EE 6, the same is possible but yet requires a bit more lines of code (that could be centralized in an helper class):<\/p>\n<pre class=\"brush:java\">import java.util.Set;\r\nimport javax.inject.Inject;\r\nimport javax.inject.Named;\r\nimport javax.enterprise.context.spi.CreationalContext;\r\nimport javax.enterprise.inject.spi.Bean;\r\nimport javax.enterprise.inject.spi.BeanManager;\r\n\r\nimport com.javacodegeeks.Request;\r\n\r\n@Named\r\npublic class Dispatcher \r\n \r\n @Inject\r\n private BeanManager beanManager;\r\n \r\n public void dispatch(Request request) throws Exception {\r\n  String beanName = \"requestHandler_\" + request.getRequestTypeId();\r\n  RequestHandler myHandler = this.getBean(beanName, RequestHandler.class);\r\n  myHandler.handleRequest(request);\r\n }\r\n \r\n @SuppressWarnings(\"unchecked\")\r\n private &lt;T&gt; T getBean(String name, Class&lt;T&gt; clazz) throws Exception {\r\n  Set&lt;Bean&lt;?&gt;&gt; founds = beanManager.getBeans(name);\r\n  if ( founds.size()==0 ) {\r\n   throw new Exception(\"No such bean found: \"+name);\r\n  } else {\r\n   Bean&lt;T&gt; bean = (Bean&lt;T&gt;) founds.iterator().next();\r\n   CreationalContext&lt;T&gt; cc = beanManager.createCreationalContext(bean);\r\n          T instance = (T) beanManager.getReference(bean, clazz, cc);\r\n          return instance;\r\n  }\r\n }\r\n \r\n}\r\n<\/pre>\n<pre class=\"brush:java\">public interface RequestHandler  {\r\n public void handleRequest(Request request);\r\n}\r\n<\/pre>\n<pre class=\"brush:java\">@Named(\"requestHandler_typeA\")\r\npublic class HandlerA implements UseCaseHandler {\u2026}\r\n<\/pre>\n<pre class=\"brush:java\">@Named(\"requestHandler_typeB\")\r\npublic class HandlerB implements UseCaseHandler {...}\r\n<\/pre>\n<h2>  PART II&nbsp;: JMS<\/h2>\n<p>Java Messaging Service eases the implementation of a loosely coupled distributed communication.<br \/>\nThis is why it has become a classical technique in Enterprise Application Integration (EAI). <div style=\"display:inline-block; margin: 15px 0;\"> <div id=\"adngin-JavaCodeGeeks_incontent_video-0\" style=\"display:inline-block;\"><\/div> <\/div><\/p>\n<p>Spring has an outstanding JMS support. You can very quickly setup JMS producers or consumers,<br \/>\nwith destination resolvers, and optionally with an automatic conversion of JMS messages into pojos (and vice-versa). On the other hand, J2EE comes with a rich set of annotations in order to access or define JMS resources such as queue\/topics, connection or messages-oriented beans.<\/p>\n<p>Let&#8217;s start with a JMS client that receives messages, that is a message consumer (or subscriber):<\/p>\n<p>SPRING<\/p>\n<pre class=\"brush:xml\">&lt;bean id=\"jndiTemplate\" class=\"org.springframework.jndi.JndiTemplate\"&gt;\r\n &lt;property name=\"environment\"&gt;\r\n         &lt;props&gt;\u2026&lt;\/props&gt;\r\n &lt;\/property&gt;\r\n&lt;\/bean&gt;\r\n    \r\n&lt;bean id=\"jmsConnectionFactory\" class=\"org.springframework.jndi.JndiObjectFactoryBean\"&gt;\r\n      &lt;property name=\"jndiTemplate\" ref=\"jndiTemplate\" \/&gt;\r\n      &lt;property name=\"jndiName\" value=\"java:\/JmsXA\" \/&gt;\r\n&lt;\/bean&gt;\r\n    \r\n&lt;bean id=\"jndiDestResolver\"\r\n class=\"org.springframework.jms.support.destination.JndiDestinationResolver\"&gt;\r\n &lt;property name=\"jndiTemplate\" ref=\"jndiTemplate\" \/&gt;\r\n&lt;\/bean&gt;\r\n \r\n&lt;bean id=\"jmsContainer\"\r\n class=\"org.springframework.jms.listener.DefaultMessageListenerContainer\"&gt;\r\n &lt;property name=\"connectionFactory\" ref=\"jmsConnectionFactory\"\/&gt;   \r\n &lt;property name=\"destinationResolver\" ref=\"jndiDestResolver\"\/&gt;  \r\n &lt;property name=\"destinationName\" value=\"queue\/myQueue\"\/&gt;\r\n &lt;property name=\"messageListener\" ref=\"myMsgConsumer\" \/&gt;\r\n&lt;\/bean&gt;\r\n   \r\n&lt;bean id=\"myMsgConverter\" class=\"com.javacodegeeks.MsgToRequestConverter\"\/&gt;\r\n   \r\n&lt;bean id=\"myMsgConsumer\" class=\"com.javacodegeeks.MsgConsumer\"\/&gt;\r\n<\/pre>\n<pre class=\"brush:java\">import javax.jms.Message;\r\nimport javax.jms.MessageListener;\r\nimport org.springframework.beans.factory.annotation.Autowired;\r\nimport org.springframework.jms.support.converter.MessageConverter;\r\n\r\nimport com.javacodegeeks.Request;\r\nimport com.javacodegeeks.Dispatcher;\r\n        \r\n\/**\r\n * Example of message consumer (Message-Driven-Pojo) in Spring\r\n *\/\r\npublic class MsgConsumer implements MessageListener {\r\n \r\n    @Autowired\r\n    private MessageConverter msgConverter;\r\n \r\n    @Autowired\r\n    private Dispatcher dispatcher;\r\n     \r\n    public void onMessage(Message message) {       \r\n     try { \r\n      Request request = (Request) msgConverter.fromMessage(message);\r\n      dispatcher.dispatch(request); \r\n     } catch (Exception e) {\r\n    e.printStackTrace();    \r\n     } \r\n    }\r\n\r\n}\r\n<\/pre>\n<p>JAVA EE 6<\/p>\n<pre class=\"brush:java\">import javax.inject.Inject;\r\nimport javax.jms.Message;\r\nimport javax.jms.MessageListener;\r\nimport javax.ejb.MessageDriven;\r\nimport javax.ejb.ActivationConfigProperty;\r\n\r\nimport com.javacodegeeks.Request;\r\nimport com.javacodegeeks.Dispatcher ;\r\nimport com.javacodegeeks.MsgToRequestConverter;\r\n\r\n\/**\r\n * Example of message consumer (Message-Driven-Bean) in JEE\r\n *\/\r\n@MessageDriven(activationConfig = { \r\n @ActivationConfigProperty(propertyName=\"destinationType\", propertyValue=\"javax.jms.Queue\"),\r\n @ActivationConfigProperty(propertyName=\"destination\", propertyValue=\"queue\/myQueue\") \r\n} )     \r\npublic class MsgConsumer implements MessageListener  {\r\n \r\n @Inject\r\n     private MsgToRequestConverter msgConverter;\r\n\r\n @Inject \r\n private Dispatcher dispatcher;\r\n \r\n public void onMessage(Message message) {       \r\n     try { \r\n      Request request = msgConverter.fromMessage(message);\r\n      dispatcher.dispatch(request);      \r\n     } catch (Exception e) {\r\n  e.printStackTrace();     \r\n } \r\n    }\r\n    \r\n}\r\n<\/pre>\n<p>Let&#8217;s now code a JMS client that creates and sends messages, that is a message producer (or publisher):<\/p>\n<p>SPRING<\/p>\n<pre class=\"brush:xml\">&lt;bean id=\"jndiTemplate\" class=\"org.springframework.jndi.JndiTemplate\"&gt;\r\n &lt;property name=\"environment\"&gt;\r\n    &lt;props&gt;\u2026&lt;\/props&gt;\r\n &lt;\/property&gt;\r\n&lt;\/bean&gt;\r\n    \r\n&lt;bean id=\"jmsConnectionFactory\" class=\"org.springframework.jndi.JndiObjectFactoryBean\"&gt;\r\n      &lt;property name=\"jndiTemplate\" ref=\"jndiTemplate\" \/&gt;\r\n      &lt;property name=\"jndiName\" value=\"java:\/JmsXA\" \/&gt;\r\n&lt;\/bean&gt;\r\n    \r\n&lt;bean id=\"jndiDestResolver\"\r\n class=\"org.springframework.jms.support.destination.JndiDestinationResolver\"&gt;\r\n &lt;property name=\"jndiTemplate\" ref=\"jndiTemplate\" \/&gt;\r\n&lt;\/bean&gt;\r\n\r\n&lt;bean id=\"jmsTemplate\" class=\"org.springframework.jms.core.JmsTemplate\"&gt;\r\n &lt;property name=\"connectionFactory\" ref=\"jmsConnectionFactory\" \/&gt;\r\n &lt;property name=\"destinationResolver\" ref=\"jndiDestResolver\" \/&gt;\r\n &lt;property name=\"messageConverter\" ref=\"myMsgConverter\" \/&gt;\r\n&lt;\/bean&gt;\r\n    \r\n&lt;bean id=\"myMsgConverter\" class=\"com.javacodegeeks.MsgConverter\"&gt;\r\n<\/pre>\n<pre class=\"brush:java\">import org.springframework.stereotype.Component;\r\nimport org.springframework.beans.factory.annotation.Autowired;\r\nimport org.springframework.jms.core.JmsTemplate;\r\nimport com.javacodegeeks.Request;\r\n\r\n\/**\r\n * Example of message producer component in Spring\r\n *\/\r\n@Component \r\npublic class MsgProducer {\r\n\r\n @Autowired\r\n private JmsTemplate jmsTemplate;\r\n \r\n public void postRequest(Request request) throws Exception {\r\n  jmsTemplate.convertAndSend(\"queue\/myQueue\", request);\r\n }\r\n \r\n}\r\n<\/pre>\n<p>JAVA EE 6<\/p>\n<pre class=\"brush:java\">import javax.annotation.PostConstruct;\r\nimport javax.annotation.PreDestroy;\r\nimport javax.annotation.Resource;\r\nimport javax.inject.Inject;\r\nimport javax.jms.Connection;\r\nimport javax.jms.ConnectionFactory;\r\nimport javax.jms.JMSException;\r\nimport javax.jms.Message;\r\nimport javax.jms.MessageProducer;\r\nimport javax.jms.Queue;\r\nimport javax.jms.Session;\r\nimport javax.ejb.Stateless;\r\nimport javax.ejb.EJBException;\r\n\r\nimport com.javacodegeeks.Request;\r\nimport com.javacodegeeks.MsgToRequestConverter;\r\n\r\n\/**\r\n * Example of message producer (here a session bean) in JEE\r\n *\/\r\n@Stateless(name=\"msgProducer\")\r\npublic class MsgProducer {\r\n \r\n @Inject\r\n     private MsgToRequestConverter msgConverter;\r\n\r\n @Resource(mappedName=\"java:\/JmsXA\")\r\n private ConnectionFactory connectionFactory;\r\n \r\n @Resource(mappedName=\"queue\/myQueue\")\r\n private Queue queue;\r\n \r\n private Connection jmsConnection;\r\n\r\n\r\n @PostConstruct\r\n private void initialize() {\r\n  try {\r\n   jmsConnection = connectionFactory.createConnection();\r\n  } catch (JMSException e) {\r\n   throw new EJBException(e);\r\n  }\r\n }\r\n \r\n \r\n @PreDestroy\r\n private void cleanup() {\r\n  try {\r\n   if (jmsConnection!=null) jmsConnection.close();\r\n  } catch (JMSException e) {\r\n   throw new EJBException(e);\r\n  }\r\n }\r\n \r\n \r\n public void postRequest(Request request) throws Exception { \r\n  Session session = null;\r\n  MessageProducer producer = null;\r\n  try {\r\n   session = jmsConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);\r\n   producer = session.createProducer(queue);\r\n   Message msg = msgConverter.toMessage(request, session);\r\n       producer.send(msg);  \r\n  } finally { \r\n   try { \r\n    if (producer!=null) producer.close();\r\n    if (session!=null) session.close();\r\n   } catch (Exception e) {\r\n    System.err.println(\"JMS session not properly closed: \"+ e);\r\n   }\r\n  }\r\n }\r\n \r\n}\r\n<\/pre>\n<p>Remarks:<\/p>\n<ul style=\"text-align: left\">\n<li>Do not forget that, in contrary to JMS connections and JMS queues, JMS sessions are not thread-safe. Sessions should therefore not be shared by all bean instances, nor be created in the constructor or in a PostConstruct method.<\/li>\n<li>PostConstruct and PreDestroy methods should only throw runtime exceptions; this is the reason why JMS exceptions have to be wrapped (for instance) into EJB exceptions.<\/li>\n<\/ul>\n<h2>  Part III : Transaction management<\/h2>\n<p>The need for transactions is crucial in system architecture, especially with the advent of SOA. In such architectures, coarse-grained transactional services can be built by assembling existing \u2013 possibly also transactional \u2013 smaller services (\u201c<a href=\"http:\/\/java.sun.com\/developer\/Books\/j2ee\/jwsa\/JWSA_CH14.pdf\">microservices<\/a>\u201d). <\/p>\n<p>Both Spring and Java EE fulfills this need by offering a powerful declarative (annotation-based) transaction management.<\/p>\n<p>SPRING<\/p>\n<pre class=\"brush:xml\">&lt;!-- Recognize @Transactional annotations in our beans --&gt; \r\n&lt;tx:annotation-driven transaction-manager=\"txManager\"\/&gt;\r\n\r\n&lt;!-- The transaction manager to use (here the JPA implementation) --&gt; \r\n&lt;bean id=\"txManager\" class=\"org.springframework.orm.jpa.JpaTransactionManager\"&gt;\r\n ...\r\n&lt;\/bean&gt;\r\n<\/pre>\n<pre class=\"brush:java\">import org.springframework.stereotype.Service;\r\nimport org.springframework.transaction.annotation.Transactional;\r\nimport org.springframework.transaction.annotation.Propagation;\r\n\r\nimport com.javacodegeeks.Request;\r\nimport com.javacodegeeks.RequestProcessor;\r\n\r\n@Service\r\npublic class RequestProcessorImpl implements RequestProcessor {\r\n\r\n @Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class)\r\n public void process(Request request) throws Exception {\r\n  ...\r\n }\r\n \r\n}\r\n<\/pre>\n<p>JAVA EE 6<\/p>\n<pre class=\"brush:java\">import javax.ejb.Stateless;\r\nimport javax.ejb.TransactionAttribute;\r\nimport javax.ejb.TransactionAttributeType;\r\nimport javax.ejb.TransactionManagement;\r\nimport javax.ejb.TransactionManagementType;\r\n\r\nimport com.javacodegeeks.Request;\r\nimport com.javacodegeeks.RequestProcessor;\r\n\r\n@Stateless\r\n@TransactionManagement(value=TransactionManagementType.CONTAINER)\r\npublic class RequestProcessorImpl implements RequestProcessor {\r\n\r\n @TransactionAttribute(TransactionAttributeType.REQUIRED)\r\n public void process(Request request) throws Exception {\r\n  ...\r\n }\r\n \r\n}\r\n<\/pre>\n<p>Be very careful with runtime\/unchecked exceptions in Java EE. By default, they are automatically wrapped by the EJB container into an EJBException, which may cause surprising results (especially in try&#8230;catch statements!). If you need finer tuning of rollback cases, consider tagging such runtime exceptions as applicative exceptions, either using the @ApplicationException annotation, or by augmenting the ejb descriptor like this:<\/p>\n<pre class=\"brush:xml\">&lt;ejb-jar&gt;\r\n   &lt;assembly-descriptor&gt;\r\n    &lt;application-exception&gt;\r\n      &lt;exception-class&gt;java.lang.NullPointerException&lt;\/exception-class&gt;\r\n      &lt;rollback&gt;true&lt;\/rollback&gt;\r\n    &lt;\/application-exception&gt;\r\n   &lt;\/assembly-descriptor&gt;\r\n&lt;\/ejb-jar&gt; \r\n<\/pre>\n<h2>  Part IV&nbsp;: Restful web services<\/h2>\n<p>Enterprise applications often need to expose some of their services to the outside world, typically through internet. This is where web services are coming into play. Like JMS (for asynchronous communication), web services are another classical integration technique for implementing a synchronous, request-response oriented, communication using XML (or JSON) as exchange format.<\/p>\n<p>SPRING<\/p>\n<pre class=\"brush:xml\">&lt;servlet&gt;\r\n &lt;servlet-name&gt;ws&lt;\/servlet-name&gt;\r\n &lt;servlet-class&gt;org.springframework.web.servlet.DispatcherServlet&lt;\/servlet-class&gt;\r\n&lt;\/servlet&gt;\r\n&lt;servlet-mapping&gt;\r\n &lt;servlet-name&gt;ws&lt;\/servlet-name&gt;\r\n &lt;url-pattern&gt;\/services\/*&lt;\/url-pattern&gt;\r\n&lt;\/servlet-mapping&gt;\r\n<\/pre>\n<pre class=\"brush:xml\">&lt;!-- Dispatch requests to controllers + use JAXB (if found in the classpath) --&gt;\r\n&lt;mvc:annotation-driven \/&gt;\r\n<\/pre>\n<pre class=\"brush:java\">import org.springframework.beans.factory.annotation.Autowired;\r\nimport org.springframework.stereotype.Controller;\r\nimport org.springframework.web.bind.annotation.PathVariable;\r\nimport org.springframework.web.bind.annotation.RequestMapping;\r\nimport org.springframework.web.bind.annotation.RequestMethod;\r\nimport org.springframework.web.bind.annotation.ResponseBody;\r\n\r\nimport com.javacodegeeks.Geek;\r\nimport com.javacodegeeks.GeekService;\r\n\r\n@Controller\r\n@RequestMapping(\"\/geeks\")\r\npublic class GeekWebService {\r\n \r\n   @Autowired\r\n   GeekService bizService;\r\n   \r\n  @RequestMapping(value=\"\/{id}\", method=RequestMethod.GET)\r\n  @ResponseBody\r\n  public Geek getGeek(@PathVariable(\"id\") long geekId) {\r\n     return bizService.findGeek(geekId);\r\n }\r\n \r\n}\r\n<\/pre>\n<pre class=\"brush:java\">import javax.xml.bind.annotation.XmlAttribute;\r\nimport javax.xml.bind.annotation.XmlElement;\r\nimport javax.xml.bind.annotation.XmlRootElement;\r\n \r\n@XmlRootElement(name=\"geek\")\r\npublic class Geek {\r\n \r\n private String name;\r\n private Long id;\r\n \r\n @XmlElement\r\n public String getName() {\r\n  return name;\r\n }\r\n \r\n public void setName(String name) {\r\n  this.name = name;\r\n }\r\n \r\n @XmlAttribute\r\n public Long getId() {\r\n  return id;\r\n }\r\n \r\n public void setId(Long id) {\r\n  this.id = id;\r\n }\r\n \r\n}\r\n<\/pre>\n<p>JAVA EE 6<\/p>\n<pre class=\"brush:java\">import javax.inject.Inject;\r\nimport javax.ws.rs.GET;\r\nimport javax.ws.rs.Path;\r\nimport javax.ws.rs.PathParam;\r\nimport javax.ws.rs.Produces;\r\nimport javax.ws.rs.core.MediaType;\r\n\r\nimport com.javacodegeeks.Geek;\r\nimport com.javacodegeeks.GeekService;\r\n\r\n@Path(\"\/geeks\")\r\n@Produces(MediaType.APPLICATION_XML)\r\npublic class GeekWebService {\r\n\r\n @Inject\r\n  GeekService bizService;\r\n   \r\n @GET\r\n @Path(\"\/{id}\")\r\n public Geek getGeek(@PathParam(\"id\") long geekId) {\r\n    return bizService.findGeek(geekId);\r\n  }\r\n  \r\n}\r\n<\/pre>\n<pre class=\"brush:java\">import javax.xml.bind.annotation.XmlAttribute;\r\nimport javax.xml.bind.annotation.XmlElement;\r\nimport javax.xml.bind.annotation.XmlRootElement;\r\n \r\n@XmlRootElement(name=\"geek\")\r\npublic class Geek {\r\n \r\n private String name;\r\n private Long id;\r\n \r\n @XmlElement\r\n public String getName() {\r\n  return name;\r\n }\r\n \r\n public void setName(String name) {\r\n  this.name = name;\r\n }\r\n \r\n @XmlAttribute\r\n public Long getId() {\r\n  return id;\r\n }\r\n \r\n public void setId(Long id) {\r\n  this.id = id;\r\n }\r\n \r\n}\r\n<\/pre>\n<p>Remark: some JAX-RS implementations, like JBoss RestEasy, do not require to modify the web.xml in order to configure and install web services&#8230;<\/p>\n<h2>  PART V : Conclusion<\/h2>\n<p>Arguing that things are in Spring much simpler, much lighter than in Java EE is not &#8211; more exactly, no more \u2013 true. It is merely a matter of taste. Furthermore, recent Java EE 6 application servers (like GlassFish 3 or JBoss 6 &amp; 7) are <a href=\"http:\/\/agoncal.wordpress.com\/2011\/10\/20\/o-java-ee-6-application-servers-where-art-thou\/\">booting<\/a> really fast, actually nearly as fast as Spring applications. Nevertheless, in a &#8220;best-of-breed&#8221; perspective, it may still be interesting to combine both technologies; this will be the subject of my next post on JCG :-)<\/p>\n<p><strong><i>Reference: <\/i><\/strong><i> From Spring to Java EE 6<\/i> from our <a href=\"http:\/\/www.javacodegeeks.com\/p\/w4g.html\">W4G partner<\/a> <a href=\"http:\/\/be.linkedin.com\/in\/bernardligny\">Bernard Ligny<\/a>.<\/p>\n<p><strong><i>Related Articles :<\/i><\/strong><\/p>\n<ul>\n<li><a href=\"http:\/\/www.javacodegeeks.com\/2011\/11\/what-is-cdi-how-does-it-relate-to-ejb.html\">What Is CDI, How Does It Relate to @EJB And Spring?<\/a><\/li>\n<li><a href=\"http:\/\/www.javacodegeeks.com\/2011\/11\/spring-singleton-request-session-beans.html\">Spring Singleton, Request, Session Beans and Thread Safety<\/a><\/li>\n<li><a href=\"http:\/\/www.javacodegeeks.com\/2011\/11\/devoxx-2011-impressions.html\">Devoxx 2011 Impressions<\/a><\/li>\n<li><a href=\"http:\/\/www.javacodegeeks.com\/2011\/10\/java-ee6-events-lightweight-alternative.html\">Java EE6 Events: A lightweight alternative to JMS<\/a><\/li>\n<li><a href=\"http:\/\/www.javacodegeeks.com\/2011\/10\/java-ee6-cdi-named-components-and.html\">Java EE6 CDI, Named Components and Qualifiers<\/a><\/li>\n<li><a href=\"http:\/\/www.javacodegeeks.com\/2011\/10\/java-ee-past-present-cloud-7.html\">Java EE Past, Present, &amp; Cloud 7<\/a><\/li>\n<li><a href=\"http:\/\/www.javacodegeeks.com\/2011\/11\/java-se-7-8-9-moving-java-forward.html\">Java SE 7, 8, 9 &#8211; Moving Java Forward<\/a><\/li>\n<\/ul>\n<\/div>\n","protected":false},"excerpt":{"rendered":"<p>I recently worked on a quite complex project mixing many Java EE 6 technologies (such as JPA, JAXB, JMS, JTA, JAX-RS, etc&#8230;). For productivity and planning reasons, the prototyped application was designed as a standalone pure Spring application. When the development of the real application started, we re-challenged our initial choice (i.e. Spring v3) and &hellip;<\/p>\n","protected":false},"author":310,"featured_media":240,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[8],"tags":[214,289,30,206],"class_list":["post-666","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-enterprise-java","tag-bernard-ligny","tag-java-ee6","tag-spring","tag-w4g"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.5 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>From Spring to Java EE 6 - Java Code Geeks<\/title>\n<meta name=\"description\" content=\"I recently worked on a quite complex project mixing many Java EE 6 technologies (such as JPA, JAXB, JMS, JTA, JAX-RS, etc...). For productivity and\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"From Spring to Java EE 6 - Java Code Geeks\" \/>\n<meta property=\"og:description\" content=\"I recently worked on a quite complex project mixing many Java EE 6 technologies (such as JPA, JAXB, JMS, JTA, JAX-RS, etc...). For productivity and\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html\" \/>\n<meta property=\"og:site_name\" content=\"Java Code Geeks\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/javacodegeeks\" \/>\n<meta property=\"article:published_time\" content=\"2011-11-27T14:12:00+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2012-10-22T19:00:15+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/spring-logo.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"150\" \/>\n\t<meta property=\"og:image:height\" content=\"150\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Bernard Ligny\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@javacodegeeks\" \/>\n<meta name=\"twitter:site\" content=\"@javacodegeeks\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Bernard Ligny\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"13 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2011\\\/11\\\/from-spring-to-java-ee-6.html#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2011\\\/11\\\/from-spring-to-java-ee-6.html\"},\"author\":{\"name\":\"Bernard Ligny\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/person\\\/36ff6ecf6006ef67a8c8cfa1223c0852\"},\"headline\":\"From Spring to Java EE 6\",\"datePublished\":\"2011-11-27T14:12:00+00:00\",\"dateModified\":\"2012-10-22T19:00:15+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2011\\\/11\\\/from-spring-to-java-ee-6.html\"},\"wordCount\":1180,\"commentCount\":5,\"publisher\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2011\\\/11\\\/from-spring-to-java-ee-6.html#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2012\\\/10\\\/spring-logo.jpg\",\"keywords\":[\"Bernard Ligny\",\"Java EE6\",\"Spring\",\"W4G\"],\"articleSection\":[\"Enterprise Java\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.javacodegeeks.com\\\/2011\\\/11\\\/from-spring-to-java-ee-6.html#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2011\\\/11\\\/from-spring-to-java-ee-6.html\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2011\\\/11\\\/from-spring-to-java-ee-6.html\",\"name\":\"From Spring to Java EE 6 - Java Code Geeks\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2011\\\/11\\\/from-spring-to-java-ee-6.html#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2011\\\/11\\\/from-spring-to-java-ee-6.html#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2012\\\/10\\\/spring-logo.jpg\",\"datePublished\":\"2011-11-27T14:12:00+00:00\",\"dateModified\":\"2012-10-22T19:00:15+00:00\",\"description\":\"I recently worked on a quite complex project mixing many Java EE 6 technologies (such as JPA, JAXB, JMS, JTA, JAX-RS, etc...). For productivity and\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2011\\\/11\\\/from-spring-to-java-ee-6.html#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.javacodegeeks.com\\\/2011\\\/11\\\/from-spring-to-java-ee-6.html\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2011\\\/11\\\/from-spring-to-java-ee-6.html#primaryimage\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2012\\\/10\\\/spring-logo.jpg\",\"contentUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2012\\\/10\\\/spring-logo.jpg\",\"width\":150,\"height\":150,\"caption\":\"spring-interview-questions-answers\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2011\\\/11\\\/from-spring-to-java-ee-6.html#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.javacodegeeks.com\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Java\",\"item\":\"https:\\\/\\\/www.javacodegeeks.com\\\/category\\\/java\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Enterprise Java\",\"item\":\"https:\\\/\\\/www.javacodegeeks.com\\\/category\\\/java\\\/enterprise-java\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"From Spring to Java EE 6\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#website\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/\",\"name\":\"Java Code Geeks\",\"description\":\"Java Developers Resource Center\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#organization\"},\"alternateName\":\"JCG\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.javacodegeeks.com\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#organization\",\"name\":\"Exelixis Media P.C.\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2022\\\/06\\\/exelixis-logo.png\",\"contentUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2022\\\/06\\\/exelixis-logo.png\",\"width\":864,\"height\":246,\"caption\":\"Exelixis Media P.C.\"},\"image\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/javacodegeeks\",\"https:\\\/\\\/x.com\\\/javacodegeeks\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/person\\\/36ff6ecf6006ef67a8c8cfa1223c0852\",\"name\":\"Bernard Ligny\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/d8a3f3e531361e58360c1dc35f8cb4b4c4f176898ad8a9854ff5f49544e5029c?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/d8a3f3e531361e58360c1dc35f8cb4b4c4f176898ad8a9854ff5f49544e5029c?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/d8a3f3e531361e58360c1dc35f8cb4b4c4f176898ad8a9854ff5f49544e5029c?s=96&d=mm&r=g\",\"caption\":\"Bernard Ligny\"},\"description\":\"Bernard is a Senior IT Architect working on the Java ecosystem since 1999 in many different functional areas. He feels passionate about building elegant, scalable and effective Java solutions using the most appropriate software and techniques, with these last years a particular interest in E.A.I.\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/author\\\/bernard-ligny\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"From Spring to Java EE 6 - Java Code Geeks","description":"I recently worked on a quite complex project mixing many Java EE 6 technologies (such as JPA, JAXB, JMS, JTA, JAX-RS, etc...). For productivity and","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html","og_locale":"en_US","og_type":"article","og_title":"From Spring to Java EE 6 - Java Code Geeks","og_description":"I recently worked on a quite complex project mixing many Java EE 6 technologies (such as JPA, JAXB, JMS, JTA, JAX-RS, etc...). For productivity and","og_url":"https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html","og_site_name":"Java Code Geeks","article_publisher":"https:\/\/www.facebook.com\/javacodegeeks","article_published_time":"2011-11-27T14:12:00+00:00","article_modified_time":"2012-10-22T19:00:15+00:00","og_image":[{"width":150,"height":150,"url":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/spring-logo.jpg","type":"image\/jpeg"}],"author":"Bernard Ligny","twitter_card":"summary_large_image","twitter_creator":"@javacodegeeks","twitter_site":"@javacodegeeks","twitter_misc":{"Written by":"Bernard Ligny","Est. reading time":"13 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html#article","isPartOf":{"@id":"https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html"},"author":{"name":"Bernard Ligny","@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/person\/36ff6ecf6006ef67a8c8cfa1223c0852"},"headline":"From Spring to Java EE 6","datePublished":"2011-11-27T14:12:00+00:00","dateModified":"2012-10-22T19:00:15+00:00","mainEntityOfPage":{"@id":"https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html"},"wordCount":1180,"commentCount":5,"publisher":{"@id":"https:\/\/www.javacodegeeks.com\/#organization"},"image":{"@id":"https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html#primaryimage"},"thumbnailUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/spring-logo.jpg","keywords":["Bernard Ligny","Java EE6","Spring","W4G"],"articleSection":["Enterprise Java"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html","url":"https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html","name":"From Spring to Java EE 6 - Java Code Geeks","isPartOf":{"@id":"https:\/\/www.javacodegeeks.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html#primaryimage"},"image":{"@id":"https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html#primaryimage"},"thumbnailUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/spring-logo.jpg","datePublished":"2011-11-27T14:12:00+00:00","dateModified":"2012-10-22T19:00:15+00:00","description":"I recently worked on a quite complex project mixing many Java EE 6 technologies (such as JPA, JAXB, JMS, JTA, JAX-RS, etc...). For productivity and","breadcrumb":{"@id":"https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html#primaryimage","url":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/spring-logo.jpg","contentUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/spring-logo.jpg","width":150,"height":150,"caption":"spring-interview-questions-answers"},{"@type":"BreadcrumbList","@id":"https:\/\/www.javacodegeeks.com\/2011\/11\/from-spring-to-java-ee-6.html#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.javacodegeeks.com\/"},{"@type":"ListItem","position":2,"name":"Java","item":"https:\/\/www.javacodegeeks.com\/category\/java"},{"@type":"ListItem","position":3,"name":"Enterprise Java","item":"https:\/\/www.javacodegeeks.com\/category\/java\/enterprise-java"},{"@type":"ListItem","position":4,"name":"From Spring to Java EE 6"}]},{"@type":"WebSite","@id":"https:\/\/www.javacodegeeks.com\/#website","url":"https:\/\/www.javacodegeeks.com\/","name":"Java Code Geeks","description":"Java Developers Resource Center","publisher":{"@id":"https:\/\/www.javacodegeeks.com\/#organization"},"alternateName":"JCG","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.javacodegeeks.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/www.javacodegeeks.com\/#organization","name":"Exelixis Media P.C.","url":"https:\/\/www.javacodegeeks.com\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/logo\/image\/","url":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2022\/06\/exelixis-logo.png","contentUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2022\/06\/exelixis-logo.png","width":864,"height":246,"caption":"Exelixis Media P.C."},"image":{"@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/javacodegeeks","https:\/\/x.com\/javacodegeeks"]},{"@type":"Person","@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/person\/36ff6ecf6006ef67a8c8cfa1223c0852","name":"Bernard Ligny","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/d8a3f3e531361e58360c1dc35f8cb4b4c4f176898ad8a9854ff5f49544e5029c?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/d8a3f3e531361e58360c1dc35f8cb4b4c4f176898ad8a9854ff5f49544e5029c?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/d8a3f3e531361e58360c1dc35f8cb4b4c4f176898ad8a9854ff5f49544e5029c?s=96&d=mm&r=g","caption":"Bernard Ligny"},"description":"Bernard is a Senior IT Architect working on the Java ecosystem since 1999 in many different functional areas. He feels passionate about building elegant, scalable and effective Java solutions using the most appropriate software and techniques, with these last years a particular interest in E.A.I.","url":"https:\/\/www.javacodegeeks.com\/author\/bernard-ligny"}]}},"_links":{"self":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/posts\/666","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/users\/310"}],"replies":[{"embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/comments?post=666"}],"version-history":[{"count":0,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/posts\/666\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/media\/240"}],"wp:attachment":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/media?parent=666"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/categories?post=666"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/tags?post=666"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}