GWT Remote Services mit Spring konfigurieren.

[Thomas Darimont]

Hallo,

hier mal ein kleines Beispiel wie man den Serverteil einer GWT Anwendung mit Spring konfigurieren kann.

Hier zu erstellen wir uns mit dem Assistenten des GWT Eclipse Plugins eine neue Beispielanwendung (Greeting).
http://code.google.com/intl/de-DE/eclipse/docs/getting_started.html

Anschließend legen wir das spring.jar aus der aktuellen Springframework Distribution ins war/web-inf/lib Verzeichnis unseres GWT-Projekts.

Zu demonstrationszwecken lassen wir Spring dem vom GWT Assistenten generierten Beispielservice einen zusätzlichen Service (IBubuService) injezieren.

Dazu definieren wir folgende Klassen im Server package:

Unser Service-Interface

package de.tutorials.web.server.services;

public interface IBubuService {
    String bubu(String arg);
}

Unsere Service-Implementierung

package de.tutorials.web.server.services.base;

import de.tutorials.web.server.services.IBubuService;

public class BubuService implements IBubuService{
    @Override
    public String bubu(String arg) {
        return arg +" bubu";
    }
}

Unseren DI Hook:

package de.tutorials.web.server;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;

import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;

public abstract class DependencyInjectionAwareRemoteServiceServlet extends RemoteServiceServlet {
    @Override
    public void init(ServletConfig config) throws ServletException {
        super.init(config);
        WebApplicationContext webApplicationContext = WebApplicationContextUtils.getWebApplicationContext(config.getServletContext());
        webApplicationContext.getAutowireCapableBeanFactory().configureBean(this, getClass().getSimpleName());
    }
}

Unser veränderter GWT Beispielservice:

package de.tutorials.web.server;

import de.tutorials.web.client.GreetingService;
import de.tutorials.web.server.services.IBubuService;

public class GreetingServiceImpl extends DependencyInjectionAwareRemoteServiceServlet implements GreetingService {

    IBubuService bubuService;

    public String greetServer(String input) {
        return "Hello, " + getBubuService().bubu(input);
    }

    public IBubuService getBubuService() {
        return bubuService;
    }

    public void setBubuService(IBubuService bubuService) {
        this.bubuService = bubuService;
    }
}

Im Verzeichnis war/WEB-INF/conifg legen wir nun eine Datei names web-context.xml an.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
    <bean name="GreetingServiceImpl" abstract="true">
        <property name="bubuService" ref="bubuService" />
    </bean>

    <bean name="bubuService" class="de.tutorials.web.server.services.base.BubuService" />
</beans>

Hier haben wir die Abhängigkeit von unserer GreetingService-Implementierung zu unserem Beispielservice definiert.

Anschließend tragen wir unter war/WEB-INF/web.xml
noch den Spring Bootstrap Code ein (ContextLoaderListener):

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    id="WebApp_ID" version="2.5">

    <welcome-file-list>
        <welcome-file>Webui.html</welcome-file>
    </welcome-file-list>

    <servlet>
        <servlet-name>greetServlet</servlet-name>
        <servlet-class>de.tutorials.web.server.GreetingServiceImpl</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>greetServlet</servlet-name>
        <url-pattern>/webui/greet</url-pattern>
    </servlet-mapping>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/config/web-context.xml</param-value>
    </context-param>
    
</web-app>

Das wars und schon kanns losgehen. Beim Start der Beispielanwendung wird nun der Spring Kontext hochgezogen und bei der ersten Anfrage des RemoteServices wird dieses entsprechend von Spring konfiguriert. Natürlich lässt sich hier jedes andere DI Framework verwenden beispielsweise google Guice.

Übrigens, möchte man etwas mehr flexibilität bei der Verarbeitung von GWT RPC Calls haben, so kann man die
com.google.gwt.user.server.rpc.RemoteServiceServlet.processCall(String) Methode überschreiben und den eingentlichen Serviceaufruf an
eine beliebige Instanz delegieren.


Wer darüber hinaus noch wissen möchte wie man auch die Client Seite einer GWT Anwendung mit einem Spring-like Dependency Mechanismus konfigurieren kann sollte sich diesen Blog Eintrag mal
anschauen: http://blog.konstantin-denerz.de/?p=110

Gruß Tom