Pages JSF embarquées dans un jar?

Bonjour,

Je cherche à embarquer des pages JSP/JSF dans un fichier jar.
quelqu'un sait-il s'il est possible de surcharger le comportement par défaut de l'application web pour aller chercher les ressources JSP/JS/CSS/... ailleurs que dans la racine du war mais plutôt dans un jar situé dans WEB-INF/lib.

Voici un exemple de contenu d'une archive war :
| index.jsp
|-/css
|-/js
|-/WEB-INF
|-/WEB-INF/classes
|-/WEB-INF/lib
|-/WEB-INF/lib/test.jar

Je souhaiterais par ex que mes ressources JSP/CSS/JS puisse être lu directement dans test.jar.

conscient qu'un fichier WAR est déja un plugin pour un conteneur d'application, je souhaiterais voir s'il est possible de créer des plugins d'applications web... je parviens déja à charger depuis un jar inclus dans un WEB-INF/lib d'un war des fichiers de config faces-config.xml, des fichiers de config XML spring et il ne me reste plus qu'à trouver le moyen de charger des ressources visuelles (JSP/JS/CSS) depuis un jar...mais là je ne sais pas si cela est faisable...

Bingo!

bon, je me répond à moi même...
finalement, j'ai trouvé comment faire: mon application utilise les frameworks Facelets, RichFaces, Spring et JPA.
Facelets permet d'implémenter son propre ResourceResolver, j'en est donc créer un qui avant de déléguer au DefaultResourceResolver va chercher la resource dans le classpath et puis c'est tout...
Allez je flague "Résolu", mais si cela interesse quelqu'un je veux bien donner plus de détails!
@+

Demande de complément

Bonjour,

je suis fortement intéresse par ta solution.
Je recherche à créer des plugins pour une application web.
je pense donc intégrer des pages JSF/JSP dans un JAR qui se trouvera dans le classpath ou un répertoire qui serai définit dans une variable d'environnement.

peux tu m'apporter ton aide.

Bonjour,
tout d'abord je tiens à attirer ton attention sur le fait que cette solution ne fonctionne que si tu utilises l'API facelets (système de templating JSF)

1/ Il te faut configurer ton environnement pour prendre en charge les facelets
2/ Dans ton descripteur de déploiement WEB-INF/web.xml, il faut ajouter les deux bouts de configurations suivants:
a/ dans la section <context-param>:

Code:

1
2
3
4
5
6
7
8
9
10
 
### Permet de récupérer les .xhtml depuis un jar ### 
<context-param> 
	<param-name>facelets.REFRESH_PERIOD</param-name> 
	<param-value>-1</param-value> 
</context-param> 
<context-param>
	<param-name>facelets.RESOURCE_RESOLVER</param-name>
	<param-value>org.schellenberger.websporttracker.web.ClasspathResourceResolver</param-value> 
</context-param>

b/ dans la section <servlet> et <servlet-mapping>:

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
 
<servlet> 
	<description></description> 
	<display-name>ClasspathServlet</display-name>
	<servlet-name>ClasspathServlet</servlet-name>
	<servlet-class>org.schellenberger.websporttracker.web.ClasspathServlet</servlet-class> 
</servlet> 
<servlet-mapping> 
	<servlet-name>ClasspathServlet</servlet-name>
	<url-pattern>*.css</url-pattern> 
</servlet-mapping> 
<servlet-mapping> <servlet-name>ClasspathServlet</servlet-name> 
	<url-pattern>*.png</url-pattern> 
</servlet-mapping> 
<servlet-mapping>
	<servlet-name>ClasspathServlet</servlet-name>
	<url-pattern>*.jpg</url-pattern>
</servlet-mapping>
<servlet-mapping>
	<servlet-name>ClasspathServlet</servlet-name>
	<url-pattern>*.jpeg</url-pattern>
</servlet-mapping>
<servlet-mapping>
	<servlet-name>ClasspathServlet</servlet-name> 
	<url-pattern>*.gif</url-pattern> 
</servlet-mapping> 
<servlet-mapping> 
	<servlet-name>ClasspathServlet</servlet-name>
	<url-pattern>*.js</url-pattern> 
</servlet-mapping>

3/ Créer la classe ClasspathResourceResolver référencée dans ton web.xml (cette classe te permet de récupérer les fichiers xhtml depuis ton classpath afin qu'ils puissent être traités par le moteur de facelets):

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
 
package org.schellenberger.websporttracker.web;
 
import java.net.URL;
 
import com.sun.facelets.impl.DefaultResourceResolver;
import com.sun.facelets.impl.ResourceResolver;
 
public class ClasspathResourceResolver extends DefaultResourceResolver 
        implements ResourceResolver {
 
 
    @Override
    public URL resolveUrl(String path) {
 
        URL url = super.resolveUrl(path);
        if (url == null) {
 
            /* classpath resources don't start with / */
            if (path.startsWith("/")) {
                path = path.substring(1);
            }
            url = Thread.currentThread().getContextClassLoader().
                    getResource(path);
        }
        return url;
    }
}

4/ Créer la classe ClasspathServlet (cette classe permet de récupérer toutes les autres ressources statiques comme les images, les feuilles de styles, ...)

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
 
package org.schellenberger.websporttracker.web
 
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.logging.Logger;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
/**
 * Cette servlet permet d'acceder à des ressources statiques présentes dans le classpath. L'accès aux fichiers java est restreint.
 */
public class ClasspathServlet extends HttpServlet {
	/**
         * 
         */
	private static final long serialVersionUID = 1L;
	private Logger log = Logger.getLogger(getClass().getName());
 
	/** default constructor */
	public ClasspathServlet() {
	}
 
	/** sert le fichier depuis le classpath */
	@Override
	public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 
		/* si la servlet n'est pas associé à un chemin on utilise l'URI */
		String path = request.getPathInfo();
		if (path == null) {
			path = request.getRequestURI().substring(request.getContextPath().length());
		}
 
		/* Restrictions */
		if (path.endsWith(".class")) {
			response.sendError(403, path + " denied");
			return;
		}
 
		/* Recherche de la ressource */
		log.fine("Looking for " + path + " on the classpath");
		URL resource = Thread.currentThread().getContextClassLoader().getResource(path.substring(1));
		if (resource == null) {
			response.sendError(404, path + " not found on classpath");
		} else {
 
			/* test de la date de modif du fichier */
			URLConnection connection = resource.openConnection();
			long lastModified = connection.getLastModified();
			long ifModifiedSince = request.getDateHeader("If-Modified-Since");
			if (ifModifiedSince != -1 && lastModified <= ifModifiedSince) {
				response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
				return;
			}
 
			/* Ecriture de la réponse*/
			response.setContentType(getServletContext().getMimeType(path));
			OutputStream out = new BufferedOutputStream(response.getOutputStream(), 512);
			InputStream in = new BufferedInputStream(resource.openStream(), 512);
			try {
				int len;
				byte[] data = new byte[512];
				while ((len = in.read(data)) != -1) {
					out.write(data, 0, len);
				}
			} finally {
				out.close();
				in.close();
				if (connection.getInputStream() != null) {
					connection.getInputStream().close();
				}
			}
		}
	} /* doGet() */
}

A vue de nez, je pense ne rien avoir oublié.

Pour finir, bien que cette solution fonctionne très bien je l'ai abandonné au profit d'une autre architecture plus souple qui conserve tout de même l'approche noyau/plugins.

Bonjour,

A la fin de ton message tu dis que tu a choisi une autre architecture noyau/plugin.

Peux tu m"en dire un peux plus car c'est ce que je cherche à faire?

merci d'avance