Probléme de multiclick

Salut,

j'aimerais savoir si quelqu'un à des problémes avec le "multiclick". Lorsque l'on clique plusieurs fois sur le même bouton à la suite, la fonction s'éxecute plusieurs fois. c'est assez embetant. j'aimerais que ma fonction se termine avant de pouvoir l'executer une seconde fois.

avez vous ce probléme ?

Pour l'instant je pense à bloquer le bouton par javascript (disabled = true). Mais c'est bof quand même.

hello tu peux mettre un disable="#{bean.isDisable}" et dans ta fonction tu mets isDisable a true

merci mais ça ne marche pas :cry: .

disable="#{bean.isDisable}" , c'est une action coté server donc le bouton sera disable apres que la page soit ré-affiché (donc apres que la fonction se soit fini).

Or j'aimerais que des que quelqu'un click le bouton soit inactif pour eviter un double click et donc 2 appel à la fonction.

Pour l'instant je ne vois que du javascript pour faire cela. et ici http://forum.java.sun.com/thread.jsp...472&tstart=135 une tres belle solution à base de filter et de servlet mais que je n'ai pas reussi à implémenter.

avant de chercher une solution, j'aimerais savoir si tout le monde à le meme probléme. Si on double click sur un bouton on passe 2 fois de suite dans la fonction ? Pas moyen de synchronized les fonctions ?

la meilleur solution que j'ai trouve pour remedier a ce probleme c'est celle la:

Citation:

---

For the purpose of identifying each submitted form uniquely, I wrote a custom tag as shown below:

package jsf.addon.tag;

import java.io.IOException;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.TagSupport;

import jsf.addon.navigation.RequestController;

public class RequestIdTag extends TagSupport
{
private static final long serialVersionUID = 5L;

private String paramName = "requestId"; //the default value

public String getParamName()
{
return paramName;
}

public void setParamName(String name)
{
this.paramName = name;
}

public int doStartTag() throws JspException
{
JspWriter out = pageContext.getOut();

try
{
RequestController rc = null;

rc = (RequestController) pageContext.getSession().getAttribute("requestController");
if(rc == null)
{
rc = new RequestController();
pageContext.getSession().setAttribute("requestController", rc);
}

rc.setExpectedRequestId(System.currentTimeMillis());

out.write("<input type=\"hidden\" name=\"" + paramName + "\" value=\"" + rc.getExpectedRequestId() + "\" />");
}
catch (IOException e)
{
throw new JspException("RequestIdTag", e);
}

return SKIP_BODY;
}

public int doEndTag()
{
return EVAL_PAGE;
}
}

The following is the <tag> element definition in the TLD file:

<tag>
<name>requestId</name>
<tag-class>jsf.addon.tag.RequestIdTag</tag-class>
<body-content>empty</body-content>
<description>
Tag to identidy the request.
This tag creates a hidden input with current time in mills as the value.
</description>
<attribute>
<name>paramName</name>
<required>false</required>
<rtexprvalue>false</rtexprvalue>
<description>
Name to be assigned to the requestId. If not specified "requestId" is used.
</description>
</attribute>
</tag>

Next, the Filter implementation is as follows:

package jsf.addon.filter;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import jsf.addon.navigation.RequestController;

public class RequestControlFilter implements Filter
{
protected FilterConfig config;

public void init(FilterConfig config) throws ServletException
{
this.config = config;
}

public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException
{
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) resp;

RequestController rc = (RequestController) request.getSession().getAttribute("requestController");

if(rc == null)
{
rc = new RequestController();
request.getSession().setAttribute("requestController", rc);
}

rc.control(request, response, chain, config);
}

public void destroy()
{
}
}

Include the following in the web.xml file:

<filter>
<filter-name>requestControlFilter</filter-name>
<filter-lass>
jsf.addon.filter.RequestControlFilter</filter-class>
</filter>

<filter-mapping>
<filter-name>requestControlFilter</filter-name>
<servlet-name>Faces Servlet</servlet-name>
</filter-mapping>

The following is the implementation of the RequestController:

package jsf.addon.navigation;

import java.io.IOException;

import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import jsf.addon.response.ResponseWrapper;

public class RequestController
{
private long expectedRequestId;
private long previousRequestId;
private String responseContent;

public long getExpectedRequestId()
{
return expectedRequestId;
}

public void setExpectedRequestId(long expectedRequestId)
{
this.expectedRequestId = expectedRequestId;
}

public long getPreviousRequestId()
{
return previousRequestId;
}

public void setPreviousRequestId(long previousRequestId)
{
this.previousRequestId = previousRequestId;
}

public String getResponseContent()
{
return responseContent;
}

public void setResponseContent(String responseContent)
{
this.responseContent = responseContent;
}

public void control(HttpServletRequest request, HttpServletResponse response,
FilterChain chain, FilterConfig config)
throws IOException, ServletException
{
long currentRequestId = 0;

String requestId = request.getParameter("requestId");

if(requestId != null)
{
currentRequestId = Long.parseLong(requestId);
}

if(currentRequestId <= 0)
{
//this may be the request for the very first page of this application
//hence, just continue
chain.doFilter(request, response);
return;
}

try
{
synchronized(this)
{
if(currentRequestId != previousRequestId)
{
//this is the first and valid request for the current page
setResponseContent(null);

ResponseWrapper responseWrapper = new ResponseWrapper(response);

chain.doFilter(request, responseWrapper);

//by now we must have a valid response

//get the response string from the response wrapper
String responseContent = responseWrapper.getResponseContent();
setResponseContent(responseContent);

//save the current request-id
setPreviousRequestId(currentRequestId);
}
}
}
catch(Exception ex)
{
ex.printStackTrace();
}
finally
{
config.getServletContext().getRequestDispatcher("/loopBack").forward(request, response);
}
}
}

The implementation of the RequestWrapper:

package jsf.addon.response;

import java.io.PrintWriter;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;

public class ResponseWrapper extends HttpServletResponseWrapper
{
private ServletOutputStreamWrapper sosw = new ServletOutputStreamWrapper();
private PrintWriter pw = new PrintWriter(sosw);

public ResponseWrapper(HttpServletResponse response)
{
super(response);
}

public ServletOutputStream getOutputStream() throws java.io.IOException
{
return sosw;
}

public PrintWriter getWriter() throws java.io.IOException
{
return pw;
}

public String getResponseContent()
{
return sosw.toString();
}
}

The implementation of the ServletOutputStreamWrapper:

package jsf.addon.response;

import java.io.ByteArrayOutputStream;
import java.io.IOException;

import javax.servlet.ServletOutputStream;

public class ServletOutputStreamWrapper extends ServletOutputStream
{
private ByteArrayOutputStream baos = new ByteArrayOutputStream();

public void write(int character) throws IOException
{
baos.write(character);
}

public String toString()
{
return baos.toString();
}
}

Finally, the implementation of the LoopBackServlet:

package jsf.addon.servlet;

import java.io.IOException;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import jsf.addon.navigation.RequestController;

public class LoopBackServlet extends HttpServlet
{
private static final long serialVersionUID = 6L;

public void init(ServletConfig config) throws ServletException
{
super.init(config);
}

protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException
{
super.service(request, response);
}

public void destroy()
{
super.destroy();
}

protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException
{
//retrieve the request controller from the session
RequestController rc = (RequestController) request.getSession().getAttribute("requestController");

ServletOutputStream out = response.getOutputStream();
out.print(rc.getResponseContent());
}

protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
{
doGet(req, resp);
}
}

Include the following elements in the web.xml:
<servlet>
<servlet-name>LoopBackServlet</servlet-name>
<servlet-class>jsf.addon.servlet.LoopBackServlet</servlet-class>
<load-on-startup>3</load-on-startup>
</servlet>
…
<servlet-mapping>
<servlet-name>LoopBackServlet</servlet-name>
<url-pattern>/loopBack</url-pattern>
</servlet-mapping>

In all your JSPs include the tag <ad:requestId/> anywhere inside the <h:form> element.

Let me know if you need any more help.

---

la solution est ecrite par un internaute BasheerShaik

Salut,
le code au dessus me parait bien lourd pour juste desactiver un boutton, le javascript est fait pour ca, j'ai le meme besoin que toi, je l'utlise et ca fonctionne très bien

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

<script type="text/javascript" language="javascript"> function waitSearch() { document.getElementById('content:searchButton').disabled = true; } </script>   [...]   <a4j:commandButton id="searchButton" value="Search" reRender="mainPanel,searchButton" action="#{contactSearchGUI.findContacts}" onclick="javascript:waitSearch()" />

---

tu peux aussi ajouter les attributs type="submit" et disabled="false" à ton commandButton mais ce sont les valeurs par defaut (il me semble), du coup dès que le process est terminé et que la page est rechargée, le boutton redevient actif.

pour ce code ca ne se fais pas cote client mais cote serveur.
aussi tu peut l'ameliorer en faisant un render kit pour tous les forms donc t'as pas a specifier ca pour chaque bouton ou form.
quand tu dit lourd de quoi veux te dire????

Déjà, je ne comprend pas trop comment c'est possible coté serveur, car justement, ce que l'on cherche ici, c'est desactiver un boutton jusqu'au retour serveur, or si c'est le serveur qui le gere, ca ne sert plus à rien...

A part en Javascript, je vois mal comment faire...

bon grossomodo la solution consiste si l'utilisateur click plusieur fois sur le bouton seulement la reponse de la premier solution luis sera envoyer (toute les phases jsf ne seront pas invoque pour les click ulterieur)