Discussion :

[Azerx]

Bonjour,
étant actuellement en train de développer un service web REST intégrant une API, je me vois confronté à un problème.
En effet, ce dernier fonctionne parfaitement quand il est utilisé par un utilisateur à la fois, mais quand deux utilisateurs font une demande en même temps l'API met un temps qui semble infini à répondre ce qu'on lui demande.
Ma question est donc de savoir d'où pourrait venir ce problème, ou bien de savoir comment séparer les ressources afin que chaque utilisateur puisse accéder à l'API sans engendrer de conflits.

Bien entendu si ce n'est pas clair n"hésitez pas à me demander plus de détails!
Merci d'avance!

[jeffray03]

salut,
as-tu deja entendu parler de ceci:
lien

Eric

[Azerx]

salut,
as-tu deja entendu parler de ceci:
lien

Eric

Merci pour votre réponse rapide! Je vais voir ça de suite!

[Azerx]

Après avoir parcouru une multitude de pages informatives et tutoriels, j'ai bien l'impression que cela correspond à ce que je dois mettre en place.
Cependant je n'arrive pas à voir comment je pourrais modifier ce que j'ai aujourd'hui pour que cela devienne asynchrone

Ce que j'ai aujourd'hui (en très simplifié):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
 
       //[...]
       fonctionTresLente();
       request.setAttribute("unAttribut", variableUne);
       //[...]
       request.setAttribute("unAutre", variableDeux);
 
       this.getServletContext().getRequestDispatcher("lien/maJSP.jsp").forward(request, response);
}

[Azerx]

Je ne suis toujours pas arrivé à mettre en place une solution qui fonctionne. Cependant j'ai aussi vu que l'utilisation des Thread pourrait me servir (ici et là sont les exemples que j'ai essayé).
De l'aide?

[jeffray03]

salut,
voici un exemple que je viens de tester:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
package in.webtuts.rest.resources;
 
import java.util.concurrent.TimeUnit;
 
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.container.AsyncResponse;
import javax.ws.rs.container.Suspended;
import javax.ws.rs.container.TimeoutHandler;
import javax.ws.rs.core.Response;
 
@Path("/resource")
public class AsyncResource {
 
  @GET
  @Path("/timeoutAsync")
  public void asyncGetWithTimeout(@Suspended final AsyncResponse asyncResponse) {
    asyncResponse.setTimeoutHandler(new TimeoutHandler() {
      @Override
      public void handleTimeout(AsyncResponse asyncResponse) {
        asyncResponse.resume(Response.status(Response.Status.SERVICE_UNAVAILABLE).entity("Operation time out.").build());
      }
    });
    asyncResponse.setTimeout(5, TimeUnit.SECONDS);
 
    new Thread(new Runnable() {
 
      @Override
      public void run() {
        String result = veryExpensiveOperation();
        asyncResponse.resume(result);
      }
 
      private String veryExpensiveOperation() {
        return "Very Expensive Operation with Timeout";
      }
    }).start();
  }
 
}

et un Test pour verifier cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
package in.webtuts.rest.resources;
 
import java.net.URI;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
 
import javax.ws.rs.client.AsyncInvoker;
import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.Response;
 
import org.glassfish.grizzly.http.server.HttpServer;
import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory;
import org.glassfish.jersey.server.ResourceConfig;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
public class AsyncResourceTest {
 
  private HttpServer httpServer;
  private WebTarget webTarget;
  private static final URI baseUri = URI.create("http://localhost:8080/rest/");
 
  @Before
  public void setup() throws Exception {
    //create ResourceConfig from Resource class
    ResourceConfig rc = new ResourceConfig(AsyncResource.class);
 
    //create the Grizzly server instance
    httpServer = GrizzlyHttpServerFactory.createHttpServer(baseUri, rc);
    //start the server
    httpServer.start();
 
    //configure client with the base URI path
    Client client = ClientBuilder.newClient();
    webTarget = client.target(baseUri);
  }
 
  @After
  public void tearDown() throws Exception {
    //if you want to stop the server from the input through keyboard then uncomment below two lines
    // System.out.println(String
    // .format("Application started.%nHit enter to stop it..."));
    // System.in.read();
 
    //stop the server
    httpServer.shutdown();
  }
 
  @Test
  public void testAsyncGetWithTimeout() throws InterruptedException, ExecutionException {
    final AsyncInvoker asyncInvoker = webTarget.path("resource/timeoutAsync").request().async();
    final Future<Response> responseFuture = asyncInvoker.get();
    System.out.println("Request is being processed asynchronously.");
    final Response response = responseFuture.get();
    // get() waits for the response to be ready
    System.out.println("Response received : " + response);
    System.out.println("Response from GET method : " + response.readEntity(String.class));
  }
 
}

le fichier web.xml:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
<?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"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    id="WebApp_ID" version="3.0">
    <display-name>rest</display-name>
    <servlet>
        <servlet-name>REST</servlet-name>
        <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
        <init-param>
            <param-name>jersey.config.server.provider.packages</param-name>
            <param-value>in.webtuts.rest.resources</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!-- Map /rest/* to Jersey -->
    <servlet-mapping>
        <servlet-name>REST</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
</web-app>

sie t´as des questions n´hesites pas.

Eric

[Azerx]

Merci pour cette réponse (très) détaillée!
Je pense que la structure de mon code n'est pas bonne... elle ne ressemble pas du tout à ça
Je vais travailler la dessus et posterais ma solution plus tard.

[Azerx]

Voilà, j'ai essayé de refaire ma structure afin qu'elle corresponde à celle de l'exemple et je suis arrivé à ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
@Path("/async")
public class TestAsync {
 
	    @POST
	    public void asyncGet(@Suspended final AsyncResponse asyncResponse) {
 
	        new Thread(new Runnable() {
	            @Override
	            public void run() {
	                String result = veryExpensiveOperation();
	                asyncResponse.resume(result);
	            }
 
	            private String veryExpensiveOperation() {
				String ok = "Hello World";
	            	        System.out.println(ok);
 
	        		maFonctionTresLourde();
 
					return ok;
	            }
 
	        }).start();
	    }
}

Mais rien à faire, quand deux utilisateurs l'appellent en même temps je suis toujours confronté au même problème...

[Pill_S]

Je penche plutôt pour du dead lock (un thread attend la libération d'une ressource verrouillée par un autre thread, lui-même attendant la libération d'une ressource lockée par le premier thread), ou de la contention (l'appli passe son temps à verrouiller/déverrouiller des ressources)

dans tous les cas, un coup de profiler (jprofiler est le meilleur) s'avère indispensable pour avoir une vue d'ensemble de ce qu'il se passe...

PS: lancer des threads directement comme ça, en mode webapp, c'est de toute façon vraiment pas une bonne idée...

[Azerx]

Oui, je suis en train de regarder de ce coté là! Je vous tiens au courant si je trouve quelque chose de mon coté

[jeffray03]

c´est plutot pas mal,
j´y avais pas pensé.
eric

[Azerx]

Trouvé! Effectivement une ressource était partagée par les deux processus actifs! Merci à ceux qui ont consacré un peu de leur temps pour m'aider!