Intégration de GWT, Spring et JPA (Eclipse-link) dans Weblogic 10

Question

Mon architecture d'application ressemble à ceci. GWT dans la couche d'interface utilisateur -> Appelle le service GWT RPC (servlets) -> Looksup Spring Beans -> Appelle la couche DAO qui est implémentée dans JPA (EclipseLink).

J'ai testé avec succès l'application avec les services GpT rpc appelant directement la couche JPA. Mais j'ai du mal à intégrer le printemps dans le mélange. (L'utilisation principale de Spring est la gestion des transactions).

J'ai essayé de googler, mais je n'ai trouvé aucun bon article sur le sujet. (La plupart des articles se réfère à l'utilisation de Spring MVC dans GWT, ce qui n'est pas ce que je cherche) Pourriez-vous s'il vous plaît me diriger vers un article/tutoriel?

Merci d'avance!

Manoj

Answer 1

Si vous cherchez quelque chose de vraiment simple, pourquoi ne pas vous appelez juste un haricot dans le contexte de l'application de votre mise en œuvre de services? Quelque chose comme:

public class GreetingServiceImpl extends RemoteServiceServlet implements 
    GreetingService { 

    public String greetServer(String input) throws IllegalArgumentException { 
    return WebApplicationContextUtils.getRequiredWebApplication(getServletContext()). 
     getBean(GreetingService .class).greetServer(input); 
    } 
} 

Le contexte d'application de soutien doit fournir une implémentation « réelle » de GreetingService. Voir aussi this article.

Answer 2

Un des problèmes intéressants que j'ai trouvé est que je veux souvent que mon servlet soit un bean géré par Spring. De cette façon, il peut effectuer toutes les injections de dépendances, etc. Mais normalement, vous devez spécifier vos servlets dans web.xml, ce qui signifie que votre conteneur (par exemple Tomcat), et non Spring, créera le servlet.

Il existe un moyen de contourner cela, en utilisant le HttpRequestHandlerServlet. Mon fichier web.xml comprend ces lignes:

<servlet> 
    <servlet-name>dataProvider</servlet-name> 
    <servlet-class> 
     org.springframework.web.context.support.HttpRequestHandlerServlet</servlet-class> 
    <load-on-startup>1</load-on-startup> 
</servlet> 

<servlet> 
    <servlet-name>documentCreator</servlet-name> 
    <servlet-class> 
     org.springframework.web.context.support.HttpRequestHandlerServlet</servlet-class> 
    <load-on-startup>1</load-on-startup> 
</servlet> 

<servlet-mapping> 
    <servlet-name>dataProvider</servlet-name> 
    <url-pattern>/dataProvider/*</url-pattern> 
</servlet-mapping> 

<servlet-mapping> 
    <servlet-name>documentCreator</servlet-name> 
    <url-pattern>/documentCreator/*</url-pattern> 
</servlet-mapping> 

Cela dit printemps qu'il va utiliser deux de ses haricots servlets, l'un appelé dataProvider, et l'autre appelé documentCreator. Il faudra déterminer ce que sont ces beans, soit en utilisant le fichier de configuration xml ou les annotations. Je préfère les annotations, telles que @Controller. Que se passe-t-il lorsque Tomcat reçoit une requête, par exemple GET/dataProvider/test Dans la section de mappage de servlet, il sait qu'il doit donner cette requête au premier HttpRequestHandlerServlet qu'il a créé. Cette classe sait qu'elle porte le nom dataProvider et elle recherche dans le contexte Spring un bean appelé dataProvider. Ensuite, il appelle la méthode handleRequest sur ce bean.

Ma classe DataProvider ressemble à ceci:

@Controller 
public class DataProvider extends HttpServlet implements HttpRequestHandler { 

    @Autowired 
    private OtherBeanType otherBean 

    @Override 
    protected void doGet(HttpServletRequest request, HttpServletResponse response) { 
    // my doGet method 
    } 

    @Override 
    protected void doPost(HttpServletRequest request, HttpServletResponse response) { 
    // my doPost method 
    } 

    @Override 
    public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { 
    if (request.getMethod().equalsIgnoreCase("GET")) { 
     doGet(request, response); 
    } else if (request.getMethod().equalsIgnoreCase("POST")) { 
     doPost(request, response); 
    } 
    } 

} 

Je pense qu'il est un peu regrettable que nous avons besoin de cette méthode handleRequest() (et si vous utilisez autre chose que publierez, vous devrez ajouter eux là-dedans). Ce serait plus agréable si HttpRequestHandlerServlet pouvait faire ce travail pour vous, mais c'est comme ça que ça fonctionne pour le moment.