One of the easiest Framework to create webservices is Apache CXF, the new version of XFire. The main difficulty is, as alway, to integrate many other frameworks.

Personnaly i use Spring and Hibernate more than any others, here is an example showing how to make Spring, Hibernate and CXF working together, with annotations.

Interesting parts of POM:

Version’s declaration :

<properties>
    <cxf.version>[2,)</cxf.version>
    <spring.version>2.5.6</spring.version>
    <servlet.version>2.5</servlet.version>
    <hibernate-annotations.version>3.4.0.GA</hibernate-annotations.version>
    <hibernate-commons-annotations.version>3.3.0.ga</hibernate-commons-annotations.version>
    <hibernate-core.version>3.3.1.ga</hibernate-core.version>
    <hsqldb.version>1.8.0.7</hsqldb.version>
    <junit.version>4.4</junit.version>
</properties>

Exclude the incompatibles version of dependencies :

<dependency>
           <groupId>org.hibernate</groupId>
           <artifactId>hibernate</artifactId>
           <version>3.2.1.ga</version>
           <exclusions>
                    <exclusion>
                             <groupId>asm</groupId>
                             <artifactId>asm</artifactId>
                    </exclusion>
                    <exclusion>
                             <groupId>asm</groupId>
                             <artifactId>asm-attrs</artifactId>
                    </exclusion>
                    <exclusion>
                             <groupId>cglib</groupId>
                             <artifactId>cglib</artifactId>
                    </exclusion>
           </exclusions>
</dependency>

Replace by the compatible dependencies :

 <dependency>
               <groupId>cglib</groupId>
               <artifactId>cglib-nodep</artifactId>
               <version>2.1_3</version>
 </dependency>

Define the Interface

@WebService defines the interface as the endpoint of a web service. The endpoint will be used to generate the WSDL.

Service’s implementation:

The annotation @WebService(endpointInterface = "com.lb.jwitter.service.UserService") defines  UserServiceImpl as the web service’s implémentation.

The other annotation @Service("userService") allow this class to be used as a classic Spring service. In this way the core logic of the service is not tied to the communication layer.

Webservice configuration :

Use a separate XML file to declare your Web services :

By using implementor="#userService" you define a Spring Bean instead of a typical class.

Download the source code [ZIP]

To import the project in Eclipse execute "mvn eclipse:eclipse" and import the project.

Les problèmes récurrents que l’on rencontre dans ces cas là sont:

• Trop de données présentées sur le même écran
• Le volume de données transmis via le réseau est trop grand pour permettre de bonnes performances
• Les incompatibilités entre les navigateurs induisent de nombreux bugs, allonge les phases de recette pour les différents navigateurs etc.

En voyant arriver les technologies AJAX et JSF je me suis dis que la solution commençait peut-être a se dessiner: des Taglibs générant le code client adapté aux navigateurs, des appels asynchrones n’envoyant et ne recevant que les données nécessaires…

Force est de constater que l’on est encore loin du compte.

L’année dernière j’ai eu a m’intéresser à la pertinence de Flex pour l’un des projets sur lequel je travaillais et depuis j’ai du mal a imaginer comment cela pourrait ne pas être l’avenir des RIA Java.

Flex est à l’IHM ce que Java est au serveur:

• Multi-plateformes grâce à sa JVM
• Multi-navigateurs grâce au plug-in Flash Player
• Compile once – run everywhere

Dans les prochaines semaines je partagerai quelques exemples de code, mais commençons par les bases, le tout sans utiliser le Flex Builder (bientôt peut-être), mais simplement le Flex SDK et Eclipse.

1. Téléchargez le Flex SDK  (ZIP)
2. Une fois décompressé, ajout le répertoire du SDK au path de votre machine.
3. Exécutez la commande:  “amxmlc -version” afin de vérifier que l’installation est correcte.

Une de ces framework est Apache CXF. En lui même assez simple d’utilisation la difficulté réside toujours dans l’intégration avec d’autre composants.

A titre personnel les framework que j’utilise le plus sont Spring et Hibernate, voici donc un exemple intégrant les 3 via des annotations.

Les parties intéressantes du POM:

Les versions:

<properties>
    <cxf.version>[2,)</cxf.version>
    <spring.version>2.5.6</spring.version>
    <servlet.version>2.5</servlet.version>
    <hibernate-annotations.version>3.4.0.GA</hibernate-annotations.version>
    <hibernate-commons-annotations.version>3.3.0.ga</hibernate-commons-annotations.version>

    <hibernate-core.version>3.3.1.ga</hibernate-core.version>
    <hsqldb.version>1.8.0.7</hsqldb.version>
    <junit.version>4.4</junit.version>
</properties>

Exclusions des librairies incompatibles:

<dependency>
	<groupId>org.hibernate</groupId>
	<artifactId>hibernate</artifactId>
	<version>3.2.1.ga</version>

	<exclusions>
		<exclusion>
			<groupId>asm</groupId>
			<artifactId>asm</artifactId>
		</exclusion>
		<exclusion>
			<groupId>asm</groupId>
			<artifactId>asm-attrs</artifactId>
		</exclusion>
		<exclusion>
			<groupId>cglib</groupId>
			<artifactId>cglib</artifactId>
		</exclusion>
	</exclusions>
</dependency>

Inclusions des librairies compatibles:
 <dependency>
	    <groupId>cglib</groupId>
    	<artifactId>cglib-nodep</artifactId>
    	<version>2.1_3</version>
 </dependency>

Le code:

import java.util.List;

import javax.jws.WebService;

import com.lb.jwitter.User;

@WebService
public interface UserService {

/**
* Return true if the user already exist, false if not
* @param username The username to search
* @return
*/
Boolean exist(String username);

/**
* Return a list containing all users
* @return A list containing all users
*/
List<User> findAll();

/**
* Create a User with the given username
* @param username The user name
*/
void createUser(String username);

/**
* Search a user with the given username
* @param username The user name to search
* @return The user with the given username, null if it doesn't exist
*/
User findByUsername(String username);

/**
* Return a user with the given id
* @param id The user id
* @return A user if the id exist, null otherwise
*/
User get(Long id);

/**
* Create 5 users with random user names
*/
void createUsers();

}

L'annotation @Webservice permet de définir l'interface comme endpoint d'un web service.

L'implémentation du service:

import javax.jws.WebService;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.lb.jwitter.User;
import com.lb.jwitter.hibernate.UserDao;

/**
* @author lbouin
*/
@Service("userService")
@WebService(endpointInterface = "com.lb.jwitter.service.UserService")
public class UserServiceImpl implements UserService,Serializable{

private Log log = LogFactory.getLog(UserServiceImpl.class);

private static final long serialVersionUID = -8740095022264495229L;

@Autowired
@Qualifier("userHibernateDao")
private UserDao userDao;

...

L'annotation @WebService(endpointInterface = "com.lb.jwitter.service.UserService") permet de définir la classe ci-dessus comme implémentation du web service déclaré par l'interface.

L'annotation @Service("userService") permet de définir la classe comme un service Spring, ce qui découple le service de la couche de protocole (le web service). Ce service pourra être utilisé comme un service standalone.

Configuration du service:

Dans un fichier xml, autre que celui de Spring, il faut configurer les web services: <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jaxws="http://cxf.apache.org/jaxws"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">

<import resource="classpath:META-INF/cxf/cxf.xml" />
<import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
<import resource="classpath:META-INF/cxf/cxf-servlet.xml" />

<jaxws:endpoint
id="userWS" implementor="#userService"
implementorClass="com.lb.jwitter.service.UserServiceImpl"
address="/User" />

<jaxws:endpoint
id="pingWS" implementor="com.lb.jwitter.service.PingServiceImpl"
address="/Marco" />

</beans>

-----------------------------------------------------------------------

Dans la déclaration ci dessous on trouve les éléments d'interaction entre Spring et CXF:

<jaxws:endpoint  id="userWS" implementor="#userService" implementorClass="com.lb.jwitter.service.UserServiceImpl" address="/User" />

---

implementor="#userService" déclare que l'implémentation du web service est un bean Spring.

Telecharger le code source [ZIP]

For this sample i will use HSQLDB for the “in memory” feature.

The sample app allow you to create “Users” containing just a username and Id.

Frameworks:

• Spring – 2.5.3
• Hibernate – 3.2.1.ga
• Hibernate-annotations – 3.3.0.ga
• HSQLDB – 1.8.0.7
• JSF – 1.2_04-p02
• Richfaces – 3.2.2.SR1
• Facelets – 1.1.14

The Value Object:

package com.lb.jwitter;

import java.io.Serializable;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.Id;

import javax.persistence.Table;

@Entity

@Table (name=”UTILISATEURS”)

public class User implements Serializable {

private static final long serialVersionUID = -1989579066723007050L;

private Long id;

private String username;

@Id

@GeneratedValue

public Long getId() {

return id;

}

public void setId(Long id) {

this.id = id;

}

public String getUsername() {

return username;

}

public void setUsername(String username) {

this.username = username;

}

}

@Entity : Declares the value object as an entity managed by the persistance API.

@Table : Defines the table’s name in which the entities will be stored.

@Id : Declares the variable behind the getter as the primary key for the entity.

@GeneratedValue : The primary key will be generated automaticaly.

References

• Hibernate Entity Manager
• Sun – Java persistence API
• JSR 220: EJB 3.0

Writing the DAO :

import java.util.List;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.hibernate.SessionFactory;

import org.hibernate.criterion.Projections;

import org.hibernate.criterion.Restrictions;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.stereotype.Repository;

import com.lb.jwitter.User;

import com.lb.utils.orm.hibernate.HibernateGenericDao;

@Repository

public class UserHibernateDao extends HibernateGenericDao<User, Long> implements UserDaoInterface {

private Log log = LogFactory.getLog(UserHibernateDao.class);

@Autowired

public UserHibernateDao(@Qualifier(“sessionFactory”) SessionFactory sessionFactory) {

super(sessionFactory);

}

public List<User> findAll() {

return getSession().createCriteria(User.class).list();

}

}

I wrote a class HibernateGenericDao to implements the CRUD methods, you can find it in the source code.

The Service with Autowired DAO

import java.io.Serializable;

import java.util.List;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import com.lb.jwitter.User;

import com.lb.jwitter.hibernate.UserDaoInterface;

@Service(“userService”)

@Transactional

public class UserService implements UserServiceInterface,Serializable{

private Log log = LogFactory.getLog(UserService.class);

@Autowired

private UserDaoInterface userDao;

public List<User> findAll(){

List<User> result = getUserDao().findAll();

log.info(“Number of user in DB:: “+result.size());

return result;

}

public UserDaoInterface getUserDao() {

return userDao;

}

/**

* @param userDao the userDao to set

*/

public void setUserDao(UserDaoInterface userDao) {

this.userDao = userDao;

}

}

Writing the Managed Bean

import java.io.Serializable;
import java.util.List;

import javax.faces.application.FacesMessage;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.validator.ValidatorException;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import com.lb.jwitter.User;
import com.lb.jwitter.service.UserServiceInterface;

@Component
@Qualifier(“userBean”)
@Scope(“session”)
public class UserBean implements Serializable {

private Log log = LogFactory.getLog(UserBean.class);

@Autowired
private UserServiceInterface userService;

public List<User> getAllUsers(){
return this.userService.findAll();
}

public UserServiceInterface getUserService() {
return userService;
}

/**
* @param userService the userService to set
*/
public void setUserService(UserServiceInterface userService) {
this.userService = userService;
}

}

Download the source code

Sometimes the database is not available, so your DAO is not loaded which results in an exception in your managed bean because the Spring service can’t be autowired.

Here is a simple application listener looking for the beans created by Spring and JSF during the context’s initialization.

CheckBeansListener.java:

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeansException;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

/**
* @author lbouin
*/
public class CheckBeansListener implements ServletContextListener {

private Log log = LogFactory.getLog(CheckBeansListener.class);

/**
* @see javax.servlet.ServletContextListener#contextDestroyed(javax.servlet.ServletContextEvent)
*/
public void contextDestroyed(ServletContextEvent sce) {
log.info(“CONTEXT DESTROYED”);

}

/**
* @see javax.servlet.ServletContextListener#contextInitialized(javax.servlet.ServletContextEvent)
*/
public void contextInitialized(ServletContextEvent sce) {
log.info(“CONTEXT INITIALIZED”);

ServletContext servletContext = sce.getServletContext();
sce.getServletContext().getAttributeNames();
WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);

String[] beanDefinitionNames = wac.getBeanDefinitionNames();

for (int i = 0; i < beanDefinitionNames.length; i++) {
try {
log.info(“Bean ” + i + ” : ” + beanDefinitionNames[i] + ” : “
+ wac.getBean(beanDefinitionNames[i]));
} catch (BeansException e) {
log.warn(“If ‘session’ scope message, ignore this: “+e.getMessage());
}
}
}

}

Configure the listener:

In your web.xml file:

<listener>
<listener-class>com.lb.front.util.CheckBeansListener</listener-class>
</listener>

Result

In your console, or log file, you should see this find of trace is the bean is correctly loaded:

INFO: Bean 0 : userService : com.lb.service.UserService@dafcbf

I use another stuff, which is only basic HTML refresh meta and it doesn’t require you to configure in the web.xml.

index.html:

<html>
<head>
<meta content=”text/html; charset=UTF-8″ http-equiv=”content-type” />
<meta http-equiv=”refresh” content=”0; url=page1.faces” />
</head>

<body>
</body>
</html>

I started this blog to share what i think usefull for other developers, here we are !

When i start a new project, or a simple POC, i spent time looking for the good configuration, the good JARs… I was so tired of this that i decided to make some POM to start quickly.

Inspired by my current mission i created a template for these APIs :

• JSF – 1.2_04-p02
• Richfaces – 3.2.2.SR1
• Facelets – 1.1.14
• Spring – 2.5.3

As many developers i’m not fan of maven but it’s almost mandatory, i use Eclipse as my IDE. To be comfortable the POM integrates the configuration for the maven’s plugin. You can easily import these template in Eclipse.

How to use the template:

• unzip the the source code below
• run   mvn install in the unzipped directory
• if you installed the maven’s plugin for Eclipse run  mvn eclipse:eclipse
• in Eclipse choose: “File>Import>Existing projects into workspace” and select the project’s directory

download source code

You can deploy the WAR on Tomcat6 through Eclipse and run the project: http://localhost:8080/basic-richfaces-facelets-annotations/page1.faces

This template include annotations with Spring, variables resolver for JSF+Spring and richfaces tags.

For JBoss, see the comments in the POM’s dependencies.

If this post was usefull just add a comment. Any problem ? Contact me.

What could it mean for developers ?

We will be able to develop GWT applications in a new way (not sure…), GWT for the UI, REST to communicate with the business logic ( in Spring, EJB… ) without spending one week configuring the environment.

So maybe our architecture department would open his mind, and our users could have benefit of truly RIA, i mean not a JSF/RichFaces/FLEX/Javascript/… stuff trying to look and behave like a web 2.0 webapp.

It just happened  but i’ll take a look at the JBoss’s team work on regular basis.

How many days fighting with the layouts and the listener.

If you remember that so you’ll be a little bit afraid of the first lines of GWT.

To start simple see the panel’s section of GWT web site here. For this sample i chose to reuse the Mail application available in the “samples” directory of the GWT’s ditribution, a classical “header+left menu+right panel” layout.

By modifying the left menu, and a few minutes of Photoshop for the logo it looks like this :

First step Layout

In your main class, the one extending EntryPoint declare your panels:


private TopPanel topPanel = new TopPanel(images); //see the Mail application for implementation
private VerticalPanel rightPanel = new VerticalPanel();
private LeftMenu leftmenu = new LeftMenu(images);
private MailList mailList; //see the Mail application for implementation
private MailDetail mailDetail = new MailDetail(); //see the Mail application for implementation

The onModuleLoad() method should look like this:

public void onModuleLoad() {

singleton = this;

topPanel.setWidth(“100%”);

mailList = new MailList();
mailList.setWidth(“100%”);

// Create the right panel, containing the email list & details. See Mail application
rightPanel.add(mailList);
rightPanel.add(mailDetail);

mailList.setWidth(“100%”);

mailDetail.setWidth(“100%”);
DockPanel outer = new DockPanel();
outer.add(topPanel, DockPanel.NORTH);
outer.add(leftmenu, DockPanel.WEST);
outer.add(rightPanel, DockPanel.CENTER);
outer.setWidth(“100%”);

outer.setSpacing(4);
outer.setCellWidth(rightPanel, “100%”);

// Hook the window resize event

Window.addWindowResizeListener(this);
Window.enableScrolling(false);

Window.setMargin(“0px”);

RootPanel.get().add(outer);

DeferredCommand.addCommand(new Command() {

public void execute() {
onWindowResized(Window.getClientWidth(), Window.getClientHeight());
}
});

onWindowResized(Window.getClientWidth(), Window.getClientHeight());
}

Next step: To modify the right panel to put a form.

Since this time i think about how this POC could have been a great experience, cause we all know how good are the Google’s stuff.

So let’s try again.

For this first personal project i decide to create a webapp able to help me in my current project, which is using the Scrum methodology.

Product Backlog:

- The app will help me to manage: Projects, Sprints, backlogs & Programmers.

- the app will allow programmers to log into and see all User Stories and tasks for a given sprint.

Starting project:

Nothing to say, just Getting Started !