REST avec Spring 3.0 et Solr (2ème partie)

Voici la suite de notre série d’articles sur le support REST de Spring 3.0 afin d’encapsuler des appels à un serveur Solr. Nous avons dans la première partie présenté le cas d’utilisation et mis en place le serveur Solr. Nous allons voir dans cette deuxième partie comment écrire un contrôleur REST avec Spring.

Configuration de l’infrastructure de Spring MVC

Le support REST de Spring est basé sur Spring MVC : les contrôleurs REST sont en fait des contrôleurs Spring MVC annotées d’une façon spécifique. La première étape consiste donc à configurer une DispatcherServlet traditionnelle :

1. <web-app xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance&#8221;
2. xmlns=“http://java.sun.com/xml/ns/javaee&#8221; xmlns:web=“http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd&#8221;
3. xsi:schemaLocation=“http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd&#8221;
4. id=“rest” version=“2.5”>
6. <display-name>Support REST de Spring avec Solr</display-name>
8. <servlet>
9. <servlet-name>catalogue</servlet-name>
10. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
11. </servlet>
13. <servlet-mapping>
14. <servlet-name>catalogue</servlet-name>
15. <url-pattern>/catalogue/*</url-pattern>
16. </servlet-mapping>
18. </web-app>

Par défaut, le fichier de configuration du contexte Spring de notre DispatcherServlet est /WEB-INF/catalogue-servlet.xml (établi selon le nom donné à la Servlet). Ce fichier va contenir pour l’instant la déclaration des contrôleurs Web, en utilisant du component scanning :

1. <?xml version=“1.0” encoding=“UTF-8”?>
2. <beans xmlns=“http://www.springframework.org/schema/beans&#8221;
3. xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance&#8221;
4. xmlns:context=“http://www.springframework.org/schema/context&#8221;
5. xsi:schemaLocation=“
6. http://www.springframework.org/schema/beans
7. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
8. http://www.springframework.org/schema/context
9. http://www.springframework.org/schema/context/spring-context-3.0.xsd&#8221;>
11. <context:component-scan base-package=“com.zenika.springsolr.web” />
13. </beans>

Voyons maintenant comment implémenter une première version de notre contrôleur REST.

Contrôleur REST

Le contrôleur REST va permettre de consulter un catalogue de produit (les classes de domaine sont Catalogue et Produit). Comme dit précédemment, nous allons brancher notre contrôleur sur le serveur Solr, mais chaque chose en son temps, commençons par une version simplifiée, qui retourne une liste de produits en dur. Voici le code de ce premier jet :

1. package com.zenika.springsolr.web;
3. import org.springframework.stereotype.Controller;
4. import org.springframework.web.bind.annotation.RequestMapping;
5. import org.springframework.web.bind.annotation.RequestMethod;
6. import org.springframework.web.servlet.ModelAndView;
8. import com.zenika.springsolr.domain.Catalogue;
9. import com.zenika.springsolr.domain.Product;
11. @Controller
12. public class CatalogueController {
14. @RequestMapping(value=“/search/”,method=RequestMethod.GET)
15. public ModelAndView search() throws Exception {
16. Catalogue catalogue = new Catalogue()
17. .add(new Product(“splp”, “Spring par la pratique”, “Cogoluegnes-Templier”))
18. .add(new Product(“sdmia”, “Spring DM in action”, “Cogoluegnes-Piper-Templier”));
19. return new ModelAndView(“default”,“catalogue”,catalogue);
20. }
22. }

Nous avons constitué notre “modèle”, il est temps de s’atteler à la “vue”. Afin d’offrir la meilleure interopérabilité possible, les résultats seront rendus en XML. Nous allons compléter le contexte Spring de notre servlet avec la définition d’un Marshaller du module OXM de Spring, utilisant XStream pour sérialiser nos objets métier en XML :

1. <bean (…)>
2. (…)
3. <bean class=“org.springframework.web.servlet.view.BeanNameViewResolver” />
5. <bean id=“default” class=“org.springframework.web.servlet.view.xml.MarshallingView”>
6. <property name=“marshaller” ref=“marshaller” />
7. </bean>
9. <bean id=“marshaller” class=“org.springframework.oxm.xstream.XStreamMarshaller”>
10. <property name=“aliases”>
11. <map>
12. <entry key=“catalogue” value=“com.zenika.springsolr.domain.Catalogue” />
13. <entry key=“product” value=“com.zenika.springsolr.domain.Product” />
14. </map>
15. </property>
16. </bean>
18. </bean>

Une fois le serveur démarré, allons voir le résultat de notre travail à l’adresse http://localhost:8080/springsolr/catalogue/search/ :

1. <catalogue>
2. <products>
3. <product>
4. <id>splp</id>
5. <name>Spring par la pratique</name>
6. <manufacturer>Cogoluegnes-Templier</manufacturer>
7. </product>
8. <product>
9. <id>sdmia</id>
10. <name>Spring DM in action</name>
11. <manufacturer>Cogoluegnes-Piper-Templier</manufacturer>
12. </product>
13. </products>
14. </catalogue>

Nous avons mis en place l’ossature de notre contrôleur REST, branchons maintenant notre contrôleur REST sur Solr avec l’API client Java, SolrJ.

Implémentation du contrôleur REST avec SolrJ

Solr propose une API permettant d’accéder à une instance de Solr, qu’elle soit embarquée (dans le même process Java) ou distante (comme dans notre cas). Voici un exemple :

1. SolrServer solrServer = new CommonsHttpSolrServer(“http://localhost:8983/solr/&#8221;);
2. SolrQuery solrQuery = new SolrQuery(“solr”);
3. SolrResponse response = solrServer.query(solrQuery);

Nous allons utiliser SolrJ dans le contrôleur REST, mais commençons par déclarer le SolrServer dans le contexte Spring de notre DispatcherServlet :

1. <bean id=“solrServer” class=“org.apache.solr.client.solrj.impl.CommonsHttpSolrServer”>
2. <constructor-arg value=“http://localhost:8983/solr/&#8221; />
3. </bean>

Nous pouvons ensuite l’injecter dans le contrôleur, avec l’annotation standard @Inject :

1. import javax.inject.Inject;
2. import org.apache.solr.client.solrj.SolrServer;
4. @Controller
5. public class CatalogueController {
7. @Inject
8. private SolrServer solrServer;
10. (…)
12. }

Notez que l’utilisation de l’interface SolrServer nous permet de changer d’implémentation à tout moment : l’implémentation distante (celle que nous utilisons) pour la production, car elle permet d’attaquer un serveur Solr dédié, ou une implémentation locale pour le développement, qui attaquerait une instance embarquée de Solr.
Modifions maintenant la méthode search pour qu’elle récupère depuis l’URL la requête Solr et qu’elle utilise le SolrServer pour récupérer les documents et les transformer en Produit :

1. import org.apache.solr.client.solrj.SolrQuery;
2. import org.apache.solr.client.solrj.SolrResponse;
3. import org.apache.solr.client.solrj.SolrServer;
4. import org.apache.solr.common.SolrDocument;
5. import org.apache.solr.common.SolrDocumentList;
6. import org.springframework.web.bind.annotation.PathVariable;
8. (…)
10. @Controller
11. public class CatalogueController {
13. @Inject
14. private SolrServer solrServer;
16. @RequestMapping(value=“/search/{query}”,method=RequestMethod.GET)
17. public ModelAndView search(@PathVariable String query) throws Exception {
18. SolrQuery solrQuery = new SolrQuery(query);
19. SolrResponse response = solrServer.query(solrQuery);
20. SolrDocumentList docs = (SolrDocumentList) response.getResponse().get(“response”);
21. Catalogue catalogue = new Catalogue();
22. for(SolrDocument doc : docs) {
23. catalogue.add(map(doc));
24. }
25. return new ModelAndView(“default”,“catalogue”,catalogue);
26. }
28. private Product map(SolrDocument doc) {
29. return new Product(doc.get(“id”).toString(),doc.get(“name”).toString(),doc.get(“manu”).toString());
30. }
32. }

Notez l’utilisation de l’annotation @PathVariable, qui permet de récupérer une partie de l’URL afin de l’utiliser comme paramètre dans le contrôleur. On peut tester cette première fonction REST avec un navigateur Web en exécutant la requête ‘solr’ : http://localhost:8080/springsolr/catalogue/search/solr (attention de bien avoir le serveur Solr lancé comme vu dans la première partie ! ). La réponse est la suivante :

1. <catalogue>
2. <products>
3. <product>
4. <id>SOLR1000</id>
5. <name>Solr, the Enterprise Search Server</name>
6. <manufacturer>Apache Software Foundation</manufacturer>
7. </product>
8. </products>
9. </catalogue>

Pour avoir plus de résultats (limités à 10 toutefois, mais cela est réglable dans la SolrQuery), utiliser l’URL suivante : http://localhost:8080/springsolr/catalogue/search/*:*.
Et pourquoi ne pas permettre à notre contrôleur d’indexer des produits ? Suivons les principes de REST et implémentons cela dans le contrôleur sous la forme d’une requête POST :

1. @Controller
2. public class CatalogueController {
4. (…)
6. @RequestMapping(value=“/index/{id}/{name}/{manu}”,method=RequestMethod.POST)
7. public void index(@PathVariable String id,@PathVariable String name,@PathVariable String manu,
8. HttpServletResponse response) throws Exception {
9. SolrInputDocument doc = new SolrInputDocument();
10. doc.addField(“id”,id);
11. doc.addField(“name”,name);
12. doc.addField(“manu”,manu);
13. solrSe rver.add(doc);
14. solrServer.commit();
15. response.setStatus(HttpServletResponse.SC_OK);
16. }
17. }

Il n’est malheureusement pas possible de tester simplement l’indexation avec un navigateur Web, car la requête attendue doit être en POST. Nous allons tester l’indexation dans la troisième partie de l’article, grâce à la partie cliente REST de Spring, le RestTemplate.