Utilisation de GWT avec spring et hibernate

            <plugin>
                <groupId>com.totsp.gwt</groupId>
                <artifactId>maven-googlewebtoolkit2-plugin</artifactId>
                <version>2.0-RC1</version>
                <configuration>
                    <compileTargets>
                        <value>com.developpez.myapplication.Application</value>
                    </compileTargets>
                    <runTarget>com.developpez.myapplication.Application/Application.html</runTarget>
                    <logLevel>INFO</logLevel>
                    <style>DETAILED</style>
                    <noServer>false</noServer>
                    <extraJvmArgs>-Xmx512m</extraJvmArgs>
                    <gwtVersion>${gwtVersion}</gwtVersion>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <!-- <goal>mergewebxml</goal>-->
                            <!-- <goal>i18n</goal>-->
                            <goal>compile</goal>                            
                            <goal>test</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

<!--  Use the dependency plugin to unpack gwt-dev-PLATFORM-libs.zip -->
<!--
    (this is a replacement for the old "automatic" mode - useful if you
    don't have GWT installed already, or you just want a maven way to
    handle gwt deps)
-->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
        <execution>
            <id>unpack</id>
            <phase>compile</phase>
            <goals>
                <goal>unpack</goal>
            </goals>
            <configuration>
                <artifactItems>
                    <artifactItem>
                        <groupId>com.google.gwt</groupId>
                        <artifactId>gwt-dev</artifactId>
                        <version>${gwtVersion}</version>
                        <classifier>${platform}-libs</classifier>
                        <type>zip</type>
                        <overWrite>false</overWrite>
                        <outputDirectory>${settings.localRepository}/com/google/gwt/gwt-dev/${gwtVersion}</outputDirectory>
                    </artifactItem>
                </artifactItems>
            </configuration>
        </execution>
    </executions>
</plugin>

Compiling module com.developpez.myapplication.Application
   Refreshing module from source
      Validating newly compiled units
         Removing units with errors
            [ERROR] Errors in 
'file:/E:/Developpement/checkout/developpez/myapplication-client/src/main/java/com/developpez/myapplication/client/model/datasources/ProjectDS.java'
               [ERROR] Line 65: No source code is available for type com.developpez.services.ProjectServiceAsync; 
               did you forget to inherit a required module?
               [ERROR] Line 65: No source code is available for type com.developpez.services.ProjectService; 
               did you forget to inherit a required module?
....

  <source path="model"/>
  <source path="client"/>
  <source path="services">      
      <exclude name="**/impl/**" />
  </source>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-source-plugin</artifactId>
            <executions>
              <execution>
                <id>attach-sources</id>
                <phase>verify</phase>
                <goals>
                  <goal>jar</goal>
                </goals>
              </execution>
            </executions>
          </plugin>    
    </plugins>    
</build>

        <dependency>
            <groupId>${groupId}</groupId>
            <artifactId>myapplication-model</artifactId>
            <version>${version}</version>
            <type>java-source</type>
        </dependency>
        <dependency>
            <groupId>${groupId}</groupId>
            <artifactId>myapplication-persistence</artifactId>
            <version>${version}</version>
            <type>java-source</type>
        </dependency>

<configuration>
    <compileTargets>
        <value>com.developpez.myapplication.Application</value>
    </compileTargets>
    <runTarget>com.developpez.myapplication.Application/Application.html</runTarget>
    <logLevel>INFO</logLevel>
    <style>DETAILED</style>
    <noServer>${gwt.noserver}</noServer>
    <port>8082</port>
    <extraJvmArgs>-Xmx512m</extraJvmArgs>
    <gwtVersion>${gwtVersion}</gwtVersion>
</configuration>

    <properties>
    ....                
        <gwt.noserver>true</gwt.noserver>
    ....    
    </properties>

<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.cargo</groupId>
            <artifactId>cargo-maven2-plugin</artifactId>
            <version>0.3.1</version>
            <configuration>
                <wait>${cargo.wait}</wait>
                <container>
                    <containerId>${tomcat.containerId}</containerId>
                    <log>${project.build.directory}/${tomcat.containerId}/cargo.log</log>
                    <zipUrlInstaller>
                        <URL>${tomcat.downloadUrl}</URL>
                        <installDir>${tomcat.installDir}</installDir>
                    </zipUrlInstaller>
                    <timeout>360000</timeout>
                </container>
                <configuration>
                    <home>${project.build.directory}/${tomcat.containerId}/container</home>
                    <properties>
                        <cargo.servlet.port>${tomcat.port}</cargo.servlet.port>
                        <cargo.logging>high</cargo.logging>
                    </properties>
                </configuration>
            </configuration>
        </plugin>
    </plugins>
</build>

<!--  profiles (with activation per platform) -->
<profiles>
    <profile>
        <id>debug</id>
        <!-- 
            profil permettant de déboguer tomcat 
            les logs sont dans myapplication\target\tomcat5x\cargo.log
        -->
        <activation>
            <property>
                <name>debug</name>
                <value>true</value>
            </property>
        </activation>

        <build>
            <plugins>
                <plugin>
                    <groupId>org.codehaus.cargo</groupId>
                    <artifactId>cargo-maven2-plugin</artifactId>
                    <configuration>
                        <wait>true</wait>
                        <container>
                            <containerId>${tomcat.containerId}</containerId>
                        </container>
                        <configuration>
                            <properties>
                                <cargo.jvmargs>
        -Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=7456
                                </cargo.jvmargs>
                            </properties>
                        </configuration>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </profile>
    <profile>
        <!-- Launch cargo on pre-integration-test phase -->
        <id>cargo</id>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.codehaus.cargo</groupId>
                    <artifactId>cargo-maven2-plugin</artifactId>
                    <executions>
                        <execution>
                            <id>start-container</id>
                            <phase>pre-integration-test</phase>
                            <goals>
                                <goal>start</goal>
                            </goals>
                        </execution>
                        <execution>
                            <id>stop-container</id>
                            <phase>post-integration-test</phase>
                            <goals>
                                <goal>stop</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </profile>        
    
</profiles>

mvn install -Dmaven.test.skip -Dcargo.wait -Pcargo

mvn install -Dmaven.test.skip -Ddebug -Pcargo

package com.developpez.client.model.datasources;

import com.smartgwt.client.data.DSRequest;
import com.smartgwt.client.data.DSResponse;
import com.smartgwt.client.data.DataSource;
import com.smartgwt.client.types.DSDataFormat;
import com.smartgwt.client.types.DSProtocol;

/**
 * Data source with ability to communicate with server by GWT RPC.
 * <p/>
 * SmartClient natively supports data protocol "clientCustom". This protocol
 * means that communication with server should be implemented in
 * <code>transformRequest (DSRequest request)</code> method. Here is a few
 * things to note on <code>transformRequest</code> implementation:
 * <ul>
 * <li><code>DSResponse</code> object has to be created and
 * <code>processResponse (requestId, response)</code> must be called to finish
 * data request. <code>requestId</code> should be taken from original
 * <code>DSRequest.getRequestId ()</code>.</li>
 * <li>"clientContext" attribute from <code>DSRequest</code> should be copied to
 * <code>DSResponse</code>.</li>
 * <li>In case of failure <code>DSResponse</code> should contain at least
 * "status" attribute with error code (<0).</li>
 * <li>In case of success <code>DSResponse</code> should contain at least "data"
 * attribute with operation type specific data:
 * <ul>
 * <li>FETCH - <code>ListGridRecord[]</code> retrieved records.</li>
 * <li>ADD - <code>ListGridRecord[]</code> with single added record. Operation
 * is called on every newly added record.</li>
 * <li>UPDATE - <code>ListGridRecord[]</code> with single updated record.
 * Operation is called on every updated record.</li>
 * <li>REMOVE - <code>ListGridRecord[]</code> with single removed record.
 * Operation is called on every removed record.</li>
 * </ul>
 * </li>
 * </ul>
 * 
 * @author Aleksandras Novikovas
 * @author System Tier
 * @version 1.0
 */
public abstract class GwtRpcDataSource extends DataSource
{

    /**
     * Creates new data source which communicates with server by GWT RPC. It is
     * normal server side SmartClient data source with data protocol set to
     * <code>DSProtocol.CLIENTCUSTOM</code> ("clientCustom" - natively supported
     * by SmartClient but should be added to smartGWT) and with data format
     * <code>DSDataFormat.CUSTOM</code>.
     */
    public GwtRpcDataSource()
    {
        setDataProtocol(DSProtocol.CLIENTCUSTOM);
        setDataFormat(DSDataFormat.CUSTOM);
        setClientOnly(false);
    }

    /**
     * Executes request to server.
     * 
     * @param request
     *            <code>DSRequest</code> being processed.
     * @return <code>Object</code> data from original request.
     */
    @Override
    protected Object transformRequest(DSRequest request)
    {
        String requestId = request.getRequestId();
        DSResponse response = new DSResponse();
        response.setAttribute("clientContext", request.getAttributeAsObject("clientContext"));
        // Asume success
        response.setStatus(0);
        switch (request.getOperationType())
        {
        case FETCH:
            executeFetch(requestId, request, response);
            break;
        case ADD:
            executeAdd(requestId, request, response);
            break;
        case UPDATE:
            executeUpdate(requestId, request, response);
            break;
        case REMOVE:
            executeRemove(requestId, request, response);
            break;
        default:
            // Operation not implemented.
            break;
        }
        return request.getData();
    }

    /**
     * Executed on <code>FETCH</code> operation.
     * <code>processResponse (requestId, response)</code> should be called when
     * operation completes (either successful or failure).
     * 
     * @param requestId
     *            <code>String</code> extracted from
     *            <code>DSRequest.getRequestId ()</code>.
     * @param request
     *            <code>DSRequest</code> being processed.
     * @param response
     *            <code>DSResponse</code>. <code>setData (list)</code> should be
     *            called on successful execution of this method.
     *            <code>setStatus (<0)</code> should be called on failure.
     */
    protected abstract void executeFetch(String requestId, DSRequest request, DSResponse response);

    /**
     * Executed on <code>ADD</code> operation.
     * <code>processResponse (requestId, response)</code> should be called when
     * operation completes (either successful or failure).
     * 
     * @param requestId
     *            <code>String</code> extracted from
     *            <code>DSRequest.getRequestId ()</code>.
     * @param request
     *            <code>DSRequest</code> being processed.
     *            <code>request.getData ()</code> contains record should be
     *            added.
     * @param response
     *            <code>DSResponse</code>. <code>setData (list)</code> should be
     *            called on successful execution of this method. Array should
     *            contain single element representing added row.
     *            <code>setStatus (<0)</code> should be called on failure.
     */
    protected abstract void executeAdd(String requestId, DSRequest request, DSResponse response);

    /**
     * Executed on <code>UPDATE</code> operation.
     * <code>processResponse (requestId, response)</code> should be called when
     * operation completes (either successful or failure).
     * 
     * @param requestId
     *            <code>String</code> extracted from
     *            <code>DSRequest.getRequestId ()</code>.
     * @param request
     *            <code>DSRequest</code> being processed.
     *            <code>request.getData ()</code> contains record should be
     *            updated.
     * @param response
     *            <code>DSResponse</code>. <code>setData (list)</code> should be
     *            called on successful execution of this method. Array should
     *            contain single element representing updated row.
     *            <code>setStatus (<0)</code> should be called on failure.
     */
    protected abstract void executeUpdate(String requestId, DSRequest request, DSResponse response);

    /**
     * Executed on <code>REMOVE</code> operation.
     * <code>processResponse (requestId, response)</code> should be called when
     * operation completes (either successful or failure).
     * 
     * @param requestId
     *            <code>String</code> extracted from
     *            <code>DSRequest.getRequestId ()</code>.
     * @param request
     *            <code>DSRequest</code> being processed.
     *            <code>request.getData ()</code> contains record should be
     *            removed.
     * @param response
     *            <code>DSResponse</code>. <code>setData (list)</code> should be
     *            called on successful execution of this method. Array should
     *            contain single element representing removed row.
     *            <code>setStatus (<0)</code> should be called on failure.
     */
    protected abstract void executeRemove(String requestId, DSRequest request, DSResponse response);
}

            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring</artifactId>
                <version>2.5.6</version>
            </dependency>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            classpath:applicationContext_GWT.xml
        </param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

<!--inserted by gwt-maven-->
<servlet>
<servlet-name>shell</servlet-name>
<servlet-class>com.google.gwt.dev.shell.GWTShellServlet</servlet-class>
</servlet>
<!--inserted by gwt-maven-->
<servlet-mapping>
<servlet-name>shell</servlet-name>
<URL-pattern>/*</URL-pattern>
</servlet-mapping>

   <bean id="gwtShellController"
class="org.springframework.web.servlet.mvc.ServletForwardingController">
        <property name="servletName">
                <value>shell</value>
        </property>
   </bean>

   <bean id="urlMapping"
class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
                <props>
                        <prop key="/*/user.rpc">userController</prop>
                        <prop key="/*">gwtShellController</prop>
                </props>
        </property>
    </bean>

            <!-- GWT SL for spring integration on server side -->        
            <dependency>
                <groupId>net.sf.gwt-widget</groupId>
                <artifactId>gwt-sl</artifactId>
                <version>0.1.5b</version>
            </dependency>
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring</artifactId>
                <version>2.5.6</version>
            </dependency>

      <servlet>
        <servlet-name>handler</servlet-name>
        <servlet-class>
            org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>handler</servlet-name>
        <URL-pattern>*.rpc</URL-pattern>
    </servlet-mapping>

package com.developpez.myapplication.services;

import java.util.List;

import org.springframework.security.annotation.Secured;

import com.developpez.myapplication.model.Project;
import com.developpez.myapplication.services.exception.ServiceSecurityException;
import com.google.gwt.user.client.rpc.RemoteService;
import com.google.gwt.user.client.rpc.RemoteServiceRelativePath;

/**
 * Services related to projects operations
 * 
 * @version 1.0
 */
@RemoteServiceRelativePath("ProjectService.rpc")
public interface ProjectService extends RemoteService
{

    /**
     * @return the list of projects available
     * @throws ServiceSecurityException 
     */
    @Secured("ROLE_ADMIN")
    List<Project> fetch() throws ServiceSecurityException;

    /**
     * 
     * @param record the project to add
     * @return the record added and potentially modified on server side
     * @throws ServiceSecurityException
     */
    @Secured("ROLE_ADMIN")
    Project add(Project record) throws ServiceSecurityException;

    /**
     * @param record the project to update
     * @return the record updated and potentially modified on server side
     * @throws ServiceSecurityException
     */
    @Secured("ROLE_ADMIN")
    Project update(Project record) throws ServiceSecurityException;

    /**
     * @param record the record to remove
     * @throws ServiceSecurityException
     */
    @Secured("ROLE_ADMIN")
    void remove(Project record) throws ServiceSecurityException;
}

package com.developpez.services.impl;

import java.util.ArrayList;
import java.util.List;

import com.developpez.myapplication.model.Project;
import com.developpez.myapplication.services.ProjectService;

/**
 * Mock implementation
 */
public class ProjectServiceImpl implements ProjectService 
{

    /**
     * serial id
     */
    private static final long serialVersionUID = 9177398707013302517L;
    
    /**
     * list of project (in memory)
     */
    private List<Project> liste;

    /**
     * empty constructor
     */
    public ProjectServiceImpl() {
        
        liste = new ArrayList<Project>();
        liste.add(new Project(0,"nom1","prenom1"));
        liste.add(new Project(1,"nom3","prenom3"));
    }
    /* (non-Javadoc)
     * @see com.developpez.client.services.ProjectService#add(com.developpez.model.Project)
     */
    public Project add(Project record)
    {
        liste.add(record);
        return record;
    }

    /* (non-Javadoc)
     * @see com.developpez.client.services.ProjectService#fetch()
     */
    public List<Project> fetch()
    {
        return liste;
    }

    /* (non-Javadoc)
     * @see com.developpez.client.services.ProjectService#remove(com.developpez.model.Project)
     */
    public void remove(Project record)
    {
        liste.remove(record);
        
    }

    /* (non-Javadoc)
     * @see com.developpez.client.services.ProjectService#update(com.developpez.model.Project)
     */
    public Project update(Project record)
    {
        liste.remove(record);
        liste.add(record);
        return record;
    }
}

    <bean id="projectService"
        class="com.developpez.myapplication.services.impl.ProjectServiceImpl">
    </bean>

    <bean id="urlProjectMapping" class="org.gwtwidgets.server.spring.GWTHandler">
    <!-- Supply here mappings between URLs and services. Services must implement the RemoteService interface but
    are not otherwise restricted.-->
        <property name="mappings">
            <map>
                <!-- Other mappings could follow -->
                <entry key="/com.developpez.myapplication.Application/ProjectService.rpc" value-ref="projectService" />
            </map>
        </property>
    </bean>

<init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>
                /WEB-INF/handler-servlet.xml
            </param-value>
        </init-param>

package com.developpez.myapplication.services;

import java.util.List;

import com.developpez.myapplication.model.Project;
import com.google.gwt.user.client.rpc.AsyncCallback;

public interface ProjectServiceAsync {

    public abstract void fetch (AsyncCallback<List<Project>> asyncCallback);

    public abstract void add (Project record, AsyncCallback<Project> asyncCallback);

    public abstract void update (Project record, AsyncCallback<Project> asyncCallback);

    public abstract void remove (Project record, AsyncCallback<Object> asyncCallback);
}

        if (!isAuthenticated)
        {
            mainWidget = createLoginWidget();
        } else
        {
            mainWidget = createMainFrame();
        }

package com.developpez.myapplication.services;

import com.developpez.myapplication.model.ReturnMemento;
import com.google.gwt.user.client.rpc.RemoteService;
import com.google.gwt.user.client.rpc.RemoteServiceRelativePath;

/**
 * Authentication service.
 * 
 */
@RemoteServiceRelativePath("AuthenticationService.rpc")
public interface AuthenticationService extends RemoteService {

    /**
     * Authenticates user.
     * 
     * @param username
     * @param password
     * @return whether authentication is successful
     */
    ReturnMemento authenticate(String username, String password);

    /**
     * Terminates a user's security session.
     */
    void logout();
}

package com.developpez.myapplication.services.impl;

import org.springframework.security.Authentication;
import org.springframework.security.GrantedAuthority;
import org.springframework.security.GrantedAuthorityImpl;
import org.springframework.security.context.SecurityContext;
import org.springframework.security.context.SecurityContextHolder;
import org.springframework.security.context.SecurityContextImpl;
import org.springframework.security.providers.UsernamePasswordAuthenticationToken;
import org.springframework.security.userdetails.User;

import com.developpez.myapplication.model.ReturnMemento;
import com.developpez.myapplication.services.AuthenticationService;

/**
 * {@link AuthenticationService} implementation.
 * 
 */
public class AuthenticationServiceImpl implements AuthenticationService {

    /* (non-Javadoc)
     * @see com.developpez.myapplication.services.AuthenticationService#authenticate(java.lang.String, java.lang.String)
     */
    public ReturnMemento authenticate(String username, String password) 
    {
        // create a test case where admin have ROLE_ADMIN and ROLE_USER
        if (username.equals("admin"))
        {
            // creating an authenticated user token for demo
            // regardless of username and password values
            GrantedAuthority[] authorities = new GrantedAuthority[] { new GrantedAuthorityImpl("ROLE_ADMIN"),new GrantedAuthorityImpl("ROLE_USER") };
            User user = new User("xxx", "yyy", true, true, true, true, authorities);
            Authentication auth = new UsernamePasswordAuthenticationToken(user, password, authorities);
            SecurityContext sc = new SecurityContextImpl();
            sc.setAuthentication(auth);
            SecurityContextHolder.setContext(sc);
    
            return new ReturnMemento(ReturnMemento.CODE_SUCCESS,ReturnMemento.CODE_SUCCESS);
        }
        // user only have ROLE_USER
        else if (username.equals("user"))
        {
            // creating an authenticated user token for demo
            // regardless of username and password values
            GrantedAuthority[] authorities = new GrantedAuthority[] { new GrantedAuthorityImpl("ROLE_USER") };
            User user = new User("xxx", "yyy", true, true, true, true, authorities);
            Authentication auth = new UsernamePasswordAuthenticationToken(user, password, authorities);
            SecurityContext sc = new SecurityContextImpl();
            sc.setAuthentication(auth);
            SecurityContextHolder.setContext(sc);
    
            return new ReturnMemento(ReturnMemento.CODE_SUCCESS,ReturnMemento.CODE_SUCCESS);
        }
        // other people can't log in
        else
        {
            ReturnMemento rm = new ReturnMemento(ReturnMemento.CODE_ERROR,ReturnMemento.CODE_ERROR);
            rm.getErrors().put("login","login or password incorrect");
            rm.getErrors().put("password","login or password incorrect");
            return rm;
        }
    }

    /* (non-Javadoc)
     * @see com.developpez.myapplication.services.AuthenticationService#logout()
     */
    public void logout() 
    {
        SecurityContextHolder.clearContext();
    }

}

    <!--
        Note: forcing eager session creation in
        HttpSessionContextIntegrationFilter to ensure that session cookie is
        set at the completion of the authenticate call.
    -->
    <security:http entry-point-ref="authenticationProcessingFilterEntryPoint"
        create-session="always"   access-denied-page="/index.html" session-fixation-protection="none">
        <security:intercept-url pattern="/com.developpez.MyApplication/MyApplication.html" access="ROLE_USER"/>
        <security:form-login login-page="/index.html" />
    </security:http>

    <!--
        Standard spring filter used to redirect unauthorized request to the login form
        Unauthorized request are intercepted by the pattern specified in the security namespace
        above : eg the application itself.
        Except for the main filter which prevent the access to the applicaton, 
        remember that here we are dealing with GWT
        RPC requests and NOT normal web requests. The only sensible thing to
        do is to, in GWT server-side code, explicitly handle exceptions thrown
        by the AbstractSecurityInterceptor (Method Security interceptor in
        this case) to either "redirect" the user to the login page or display
        "access denied" messages.
    -->
    <bean id="authenticationProcessingFilterEntryPoint"
            class="org.springframework.security.ui.webapp.AuthenticationProcessingFilterEntryPoint">
      <property name="loginFormUrl" value="/index.html"/>
      <property name="forceHttps" value="false"/>
    </bean>

    <security:global-method-security
        secured-annotations="enabled" jsr250-annotations="disabled" />

    <bean id="dummyAuthenticationProvider"
        class="com.developpez.security.core.DummyAuthenticationProvider">
        <security:custom-authentication-provider />
    </bean>

        .....
                <entry key="/com.developpez.myapplication.Login/AuthenticationService.rpc" value-ref="authenticationService" />
                <!-- because logout can also be called from the application module -->
                <entry key="/com.developpez.myapplication.Application/AuthenticationService.rpc" value-ref="authenticationService" />
        ......

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE module PUBLIC "-//Google Inc.//DTD Google Web Toolkit 1.6.4//EN" "http://google-web-toolkit.googlecode.com/svn/tags/1.6.4/distro-source/core/src/gwt-module.dtd">
<module >

  
  <!-- Inherit the core Web Toolkit stuff.                        -->
  <inherits name='com.google.gwt.user.User'/>

  <!-- Inherits smartGWT                                      -->
  <inherits name="com.smartgwt.SmartGwt"/>

  <source path="model"/>
  <source path="client"/>
  <source path="services">
      <include name="**/*"/>  
      <exclude name="**/impl/**" />
  </source>  

  <!-- Specify the app entry point class.                         -->
  <entry-point class='com.developpez.myapplication.client.LoginEntry'/>
</module>

        DataSource dataSource = new DataSource();

        DataSourceTextField login = new DataSourceTextField("login", "Username", 50, true);
        DataSourcePasswordField password = new DataSourcePasswordField("password", "Password", 50, true);
        DataSourceBooleanField rememberField = new DataSourceBooleanField("remember", "Remember me on this computer.", 50, false);

        dataSource.setFields(login, password, rememberField);

        final DynamicForm form = new DynamicForm();
        form.setDataSource(dataSource);
        form.setUseAllDataSourceFields(true);

        IButton validateItem = new IButton("Log in");

        ....
        
        VLayout formLayout = new VLayout(10);
        formLayout.addMember(form);
        formLayout.addMember(validateItem);

        validateItem.addClickHandler(new ClickHandler()
        {
            public void onClick(ClickEvent event)
            {
                if (form.validate(false))
                {
                    AuthenticationServiceAsync service = GWT.create(AuthenticationService.class);
                    service.authenticate(form.getValueAsString("login"), form.getValueAsString("password"), new AsyncCallback<ReturnMemento>()
                    {

                        public void onSuccess(ReturnMemento result)
                        {
                            if (result.getCode() == ReturnMemento.CODE_SUCCESS)
                            {
                                String path = Window.Location.getPath();
                                String modulePath = "/com.developpez.myapplication.Login/Login.html";
                                int index = path.indexOf(modulePath);
                                String contextPath = path.substring(0,index);

                                Window.open(contextPath+"/com.developpez.myapplication.Application/Application.html", "_self", "");
                            }
                            else
                            {
                                form.setErrors(result.getErrors(), true);
                            }
                        }

                        public void onFailure(Throwable arg0)
                        {
                            SC.say("error : " + arg0);
                        }
                    });
                }

            }
        });

                                String path = Window.Location.getPath();
                                String modulePath = "/com.developpez.myapplication.Login/Login.html";
                                int index = path.indexOf(modulePath);
                                String contextPath = path.substring(0,index);

    /**
     * 
     * @param record the project to add
     * @return the record added and potentially modified on server side
     * @throws ServiceSecurityException
     */
    @Secured("ROLE_ADMIN")
    Project add(Project record) throws ServiceSecurityException;

    /* (non-Javadoc)
     * @see org.gwtwidgets.server.spring.GWTRPCServiceExporter#handleInvocationTargetException(
                                         java.lang.reflect.InvocationTargetException, 
                                         java.lang.Object, java.lang.reflect.Method, 
                                        com.google.gwt.user.server.rpc.RPCRequest)
     */
    @Override
    protected String handleInvocationTargetException(InvocationTargetException e, Object service, Method targetMethod, RPCRequest rpcRequest) throws Exception
    {
        Throwable cause = e.getCause();
        if (cause instanceof SpringSecurityException)
        {
            String failurePayload = RPC.encodeResponseForFailure(rpcRequest.getMethod(), 
                                                                 new ServiceSecurityException(cause.getMessage()), 
                                                                 rpcRequest.getSerializationPolicy());
            return failurePayload;
        }
        else
        {
            return super.handleInvocationTargetException(e, service, targetMethod, rpcRequest);
        }
    }

     ....
        <property name="serviceExporterFactory" ref="serviceExporterFactory"></property>
     ....

    /**
     * list of associated authors
     */
    @OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER)
    @JoinTable(name="project_authors", joinColumns= @JoinColumn( name="PROJECT_ID"), inverseJoinColumns=@JoinColumn( name="AUTHOR_ID"))
    private List<Authors> authors = new ArrayList<Authors>();

[20:49:49.576][info][talledLocalContainer] java.lang.RuntimeException: com.google.gwt.user.client.rpc.SerializationException: 
java.lang.reflect.InvocationTargetException
...
[20:49:49.841][info][talledLocalContainer] Caused by: com.google.gwt.user.client.rpc.SerializationException: 
Type 'org.hibernate.collection.PersistentBag' was not included in the set of types which can be serialized by this SerializationPolicy 
or its Class object could not be loaded. For security purposes, this type will not be serialized.

package com.developpez.myapplication.model;

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

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.OneToMany;
import javax.persistence.Table;


/**
 * 
 */
@Entity
@Table(name="PROJECT")
public class Project implements Serializable 
{

    /**
     * serial id
     */
    private static final long serialVersionUID = -5922364316829478146L;
    
    /**
     * name of the project
     */
    @Column(name="NAME")
    private String name;

    /**
     * description of the project
     */
    @Column(name="DESCRIPTION")
    private String desc;
    
    /**
     * url of the project
     */
    @Column(name="URL")
    private String URL;
    
    /**
     * list of associated authors
     */
    @OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER)
    @JoinTable(name="project_authors", joinColumns= @JoinColumn( name="PROJECT_ID"), inverseJoinColumns=@JoinColumn( name="AUTHOR_ID"))
    private List<Authors> authors = new ArrayList<Authors>();

    /**
     * unique identifier
     */
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Integer id;

    
    /**
     * Empty constructor
     */
    public Project() {

    }    
    /**
     * Full constructor
     * @param id
     * @param name
     * @param desc
     */
    public Project(Integer id,String name,String desc)
    {
        this.id = id;
        this.name = name;
        this.desc=desc;
    }
    
    /**
     * @return the list of authors
     */
    public List<Authors> getAuthors() {
        return authors;
    }   
    
    /**
     * @param the list of authors
     */
    public void setAuthors(List<Authors> authors) {
        this.authors = authors;
    }       
    
    /**
     * @return
     */
    public String getName()
    {
        return name;
    }

    /**
     * @param name
     */
    public void setName(String name)
    {
        this.name = name;
    }

    /**
     * @return
     */
    public String getDesc()
    {
        return desc;
    }

    /**
     * @param desc
     */
    public void setDesc(String desc)
    {
        this.desc = desc;
    }

    /**
     * @return
     */
    public String getUrl()
    {
        return URL;
    }

    /**
     * @param URL
     */
    public void setUrl(String url)
    {
        this.url = URL;
    }



    /**
     * @param id
     */
    public void setId(Integer id)
    {
        this.id = id;
    }

    /**
     * @return
     */
    public Integer getId()
    {
        return id;
    }

    /* (non-Javadoc)
     * @see java.lang.Object#hashCode()
     */
    @Override
    public int hashCode()
    {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((id == null) ? 0 : id.hashCode());
        return result;
    }
    /* (non-Javadoc)
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Project other = (Project) obj;
        if (id == null)
        {
            if (other.id != null)
                return false;
        } else if (!id.equals(other.id))
            return false;
        return true;
    }

}

public class Project extends LightEntity implements Serializable

      <!-- Gilead light entity -->
        <inherits name='net.sf.gilead.Adapter4Gwt15'/>

    <!--
    The Gilead POJO stateless proxy store.
     -->
    <bean id="proxyStore" class="net.sf.gilead.core.store.stateless.StatelessProxyStore" />
    
    <bean id="persistenceUtil" class="net.sf.gilead.core.hibernate.HibernateUtil">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    <!--
    Gilead persistentBeanManager binds the POJO store with a Hibernate session factory (through the hibernate util).
     -->    
    <bean id="persistentBeanManager" class="net.sf.gilead.core.PersistentBeanManager">
        <property name="proxyStore" ref="proxyStore" />
        <property name="persistenceUtil" ref="persistenceUtil"></property>
    </bean>

public class GWTRPCSecuredServiceExporter extends HB4GWTRPCServiceExporter

/**
 * Factory to use with {@link GWTRPCSecuredServiceExporter}
 *
 */
public class GWTRPCSecuredServiceExporterFactory implements RPCServiceExporterFactory
{
    private PersistentBeanManager manager = new PersistentBeanManager();


    /* (non-Javadoc)
     * @see org.gwtwidgets.server.spring.RPCServiceExporterFactory#create()
     */
    public RPCServiceExporter create()
    {
        GWTRPCSecuredServiceExporter exporter = new GWTRPCSecuredServiceExporter();
        exporter.setBeanManager(manager);
        return exporter;
    }

    
    /**
     * @return the manager
     */
    public PersistentBeanManager getManager()
    {
        return manager;
    }

    /**
     * @param manager the manager to set
     */
    public void setManager(PersistentBeanManager manager)
    {
        this.manager = manager;
    }    
}

    <bean id="serviceExporterFactory" class="com.developpez.server.spring.GWTRPCSecuredServiceExporterFactory" >
        <property name="manager" ref="persistentBeanManager"></property>
    </bean>