Charger un fichier javascript pour un composant JSF perso

Salut à tous

je souhaiterais charger un fichier js pour un ou plusieurs composant jsf que j'ai dévellopé, ces composant utilisent dans leur renderer pas mal de javascript mais cela nécessite au préalable un chargement d'un fichier js en tout début.

Mon but est de créer plusieurs composant réutilisable dans d'autres applications, donc sous forme de jar, ce serait comme une petite librairie de composants.

Comment puis-je charger mon fichiers javascript pour tous ces composant jsf ?

tout comme les librairies ou framework jsf connu il s'agit d'épargner à l'utilisateur d'ajouter les balises <script src...> dans le header de ses pages. comment ils s'y prennent ??

merci d'avance à celui qui connait

Ta question, je me la suis posée il y a quelques temps... En recherchant à nouveau, j'ai trouvé ce lien, qui mène à ce lien qui devrait résoudre ton problème...

Salut romaintaz

En effet en passant par un phase Listener on y arrive, le principe est pas mal, même s'ils obligent à mettre les fichiers ressources dans le dossier META-INF d'après leur code.
Sinon plus généralement j'ai eu l'occasion de regarder rapidement dans un bouquin : "Core JavaServer Faces second edition" j'ai retenu qu'il y avait 4 pricipales mannières pour charger des ressources (css, js, jpg...) à partir d'un jar dont je vous dévoile la liste :D

1) avec une servlet qui va localiser les ressources
2) avec un servlet filter, comme Myfaces tomahawk utilise extension Filter
3) en utilisant weblet ça nécessite un fichier de configuration weblet-config.xml
4) et enfin avec un Phase Listener dont voici le détail comment y remédier

Il faut définir le Phase Listener qui va charger contrôler les url

Code:

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
package myPackage;
 
/**
* @author Mediii.
*/
 
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.Map;
import javax.faces.FacesException;
import javax.faces.application.ViewHandler;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.event.PhaseEvent;
import javax.faces.event.PhaseId;
import javax.faces.event.PhaseListener;
import javax.servlet.http.HttpServletResponse;
 
public class ResourcePhaseListener implements PhaseListener {
 
   public static final String RESOURCE_PREFIX = "/resource";
 
   public static final String RESOURCE_LOCATION_PARAM = "r";
 
   public static final String CONTENT_TYPE_PARAM = "ct";
 
   public static final String DEFAULT_CONTENT_TYPE = "application/octet-stream";
 
   private Map<String, String> extensionToContentType = null;
 
   public ResourcePhaseListener() {
      extensionToContentType = new HashMap<String, String>();
      extensionToContentType.put(".js", "text/javascript");
      extensionToContentType.put(".gif", "image/gif");
      extensionToContentType.put(".jpg", "image/jpeg");
      extensionToContentType.put(".jpeg", "image/jpeg");
      extensionToContentType.put(".png", "image/png");
      extensionToContentType.put(".css", "text/css");
   }
 
   public PhaseId getPhaseId() {
      return PhaseId.RESTORE_VIEW;
   }
 
   public void beforePhase(PhaseEvent phaseEvent) {
   }
 
   public void afterPhase(PhaseEvent event) {
      if (event.getFacesContext().getViewRoot().getViewId().startsWith(
            RESOURCE_PREFIX)) {
         FacesContext context = event.getFacesContext();
         ExternalContext external = context.getExternalContext();
 
         String resourcePath =
               (String) external.getRequestParameterMap().get(
                     RESOURCE_LOCATION_PARAM);
         if (resourcePath == null)
            return;
 
         String contentType =
               (String) external.getRequestParameterMap().get(
                     CONTENT_TYPE_PARAM);
         if (contentType == null) {
            int extensionIndex = resourcePath.lastIndexOf(".");
            if (extensionIndex != -1)
               contentType =
                     extensionToContentType.get(resourcePath
                           .substring(extensionIndex));
            if (contentType == null)
               contentType = DEFAULT_CONTENT_TYPE;
         }
 
         InputStream in = getClass().getResourceAsStream(resourcePath);
         HttpServletResponse servletResponse =
               (HttpServletResponse) external.getResponse();
         try {
            OutputStream out = servletResponse.getOutputStream();
            servletResponse.setContentType(contentType);
            int ch;
            while ((ch = in.read()) != -1)
               out.write(ch);
         } catch (IOException ex) {
            throw new FacesException(ex);
         }
         context.responseComplete();
      }
   }
 
   /**
    * Returns a URL for fetching a resource through this listener
    * 
    * @param context the faces context
    * @param String resourcePath the path to the resource
    * @param String contentType the content type to include in the URL, or null
    *           if no content type should be included
    * @return the URL of the form
    *         /appname/resource.faces?r=resourcePath,ct=contentType or
    *         /appname/faces/resource?r=resourcePath,ct=contentType
    */
   public static String getURL(FacesContext context, String resourcePath,
         String contentType) {
      ViewHandler handler = context.getApplication().getViewHandler();
 
      String url = handler.getActionURL(context, RESOURCE_PREFIX);
      StringBuilder r = new StringBuilder(url);
      r.append("?" + RESOURCE_LOCATION_PARAM + "=").append(resourcePath);
      if (contentType != null)
         r.append("," + CONTENT_TYPE_PARAM + "=").append(contentType);
      return r.toString();
   }
}

ensuite dans le renderer d'un composant on peut appeler un script contenu dans un jar par exemple si le chemin est resources/js/myscript.js alors on ecrira :

Code:

1
2
3
4
5
6
7
...
writer.startElement("script", component);
writer.writeAttribute("src", ResourcePhaseListener.getURL(context, "/resources/js/myscript.js", null), null);
writer.writeAttribute("type", "text/javascript", null);
writer.endElement("script");
...

ne pas oublier de déclarer dans le faces-config.xml notre phaseListener

Code:

1
2
3
4
5
 
 
<lifecycle>
        <phase-listener>myPackage.ResourcePhaseListener</phase-listener>
</lifecycle>

Voila pour ce PhaseListener !

Bonus : il y a une dernière solution à utiliser si l'en veut pas faire de phaseListener, en utilisant le composant de a4j
<a4j:loadScript src="resource///resources/js/myscript.js"/>

en fesant bien attention de mettre le prefix "resource//" avant votre url.

Maintenant le fichier javascript est bien chargé à partir d'un jar, j'aimerais savoir comment peut-on faire appel au script dans la balise <HEAD> de notre page ??

j'ai regarder un peu dans les sources de a4j car le composant <a4j:loadScript> mets bien les scripts dans le header de la page, alors comment il va chercher cette balise et si elle n'existe pas il en crée une. le code source de a4j est bien trop complexe pour retrouver cmt il fait ça, si qq1 sait merci de m'en faire part.