FAQ Java EEConsultez toutes les FAQ

Nombre d'auteurs : 27, nombre de questions : 85, dernière mise à jour : 3 mai 2015  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums de http://www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous trouvez une erreur, ou que vous souhaitez nous aider en devenant rédacteur, lisez ceci.


SommaireServletsServlets Généralités (20)
précédent sommaire suivant
 

Une servlet est un peu comme un applet par le fait qu'elle possède une méthode init() qui agit en tant que constructeur. Puisque l'environnement de servlet prend soin d'instancier la servlet, un constructeur explicite n'est pas nécessaire. N'importe quel code d'initialisation que vous devez utiliser devrait être placé dans la méthode init() puisque cette méthode est appelée lorsque la servlet est chargée par le conteneur de servlet.

Mis à jour le 16 février 2005 Stessy

doGet() est appelée à la suite d'une requête de type HTTP GET. Cela se passe généralement lorsqu'un utilisateur clique sur un lien ou lorsque celui-ci entre une URL dans la barre d'adresse du navigateur.

La méthode doPost() est appelée en réponse d'une requête HTTP POST.

Les deux méthodes sont appelées à partir de l'implémentation par défaut de la méthode service() se trouvant dans la classe de base HttpServlet.

Fondamentalement, le navigateur demande toujours des pages par l'intermédiaire de GET et peut envoyer des données sous les deux formes GET et POST. Les deux seules différences résident dans le fait que :

  • GET est restreint au niveau de la taille des paramètres envoyés au serveur. Cela veut dire qu'il est, la plupart du temps, préférable d'envoyer des données avec la méthode POST ;
  • envoyer des données par l'intermédiaire de GET évoque également une question concernant la sécurité puisqu'elles sont ajoutées à la suite de l'URL. Pour cette raison il est plus prudent d'utiliser la méthode POST pour envoyer des données au serveur.

Mis à jour le 16 février 2005 Stessy

Les caractères spéciaux sont souvent une cause de problème lors de l'utilisation des servlets.
Même si nous déclarons (l'UTF-8 par exemple) dans nos pages servlets et jsps, on peut voir apparaître les caractères spéciaux non gérés.
Pour cela, il suffit de faire une vérification comme suit :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
String encoding = request.getCharacterEncoding(); 
  
if (encoding == null || !encoding.equals("UTF-8")) { 
	try { 
		request.setCharacterEncoding("UTF-8"); 
	} catch (UnsupportedEncodingException e) { 
		System.err.println("HttpMultipartRequest - : " + e); 
	} 
}
Une autre façon de faire est de configurer l'encodage au niveau du fichier web.xml au moyen d'un Filter :

Code xml : Sélectionner tout
1
2
3
4
5
6
7
8
9
<filter> 
	<filter-name>Character Encoding</filter-name> 
	<filter-class>chemin.de.ton.package.CharsetFilter</filter-class> 
</filter> 
  
<filter-mapping> 
	<filter-name>Character Encoding</filter-name> 
	<servlet-name>action</servlet-name>	 
</filter-mapping>
Puis d'implémenter un filtre UTF-8 :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/** 
 * Filtre sur les requetes pour les encoder en UTF-8   
 */ 
public class CharsetFilter implements Filter{ 
  
	@Override 
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { 
  
		request.setCharacterEncoding("UTF-8"); 
		chain.doFilter(request,response); 
	 } 
  
	@Override 
	public void init(FilterConfig arg0) throws ServletException {} 
  
	@Override 
	public void destroy() {} 
}

Mis à jour le 21 mai 2009 link256 X-plode

L'interface ServletContext inclut les méthodes getMajorVersion() et getMinorVersion() pour vous indiquer quelle version de l'API Servlet est utilisée.

Un petit exemple :

Code java : Sélectionner tout
1
2
3
4
5
//Si le moteur de servlet implémente la spec 2.4 de l'API servlet  
//majorVersion est égal à 2  
int majorVersion = getServletContext().getMajorVersion(); 
//minorVersion est égal à 4  
int minorVersion = getServletContext().getMinorVersion();

Mis à jour le 16 février 2005 Stessy

Pour pouvoir partager des variables entre vos pages JSP et vos servlets, vous devez savoir comment créer et accéder à ces variables depuis vos servlets.
Les différents exemples qui vont suivre dépendent de la portée, ou si vous préférez, la durée de vie de vos objets.

Pour en savoir plus sur les différentes portées existantes, reportez-vous à la section suivante : Quelles sont les différentes portées existantes ?

  • page

Dans cet exemple, le Bean est instancié comme une variable locale est n'est donc pas partageable entre différentes servlets :

Code java : Sélectionner tout
com.developpez.beans.MyBean myBean = new com.developpez.beans.MyBean();
  • request

Dans cet exemple, le Bean instancié sera accessible pendant toute la durée de la requête :

Code java : Sélectionner tout
1
2
3
4
5
com.developpez.beans.MyBean myBean = (com.developpez.beans.MyBean) request.getAttribute("myBean"); 
if (myBean == null) {  
	myBean = new com.developpez.beans.MyBean(); 
	request.setAttribute("myBean", myBean);  
}
  • session

Dans cet exemple, lorsque le Bean est instancié, il est placé dans la session actuelle :

Code java : Sélectionner tout
1
2
3
4
5
6
HttpSession session = request.getSession(true); 
com.developpez.beans.MyBean myBean = (com.developpez.beans.MyBean) session.getAttribute("myBean"); 
if (myBean == null) { 
	myBean = new com.developpez.beans.MyBean(); 
	session.setAttribute("myBean", myBean); 
}
  • application

Dans ce dernier exemple, lorsque le Bean est instancié, il est placé dans le contexte de la servlet :

Code java : Sélectionner tout
1
2
3
4
5
com.developpez.beans.MyBean myBean = (com.developpez.beans.MyBean) getServletContext().getAttribute("myBean"); 
if (myBean == null) { 
	myBean = new com.developpez.beans.MyBean(); 
	getServletContext().setAttribute("counter", counter); 
}

Mis à jour le 16 février 2005 Stessy

L'objet ServletConfig est une interface. Cette interface contient les quatre méthodes suivantes :

  • getInitParameter(java.lang.String name) : cette méthode retourne un String contenant le paramètre d'initialisation de la servlet correspondant au paramètre name ;
  • getInitParameterNames() : cette méthode retourne un objet Enumeration contenant les paramètres d'initialisation de la servlet ;
  • getServletContext() : cette méthode retourne une référence de l'interface ServletContext ;
    C'est la méthode la plus valable, car elle permet de partager l'information à travers l'application ;
  • getServletName() : cette méthode retourne un String contenant le nom de l'instance de la servlet.

Mis à jour le 16 février 2005 Stessy

Dans le fichier web.xml situé dans le répertoire WEB-INF de l'application, il suffit d'ajouter les lignes suivantes :

Code xml : Sélectionner tout
1
2
3
<session-config> 
	<session-timeout>60</session-timeout> 
</session-config>

Mis à jour le 16 février 2005 bahamouth

Il suffit d'accéder à la session voulue et de la modifier comme ceci :

Code java : Sélectionner tout
request.getSession().setMaxInactiveInterval(int);

Mis à jour le 15 septembre 2005 Jaxofun

Cette information peut être retrouvée dans le header de la requête :

Code java : Sélectionner tout
String browser = request.getHeader("user-agent");

Mis à jour le 16 février 2005 Didier

Placez la définition <init-param> dans la description de votre servlet dans le fichier web.xml comme ceci :

Code xml : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
<servlet> 
	<servlet-name>maServlet</servlet-name> 
	<display-name>Ma Servlet</display-name> 
	<description>Ce que fait ma servlet</description> 
	<servlet-class>com.servlet.MaServlet</servlet-class> 
	<init-param> 
		<param-name>MON_PARAM</param-name> 
		<param-value>Bonjour</param-value> 
	</init-param> 
</servlet>
Puis, dans le code de votre servlet, utilisez ceci pour récupérer la valeur de MON_PARAM :

Code java : Sélectionner tout
getInitParameter("MON_PARAM");
Si vous désirez mettre plus de paramètres, il suffit d'ajouter des déclarations <init-param> comme ceci :

Code xml : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<servlet> 
	<servlet-name>maServlet</servlet-name> 
	<display-name>Ma Servlet</display-name> 
	<description>Ma Servlet</description> 
	<servlet-class>com.servlet.MaServlet</servlet-class> 
	<init-param> 
		<param-name>MON_PARAM</param-name> 
		<param-value>Bonjour</param-value> 
	</init-param> 
	<init-param> 
		<param-name>MON_PARAM_2</param-name> 
		<param-value>Bonjour</param-value> 
	</init-param> 
</servlet>
Si vous désirez mettre des paramètres de manière globale afin de pouvoir les récupérer dans toutes les servlets, il suffit d'ajouter <context-param> comme ceci :

Code xml : Sélectionner tout
1
2
3
4
5
6
7
<webapp> 
	... 
	<context-param> 
        <param-name>Author</param-name> 
        <param-value>X-plode</param-value> 
    </context-param> 
</webapp>
Puis, dans le code de votre servlet, il faut récupérer le contexte de la servlet et appeler la méthode getInitParameter comme la manière précédente pour récupérer la valeur de Author :

Code java : Sélectionner tout
getServletContext().getInitParameter("MON_PARAM");

Mis à jour le 16 février 2005 Righetto Dominique

Côté applet :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
URL urlservlet = new URL("http://localhost:8080/imed/ImageMapServlet"); 
HttpURLConnection connExtension = (HttpURLConnection)urlservlet.openConnection(); 
  
FileInputStream in = new FileInputStream(image); 
in.read(tableauImage);  
in.close(); 
  
HttpURLConnection connImage = (HttpURLConnection)urlservlet.openConnection(); 
connImage.setDoInput(true); 
connImage.setDoOutput(true); 
connImage.setUseCaches(false); 
connImage.setRequestProperty("Content-Type","application/octet-stream"); 
DataOutputStream out = new DataOutputStream(connImage.getOutputStream()); 
out.write(tableauImage, 0, tableauImage.length); 
out.flush();  
out.close();
Côté servlet

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
// Récupération du flux entrant 
java.io.DataInputStream dis = new java.io.DataInputStream(request.getInputStream()); 
dis.readFully(temp);  
dis.close(); 
  
// Écriture du fichier image sur le serveur  
File cibleServeur = new File("/repertoire/nomfichier"); 
FileOutputStream fos = new FileOutputStream(cibleServeur);  
fos.write(temp); 
fos.close();

Mis à jour le 16 février 2005 SnorkyBZH

Voici un exemple de code permettant de télécharger un fichier depuis le serveur vers le poste client :

Code java : Sélectionner tout
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
	response.setContentType("application/download"); 
	response.setHeader("Content-Disposition", "attachment;filename=\"" + filename + "\""); 
  
	ServletOutputStream out = response.getOutputStream(); 
	File file = null; 
	BufferedInputStream from = null; 
  
	try {  
		file = new File(filepath); 
		response.setContentLength((int) file.length());  
		int bufferSize = 64 * 1024; 
  
		from = new BufferedInputStream(new FileInputStream(file), bufferSize * 2); 
		byte[] bufferFile = new byte[bufferSize]; 
  
		for (int i = 0; ; i++) { 
  
			int len = from.read(bufferFile);  
  
			if (len < 0) { 
				break; 
			}  
  
			out.write(bufferFile, 0, len); 
		} 
		out.flush(); 
  
	} catch (FileNotFoundException e) { 
		e.printStackTrace(); 
	} catch (IOException e) { 
		e.printStackTrace(); 
	} finally { 
		if (from != null) { 
			try { 
				from.close(); 
			} catch (Exception e) { 
				e.printStackTrace(); 
			} 
		} 
		if (out != null) { 
			try { 
				out.close(); 
			} catch (Exception e) { 
				e.printStackTrace(); 
			} 
		} 
		if (file != null) { 
			try { 
				file.delete(); 
			} catch (Exception e) { 
				e.printStackTrace(); 
			} 
		} 
	}

Mis à jour le 16 février 2005 Stessy

En implémentant l'interface HttpSessionListener comme ceci :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.dvp.faq.javaee; 
  
import javax.servlet.http.HttpSessionListener; 
import javax.servlet.http.HttpSessionEvent; 
  
public class MyHttpSessionListener implements HttpSessionListener { 
  
	/** Cette méthode est appelée lors de la création de session */  
	public void sessionCreated(HttpSessionEvent hse){ 
  
		System.out.println("Une session vient d'être créée");  
	} 
  
	/** Cette méthode est appelée lors de la destruction de session*/  
	public void sessionDestroyed(HttpSessionEvent hse) { 
  
		System.out.println("Une session vient d'être détruite");  
	} 
}
Ensuite, il suffit de référencer le listener dans le fichier web.xml (sous la balise racine)

Code xml : Sélectionner tout
1
2
3
4
5
6
7
<web-app>  
	<listener> 
		<listener-class> 
			com.dvp.faq.javaee.MyHttpSessionListener 
		</listener-class 
	</listener> 
</web-app>

Mis à jour le 27 avril 2005 Righetto Dominique

En implémentant l'interface ServletContextListener comme ceci :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.dvp.faq.javaee; 
  
import javax.servlet.ServletContextListener; 
import javax.servlet.ServletContextEvent; 
  
public class MyHttpServletContextListener implements ServletContextListener { 
  
	/** Cette méthode appelée lors du démarrage de l'application*/  
	public void contextInitialized(ServletContextEvent sce) { 
  
		System.out.println("L'application vient de démarrer"); 
	} 
  
	/** Cette méthode appelée lors de l'arrêt de l'application*/  
	public void contextDestroyed(ServletContextEvent sce) { 
  
		System.out.println("L'application vient de s'arrêter"); 
	} 
}
Ensuite, il suffit de référencer le listener dans le fichier web.xml (sous la balise racine)

Code xml : Sélectionner tout
1
2
3
4
5
6
7
<web-app> 
	<listener> 
		<listener-class> 
			com.dvp.faq.javaee.MyHttpServletContextListener 
		</listener-class> 
	</listener> 
</web-app>

Mis à jour le 27 avril 2005 Righetto Dominique

À l'aide de l'interface HttpServletRequest

Code java : Sélectionner tout
String contextPath = request.getContextPath();

Mis à jour le 1er janvier 2004 SEMPERE Benjamin

De base, le navigateur va tenter d'afficher la page directement selon le flux de données qu'il reçoit. Dans le cas d'un fichier PDF par exemple, les données ne sont pas du tout affichables en l'état par le navigateur. C'est pourquoi il faut indiquer au navigateur le type de fichier qu'on lui envoie. Pour cela, il faut modifier le content-type de la réponse :

Code java : Sélectionner tout
response.setContentType("application/pdf");
Dans ce cas-là, le navigateur comprendra que le fichier retourné est un fichier PDF et agira en conséquence.

Il est également possible de modifier le nom du fichier en ajoutant un entête à la réponse :

Code java : Sélectionner tout
response.setHeader("Content-disposition", "filename=monNomDeFichier");

Mis à jour le 22 décembre 2009 ceddup

Pour accéder à une ressource depuis une servlet, il faut passer par l'interface ServletContext. Plus exactement la méthode : getRealPath(String relativePath).

Cette méthode recherche depuis la racine de l'application web le fichier passé en paramètre sous forme d'un chemin relatif.

Voici un exemple d'implémentation :

La ressource à laquelle on veut accéder : le fichier de propriété test.properties

Code : Sélectionner tout
clef1=hello World
Emplacement du fichier dans l'application web :

Code : Sélectionner tout
1
2
3
4
ROOT_WEB_APP 
   files 
      test.properties 
   WEB-INF
Voilà le code la servlet :

Code java : Sélectionner tout
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
public class TestServlet extends HttpServlet { 
  
	private static final String KEY = "clef1";  
	private static final String RELATIVE_PATH_FILE= "files/test.properties"; 
  
	protected void doGet(HttpServletRequest arg0, HttpServletResponse arg1) throws ServletException, IOException { 
  
		super.doGet(arg0, arg1); 
	} 
  
	protected void service(HttpServletRequest arg0, HttpServletResponse arg1) throws ServletException, IOException { 
  
		InputStream in = null; 
  
		ServletContext context = getServletContext(); 
  
		System.out.println("Affichage du chemin absolu du fichier via la méthode getRealPath(String"); 
		System.out.println(context.getRealPath(RELATIVE_PATH_FILE)); 
  
		String path  = context.getRealPath("files/test.properties");		 
  
		if (path != null){ 
			in = new FileInputStream(path); 
		} 
  
		Properties prop = new Properties(); 
		prop.load(in); 
		String result = prop.getProperty(KEY); 
  
		arg1.setContentType("text/html"); 
		Writer writer = arg1.getWriter(); 
		writer.write("Résultat : " + result); 
		writer.flush(); 
	} 
}
Remarque : le chemin relatif déterminé par la variable RELATIVE_PATH_FILE doit être relatif à la racine de l'application web.

Le résultat à l'affichage sera :

Code : Sélectionner tout
Résultat : hello World
La méthode getResourcePaths() permet de lister tous les fichiers contenus dans l'application web.

Mis à jour le 22 décembre 2009 fabszn

Certains types MIME (Content-Type) ne sont pas reconnus par tous les navigateurs, il est possible de passer par un type MIME standard que tout navigateur comprend :

Code java : Sélectionner tout
1
2
response.setContentType ("application/octet-stream"); 
response.setHeader ("Content-Disposition", "attachment; filename=nom_du_fichier");
Le navigateur va donc lancer le téléchargement du fichier.

Mis à jour le 22 décembre 2009 Jack Huser

Il faut utiliser la classe JspFactory et sa méthode getPageContext() pour créer une nouvelle instance de PageContext. Mais attention, car tous les PageContext créés de la sorte doivent être libérés par la méthode releasePageContext() :

Voici la structure à utiliser pour utiliser PageContext :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
	JspFactory jspFactoty = JspFactory.getDefaultFactory(); 
  
	PageContext pageContext = jspFactoty.getPageContext( 
			this,		// La Servlet 
			request,	// Le request courant 
			response,	// La réponse courante 
			null,		// La page de redirection d'erreur (null si aucune) 
			true,		// Utilise la session 
			PageContext.NO_BUFFER,	// Pas de buffer 
			false );	// pas d'autoflush 
	try { 
  
		// Utilisation du PageContext 
  
	} finally { 
		// Libération du PageContext 
		jspFactoty.releasePageContext(pageContext); 
	}

Mis à jour le 22 décembre 2009 adiGuba

Le pattern transfer Object précédemment appelé Value Object est une classe implémentant l'interface Serializable.
Ce pattern est essentiellement utilisé pour échanger des données entre une application cliente et des EJB de type Entity (EntityBean).

Pourquoi me direz-vous ?

Tout simplement parce que, comme vous le savez, les EntityBean comme tous les EJB sont des objets distants, ce qui induit, pour chaque accès à celui-ci, un aller-retour à travers le réseau, avec en plus démarrage/validation de transactions.
Par exemple, pour lire un objet Personne avec cinq attributs, il vous faudra six allers-retours pour récupérer vos informations (1 findByPrimaryKey + 5 lectures d'attribut).

C'est pour cette raison que les Transfer Object sont là.
Les EntityBean ne sont là que pour être utilisés sur le serveur EJB (dans les EJB 2.0, ils sont maintenant « local », ils ne peuvent pas être accessibles de l'extérieur). L'idée est de fournir un service avec des EJB stateless qui vont vous fournir les services qui vous intéressent (lecture/création/modification/suppression... d'un objet). Cet EJB utilise des Entity en interne pour faire les opérations, et créer des classes de transport (avec uniquement les attributs + get/set), cette classe doit implémenter Serializable pour pouvoir passer sur RMI/IIOP. C'est cette classe que l'on appelle Transfer Object.

L'avantage de ce modèle, c'est d'avoir une programmation distante (N tiers) avec le transit de véritables objets que vous allez pouvoir manipuler, puis renvoyer au serveur pour modification...

Voici un petit exemple qui vient étayer la partie théorique.

Entity Bean

L'interface Local

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.societe.monserveur; 
  
import javax.ejb.EJBLocalObject; 
  
/**  
 * Classe d'accès à une entité.  
 * L'accès est local, cette classe n'est pas accessible depuis l'extérieur.  
 */  
public interface PersonneEJBCMP extends EJBLocalObject {  
	public java.lang.Integer getCodePersonne(); 
  
	public java.lang.String getNom(); 
  
	public void setNom(java.lang.String nom);  
}
L'interface Home

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.societe.monserveur; 
  
import javax.ejb.CreateException;  
import javax.ejb.EJBLocalHome;  
import javax.ejb.FinderException; 
  
/**  
 * Home (Factory) de l' Entité CMP  
 */  
public interface PersonneEJBCMPHome extends EJBLocalHome { 
	public PersonneEJBCMP create(java.lang.Integer codePersonne) throws CreateException; 
  
	public PersonneEJBCMP create(java.lang.Integer codePersonne, java.lang.String nom) throws CreateException; 
  
	public PersonneEJBCMP findByPrimaryKey(java.lang.Integer codePersonne) throws FinderException;  
}
Le Bean

Code java : Sélectionner tout
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
package com.societe.monserveur; 
  
import javax.ejb.CreateException; 
import javax.ejb.EntityBean; 
import javax.ejb.EntityContext;  
import javax.ejb.RemoveException; 
  
/**  
 * Implémentation de l'entité CMP  
 */  
public abstract class PersonneEJBCMPBean implements EntityBean { 
  
	EntityContext entityContext;  
	public abstract java.lang.Integer getCodePersonne(); 
  
	public abstract void setCodePersonne(java.lang.Integer codePersonne); 
  
	public abstract java.lang.String getNom(); 
  
	public abstract void setNom(java.lang.String nom); 
  
	public java.lang.Integer ejbCreate(java.lang.Integer codePersonne) throws CreateException { 
		setCodePersonne(codePersonne);  
		return null;  
	} 
  
	public java.lang.Integer ejbCreate(java.lang.Integer codePersonne, java.lang.String nom) throws CreateException { 
  
		setCodePersonne(codePersonne); 
		setNom(nom);  
		return null;  
	} 
  
	public void ejbPostCreate(java.lang.Integer codePersonne) throws CreateException { } 
  
	public void ejbPostCreate(java.lang.Integer codePersonne, java.lang.String nom,  
			java.lang.String prenom, java.lang.Integer age, java.lang.Integer codeEntreprise)  
			throws CreateException { } 
  
	public void ejbLoad() { } 
  
	public void ejbStore() { } 
  
	public void ejbRemove() throws RemoveException { } 
  
	public void ejbActivate() { } 
  
	public void ejbPassivate() { } 
  
	public void setEntityContext(EntityContext entityContext) { 
  
		this.entityContext = entityContext; 
	} 
  
	public void unsetEntityContext() { 
  
		this.entityContext = null;  
	} 
}
Le SessionBean

L'interface Home

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
package com.societe.monserveur; 
  
import java.rmi.RemoteException;  
import javax.ejb.CreateException; 
import javax.ejb.EJBHome; 
  
public interface PersonneEJBFacadeHome extends EJBHome {  
  
	public PersonneEJBFacade create() throws RemoteException, CreateException;  
}
L'interface Remote

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.societe.monserveur; 
  
import java.rmi.RemoteException;  
import javax.ejb.EJBObject; 
  
public interface PersonneEJBFacade extends EJBObject { 
  
	public void insert(Personne obj) throws RemoteException; 
  
	public void update(Personne obj) throws RemoteException; 
  
	public void delete(Personne obj) throws RemoteException; 
  
	public Personne findObject(Integer codePersonne) throws RemoteException;  
}
Le Bean

Code java : Sélectionner tout
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
package com.societe.monserveur; 
  
import javax.ejb.EJBException;  
import javax.ejb.SessionBean;  
import javax.ejb.SessionContext;  
import javax.naming.Context;  
import javax.naming.InitialContext;  
import javax.naming.NamingException; 
  
public class PersonneEJBFacadeBean implements SessionBean {  
  
	private SessionContext sessionContext; 
  
	public void ejbCreate() { } 
  
	public void ejbRemove() { } 
  
	public void ejbActivate() { } 
  
	public void ejbPassivate() { } 
  
	public void setSessionContext(SessionContext sessionContext) {  
		this.sessionContext = sessionContext;  
	} 
  
	public void insert(Personne obj) {  
		try { 
			getCMPHome().create(obj.getCodePersonne(), obj.getNom());  
		} catch (Exception ex) {  
			throw new EJBException(ex);  
		}  
	} 
  
	public void update(Personne obj) {  
		try { 
			PersonneEJBCMP personneEJBCMP = getCMPHome().findByPrimaryKey(obj.getCodePersonne()); 
			personneEJBCMP.setNom(obj.getNom());  
		} catch (Exception ex) {  
			throw new EJBException(ex);  
		}  
	} 
  
	public void delete(Personne obj) {  
		try {  
			getCMPHome().remove(obj.getCodePersonne());  
		} catch (Exception ex) {  
			throw new EJBException(ex);  
		} 
	} 
  
	public Personne findObject(Integer codePersonne) { 
		try {  
			PersonneEJBCMP personneEJBCMP = getCMPHome().findByPrimaryKey( codePersonne); 
			Personne obj = new Personne(personneEJBCMP.getCodePersonne(), personneEJBCMP.getNom()); 
			return obj;  
		} catch (Exception ex) {  
			throw new EJBException(ex);  
		}  
	} 
  
	public static PersonneEJBCMPHome getCMPHome() throws NamingException {  
		Context ctx = new InitialContext();  
		PersonneEJBCMPHome personneEJBCMPHome =  
			(PersonneEJBCMPHome) ctx.lookup("com/societe/monserveur/PersonneEJBCMP");  
		return personneEJBCMPHome;  
	} 
}
Le Transfer Object

Code java : Sélectionner tout
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
package com.societe.monserveur; 
  
import javax.naming.Context;  
import javax.naming.InitialContext;  
import javax.rmi.PortableRemoteObject; 
  
/**  
 * Value Object Personne  
 */  
public class Personne implements java.io.Serializable { 
  
	private Integer codePersonne;  
	private String nom; 
  
	/** Constructeur sans argument */  
	public Personne() { 
		super();  
	} 
  
	/**  
	 * Constructeur avec arguments  
	 */  
	public Personne(Integer codePersonne, String nom) { 
		this.codePersonne = codePersonne; 
		this.nom = nom;  
	} 
  
	/**  
	 * Rechercher un objet à partir de son identifiant  
	 * @return L'objet trouvé  
	 */  
	public static Personne findObject(Integer codePersonne) throws Exception {  
		return getFacade().findObject(codePersonne);  
	} 
  
	/** Insertion de l'objet dans la base */  
	public void insert() throws Exception { 
		getFacade().insert(this);  
	} 
  
	/** Modification de l'objet dans la base */  
	public void update() throws Exception { 
		getFacade().update(this);  
	} 
  
	/** Suppression de l'objet dans la base */  
	public void delete() throws Exception { 
		getFacade().delete(this);  
	} 
  
	/**  
	 * Getter / Setter  
	 */  
	public Integer getCodePersonne() {  
		return codePersonne;  
	} 
  
	public void setCodePersonne(Integer codePersonne) throws Exception {  
		this.codePersonne = codePersonne; 
	} 
  
	public String getNom() { return nom; } 
  
	public void setNom(String nom) throws Exception { 
		this.nom = nom;  
	} 
  
	/**  
	 * Récupération de l'EJB façade  
	 * @return la façade  
	 */  
	private static PersonneEJBFacade getFacade() throws Exception {  
		Context ctx = new InitialContext();  
		Object ref = ctx.lookup("com/societe/monserveur/PersonneEJBFacade"); 
		PersonneEJBFacadeHome personneEJBFacadeHome =  
			(PersonneEJBFacadeHome) PortableRemoteObject.narrow(ref, PersonneEJBFacadeHome.class);  
		return personneEJBFacadeHome.create();  
	} 
}
Et enfin, le Client

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.societe.monclient; 
  
import com.societe.monserveur.Personne; 
  
public class Test { 
  
	public static void main(String[] args) throws Exception { 
  
		//Création de toto  
		Personne toto = new Personne(new Integer(1), "Toto"); 
		toto.insert(); 
  
		//Modification de toto  
		toto.setNom("Titi"); 
		toto.update(); 
  
		//Suppression de toto  
		toto.delete(); 
  
		//Récupération d'une autre personne  
		Personne autre = Personne.findObject(new Integer(99));  
	}  
}
L'avantage avec cette solution (EJB + VO) c'est que l'accès et les règles de gestion sont centralisés sur un seul serveur. Si une autre application (back office) ou un autre serveur web, veulent accéder à la même information, ils pourront réutiliser tout cela.

Mis à jour le 20 février 2005 request

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2016 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsables bénévoles de la rubrique Java Web : Mickael Baron - Robin56 -