My 02 Servlets 2

Comment développer
des Servlets
Préparé par Hassouni Larbi

• Pour créer une servlet, vous devez procéder
en deux étapes:
1. Ecrire le code de la classe pour la servlet
2. Mapper la classe de la servlet à une URL
Larbi Hassouni Servlets 2

• La méthode qui mappe une servlet à une URL
dépend de la spécification des servlets
• Avec une spécifitaion antérieure à servlet 3.0
(Tomcat 7.0) vous devez utiliser le fichier de
configuration web.xml pour mapper la servlet à
une URL
• Avec une spécifitaion servlet 3.0 et postérieure
(Tomcat 8.0) vous pouvez utiliser l'annotation
@WebServlet pour mapper la servlet à une ou
plusieurs URLs. L'utilisation du fichier web.xml
reste toujours possible.

Object
ServletRequest ServletResponse
GenericServlet
{abstract}
+ init () : void HttpServletRequest HttpServletResponse

+ destroy () : void
+ getServletInfo () : String
HttpServlet
{abstract}
# doGet (HttpServletRequest req, HttpServletResponse resp) : void

# doPost (HttpServletRequest req, HttpServletResponse res) : void
# doPut (HttpServletRequest req, HttpServletResponse resp) : void
# doDelete (HttpServletRequest req, HttpServletResponse resp) : void
Doit définir au moins une des méthodes :

VotreServlet init, destroy, getServletInfo, doGet, doPost, doPut, doDelete

package mypack01;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(name = "TestServlet", urlPatterns =
{"/TestServlet"})
public class TestServlet extends HttpServlet {
protected void processRequest(HttpServletRequest request,

HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
out.println("<!DOCTYPE html>");
out.println("<html>");
out.println("<head>");
out.println("<title>Ma première Servlet</title>");
out.println("</head>");

out.println("<body>");
out.println("<h1>Bienvenue dans ma première Servlet" +
request.getContextPath() + "</h1>");
out.println("</body>");
out.println("</html>"); }
finally{ out.close();} }
@Override
protected void doGet(HttpServletRequest request,
processRequest(request, response); }
@Override
protected void doPost(HttpServletRequest request,
processRequest(request, response);
Larbi Hassouni Servlets
}} 7
• Les méthodes doGet et doPost reçoivent un
argument objet request de type
HttpServletRequest.
• L'interface HttpServletRequest hérite de
l'interface ServletRequest.
• L'objet request peut exécuter toutes les
méthodes des deux interfaces

• Pour obtenir la valeur d'un paramètre d'une
requête, on peut utiliser l'une des trois
méthodes :
✓String getParameter(String name)
✓String[] getParameterValues(String name)
✓Map<String,String[]> getParameterMap()
• Pour obtenir la liste des noms des paramètres
on peut utiliser la méthode:
✓Enumeration<String> getParameterNames()

• Cette méthode retourne la valeur du paramètre
spécifié s'il existe, null s'il n'existe pas.
• Cette méthode doit être utilisée avec un
paramètre qui a une seule valeur comme:
✓ Zone de texte
✓ Bouton radio
✓ Case à cocher
✓ Zone de liste modifiable
• Dans le cas d'un paramètre à plusieurs valeurs
comme "liste à sélection multiple", la valeur
retournée est la première valeur.

• Retourne un tableau d'objets String qui
contient toutes les valeurs que le paramètre
contient, ou null si le paramètre n'existe pas.
• Si le paramètre a une seule valeur, le tableau a
une longueur de 1.

• Retourne un java.util.Map qui contient les
noms des parametres comme clés, et les
valeurs des paramètres comme valeurs du
Map.
• Les clés sont des objets String et les valeurs
sont des tableaux d'objets String.

• Retourne une énumération d'objets String qui contient les
noms des paramètres contenues dans la requête.
• Si la requête n'a pas de paramètres, la méthode retourne une
énumération vide.
• Enumeration est une interface qui contient les deux méthodes
ci-dessous:
Modifier and Type Method and Description
hasMoreElements() Teste si l'énumération
boolean
contient encore des éléments.
nextElement() Retourne l'élément suivant
de l'énumération dans le cas où l'objet
E
énumération possède encore au moins un
autre élément.
• Manipuler les données d'un formulaire d'une page
HTML est une tâche très courante en developpement
web.
• Le scénario typique est :
L'utilisateur remplit les champs du formulaire par des
données, puis les soumets au serveur pour les traiter.
• Le traitement est généralement réalisé sur le serveur à

l'aide d'une servlet.
• Le schéma suivant montre ce workflow en utilisant une
servelt du côté du serveur.

package mypack01;
@WebServlet(name = "MyFormServlet01", urlPatterns = {"/MyFormServlet01"})

public class MyFormServlet01 extends HttpServlet {
protected void processRequest(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");

<html>
<head>
<title>Traitement d'un formulaire par une Servlet</title>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
</head>
<body>
<form name="loginForm" method="post" action="MyFormServlet01">
<fieldset>
<legend> Handling Text Boxes</legend>
Username: <input type="text" name="username"/> <br/>
Password: <input type="password" name="password"/> <br/>
</fieldset>

Formulaire:
<fieldset>
<legend> Handling Text Boxes</legend>
Username: <input type="text" name="username"/> <br/>
Password: <input type="password" name="password"/> <br/>
</fieldset>
Servlet
String username = request.getParameter("username");
String password = request.getParameter("password");
out.println("username: " + username + "<br />");
out.println("password: " + password + "<br />");
Formulaire:
<fieldset>
<legend>Handling CheckBoxes</legend>
Speaking language:<br/>
<input type="checkbox" name="language" value="english" />English<br/>
<input type="checkbox" name="language" value="french" />French<br/>
</fieldset>
Servlet
// Handling CheckBoxes
String[] languages = request.getParameterValues("language");
if (languages != null) {
out.println("Languages are: <br />");
for (String lang : languages) {
out.println(lang + "<br />");
}
}
• Pour une case à cocher qui a l'attribut value, la
méthode getParameter obtient la valeur de cet
attribut si la case à cocher est sélectionnée, et
null dans le cas contraire
• Pour une case à cocher qui n'a pas l'attribut
value, la méthode getParameter obtient la valeur
"on" si la case à cocher est sélectionnée, et null
dans le cas contraire
• Par conséquent, vous pouvez déterminer si un
utilisateur a sélectionné une case à cocher en
testant si sa valeur n'est pas null.

Formulaire:
<fieldset>
<legend>Handling Radio button</legend>
Gender:<br />
<input type="radio" name="gender" value="male" />Male<br />
<input type="radio" name="gender" value="female" />Female<br />
</fieldset>
Servlet
// Handling RadioButtons
String gender = request.getParameter("gender");
out.println("Gender is: " + gender+"<br/>");
Formulaire:
<fieldset>
<legend>Handling Text area</legend>
Feedback:<br/>
<textarea rows="5" cols="30"name="feedback">
</textarea>
</fieldset>
Servlet
// Handling Textarea
String feedback = request.getParameter("feedback");
out.println("Feed back is: <br/>" + feedback +"<br/>");
Formulaire:
<fieldset>
<legend>Handling Combo Boxes</legend>
Job Category:
<select name="jobCat">
<option value="tech">Technology</option>
<option value="admin">Administration</option>
<option value="biology">Biology</option>
<option value="science">Science</option>
</select>
</fieldset>
Servlet
// Handling ComboBox
String jobCategory = request.getParameter("jobCat");
out.println("Job category is:
Larbi Hassouni
" + jobCategory +"<br />");
Servlets 23
Formulaire:
<fieldset>
<legend>Handling List Boxes with multiple value</legend>
Visited cities:
<select name="city" multiple>
<option value="Tanger">Tanger</option>
<option value="Fes">Fes</option>
<option value="Rabat">Rabat</option>
</select>
</fieldset>
Servlet
// Handling ListBox with multiple values
String[] vcities = request.getParameterValues("city");
if (vcities != null) {
out.println("visited cities are: <br />");
for (String cit : vcities) {
out.println(cit + "<br />");
}
Larbi Hassouni } Servlets 24
• Lorsque vous travaillez avec une servlet vous
utilisez typiquement des chemins relatifs pour
spécifier des fichiers faisant partie de
l'application.
• Cependant des fois, vous avez besoin d'utiliser
le chemin absolu de l'un de ces fichiers.

• Pour obtenir le chemin absolu d'un fichier procéder comme
suit:
1. Exécuter la méthode getServletContext() avec l'objet courant
pour obtenir un objet ServletContext.
2. Exécuter la méthode getRealPath(String relativepath) avec
l'objet ServletContext.
• Exemple:
ServletContext sc = this.getServletContext();
String absolutePath1 = sc.getRealPath("/EmailList.txt");
String absolutePath2 = sc.getRealPath("/WEB-INF/Stock.txt")
• Le slash (/) au début d'un fichier indique la racine de
l'application Web courante.
• getServletContext() est héritée de GenericServlet

@WebServlet(name = "helloServlet", value = "/hello-servlet")
public class HelloServlet extends HttpServlet {
private String message;
public void init() { message = "Hello World!"; }
public void doGet(HttpServletRequest request,

HttpServletResponse response) throws IOException {
response.setContentType("text/html");
out.println("<html><body>");
out.println("<h1>" + message + "</h1>");
ServletContext sc = this.getServletContext();
String absolutePath1 = sc.getRealPath("/EmailList.txt");
String absolutePath2 = sc.getRealPath("/WEB-INF/Stock.txt");
out.println("<h2>" + absolutePath1 + "</h2>");
out.println("<h2>" + absolutePath2 + "</h2>");
out.println("</body></html>");
}
}
HttpServletResponse response) throws ServletException, IOException
{
// TODO Auto-generated method stub
response.setContentType("text/html; charset=UTF-8");
out.print("<!DOCTYPE html>");
out.print("<html>");
out.print("<head><title>Chemin absolu d'un
fichier</title></head>");
out.print("<body>");
out.print("<h2>Chemin absolu d'un fichier</h2>");
out.print("<p>");
ServletContext src = request.getServletContext();
String cheminabsolu = src.getRealPath("/myform01.html");
out.print(cheminabsolu);
out.print("</p>");
out.print("</body>");
out.print("</html>");
}

• Pour stocker un objet dans l'objet
request(HttpServletRequest), on peut utiliser la méthode
setAttribute de l'objet request:
void setAttribute(String name, object o);
• Pour retrouver un objet stocké dans l'objet request, on
peut utiliser la méthode getAttribute de l'objet request.
Object getAttribute(String name);
• Les attributs stockés dans un objet request ne sont effectifs
que pour une requête, ils sont effacés entre les requêtes.
• Par conséquent, si on stocke un objet User dans l'objet
request, puis on forward l'objet request à un fichier JSP, cet
attribut User n'est disponible que pour ce fichier JSP, et
n'est plus disponible pour la suite de la session.

schéma

• Placer un attribut dans l'objet request
1. User user = new User(firstname, lastName, email);
2. request.setAttribute("user", user);
• Obtenir un attribut à partir de l'objet request
1.User user = (User)request.getAttribute("user");
• Placer un attribut de type primitif
1. int id = 1;
2. request.setAttribute("id", new Integer(id));
• Obtenir un attribut de type primitif à partir de
l'objet request
1. int id = (Integer)request.getAttribute("id");

• Pour transférer un objet request à partir d'une servlet vers un
fichier HTML, JSP, ou une autre servelt, il faut procéder comme
suit:
1. Créer un objet ServletContext en exécutant la méthode
à partir de la classe HttpServlet
en cours;
2. Créer un objet RequestDispacher en exécutant la méthode
avec l'objet
ServletContext créé précédemment. Si vous commencez l'URL par
un slash(/) , l'URL est considéré comme un path relatif au répertoire
racine de l'application web;
3. Exécuter la méthode
avec l'objet RequestDispatcher créé
précedemment pour transférer les objets request et response au
fichier HTML, JSP ou servlet dont l'URL a été fournie à la méthode
getRequestDispacher;

How to get the object of RequestDispatcher
The getRequestDispatcher() method of ServletRequest interface
returns the object of RequestDispatcher.
Syntax of getRequestDispatcher method
public RequestDispatcher getRequestDispatcher(String resource);
Example of using getRequestDispatcher method

RequestDispatcher rd=request.getRequestDispatcher("servlet2");
//servlet2 is the url-pattern of the second servlet
rd.forward(request, response);
//method may be include or forward

Methodes de l'interface RequestDispatcher
The RequestDispatcher interface provides two methods. They are:

1. public void forward(ServletRequest
request,ServletResponse response)throws
ServletException,java.io.IOException: Forwards a request
from a servlet to another resource (servlet, JSP file, or HTML file)
on the server.
2. public void include(ServletRequest
request,ServletResponse response)throws
ServletException,java.io.IOException: Includes the content of
a resource (servlet, JSP page, or HTML file) in the response.

As you see in the above figure, response of second servlet is sent
to the client. Response of the first servlet is not displayed to the
user.
As you can see in the above figure, response of second servlet is
included in the response of the first servlet that is being sent to the
client.

• Transférer les objets request et response à une page
HTML
1. String url = "/index.html";
2. ServletContext sc = getServletContext();
3. RequestDispatcher rd = sc.getRequestDispatcher(url);
4. Rd.forward(request, response);
• Ou en faisant le chaînage des appels des
méthodes
1. String url = "/index.html"
2. getServletContext().getRequestDispatcher(url).forward(
request, response);

• Transférer les objets request et response à un fichier JSP
en faisant le chaînage des appels des méthodes
1. String url = "/myJSPFile.jsp"
request, response);
• Transférer les objets request et response à une servlet
1. String url = "/myServlet"
request, response);

Example of RequestDispatcher interface
In this example, we are validating the password entered by the user. If

password is servlet, it will forward the request to the WelcomeServlet,
otherwise will show an error message: sorry username or password error!. In
this program, we are cheking for hardcoded information. But you can check it
to the database also that we will see in the development chapter. In this
example, we have created following files:
• index.html file: for getting input from the user.
• Login.java file: a servlet class for processing the response. If password is
servet, it will forward the request to the welcome servlet.
• WelcomeServlet.java file: a servlet class for displaying the welcome
message.
• web.xml file: a deployment descriptor file that contains the information
about the servlet.

Index.html
<form action="servlet1" method="post">
<table>
<tr>
<td>Name:</td><td><input type="text" name="userName"/></td>
</tr>
<tr>
<td>Password:</td><td><input type="password" name="userPass"/></td>
</tr>
</table>
<input type="submit" value="login"/>
</form>

Login.java
package mypkg;
……………………………………..
public class Login extends HttpServlet {
private static final long serialVersionUID = 1L;
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException {
String n=request.getParameter("userName");
String p=request.getParameter("userPass");
if(p.equals("servlet")){
RequestDispatcher rd=request.getRequestDispatcher("servlet2");
rd.forward(request, response);
}
else{
out.print("Sorry UserName or Password Error!");
RequestDispatcher rd=request.getRequestDispatcher("/index.html");
rd.include(request, response);
} }}
WelcomeServlet.java
package mypkg;
…………………………………………………………………….
public class WelcomeServlet extends HttpServlet {


HttpServletResponse response) throws ServletException,
IOException {
String n=request.getParameter("userName");
out.print("Welcome "+n);
}}

Web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi= ……………..>
<display-name>requestdispatcher</display-name>
<servlet>
<servlet-name>Login</servlet-name>
<servlet-class>mypkg.Login</servlet-class>
</servlet>
<servlet>
<servlet-name>WelcomeServlet</servlet-name>
<servlet-class>mypkg.WelcomeServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Login</servlet-name>
<url-pattern>/servlet1</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>WelcomeServlet</servlet-name>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>

• La technique de rediriger une réponse est souvent utilisée
lorsqu'on veut passer le contrôle à l'extérieur de l'application.
• Cette technique utilise la méthode
de l'objet HttpServeletResponse.
• L' est souvent un path absolu.
• L'url peut être un path relatif qui est traduit automatiquement
en un path absolu par le moteur de servlet.
– Si l'url ne commence pas par un slash, elle est relative au répertoire
courant.
– Si elle commence par slash, elle est relative au répertoire racine du
conteneur de servlet.

• Lorsqu'on utilise sendRedirect, le serveur envoie une URL
absolue au browser, qui à son tour envoie une requête à
cette URL.
• Puisque ce traitement s'effectue du côté client et non du
côté serveur, ce mode de renvoi est moins efficace que la
méthode présentée précédemment.
En plus, sendRedirect ne transfère pas les objets request et
response;
• En conséquence, sendRedirect ne doit être utilisée que
pour faire un renvoi à une URL qui n'est disponible qu'à
partir d'une autre application.

• Rediriger une réponse à une url relative par rapport
au répertoire courant
• Rediriger une réponse à une url relative au

conteneur de servlet
• Rediriger une réponse à une url sur un autre

serveur web

Full example of sendRedirect method in servlet
In this example, we are redirecting the

request to the google server. Notice that
sendRedirect method works at client side,
that is why we can our request to
anywhere. We can send our request
within and outside the server.

Index.html
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
<form action="MySearcher">
<input type="text" name="name">
<input type="submit" value="Google Search">
</form>
</body>
</html>

MySearcher.java
package mypkg;
public class MySearcher extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException {
// TODO Auto-generated method stub
String name=request.getParameter("name");
response.sendRedirect("https://www.google.co.in/#q="+name);
}
}

• Lorsqu'un utilisateur introduit des données
dans une application, celle-ci doit souvent les
contrôler pour s'assurer qu'elles sont valides:
ce contrôle est reconnu sous le nom de
.
• Si les données introduites ne sont pas valides,
l'application peut envoyer un message
d'erreur et donner à l'utilisateur une autre
chance pour saisir les données.

• Dans une application Web typique, les
données introduites par l'utilisateur sont
validées par JavaScript dans le browser.
• De cette façon, les données erronées sont
attrapées avant qu'elles ne soient envoyées au
serveur pour traitement.
• Ceci rend l'application plus "sensible" à
l'utilisateur et réduit les téléchargements au
serveur.
• Que les données soient validées sur le client
ou non, elles sont toujours validées sur le
serveur.
• Une raison à cela est que JavaScript ne permet
pas d'effectuer toutes les validations requises.
• Par exemple, tester si le login d'un utilisateur
est déjà stocké dans la base de données ne
peut être effectué que sur le serveur.
• Une autre raison est que JavaScript peut être
désactivé dans le browser de l'utilisateur
Exemple d'application
de
validation des données

CREATE DATABASE mohadb;
USE mohadb;
CREATE TABLE User (

UserID INT NOT NULL AUTO_INCREMENT,
email VARCHAR(50),
prenom VARCHAR(50),
nom VARCHAR(50),
PRIMARY KEY(UserID)
);
INSERT INTO User (email, prenom nom)VALUES

('moha@gmail.com', 'Najib', 'Moha'),
('manolo@hotmail.com', 'Brahim', 'Manolo'),
('toto@yahoo.com', 'Ali', 'Toto');

package data;
import java.sql.*;
public class DBUtil {
public static Connection dbConnect(String dbName, String dbUserName, String
dbUserPassword){
Connection con = null;
try{
StringBuilder dbURL1 = new StringBuilder("jdbc:mysql://localhost:3306/");
dbURL1.append(dbName);
String dbURL = dbURL1.toString();
System.out.println(dbURL);
Class.forName("com.mysql.jdbc.Driver");
con = DriverManager.getConnection(dbURL, dbUserName, dbUserPassword);
}catch(ClassNotFoundException e){
System.out.println("Driver non trouve : " + e.getMessage());
}
catch(SQLException e){
System.out.println("Connection a la base impossible : " + e.getMessage());
}
return con;
}
public static void closeStatement(Statement s) {
try {
if (s != null) { s.close(); }
} catch (SQLException e) { System.out.println(e); }
}
public static void closePreparedStatement(PreparedStatement ps) {

try { if (ps != null) {
ps.close(); }
}
public static void closeResultSet(ResultSet rs) {

try { if (rs != null) {
rs.close(); }
}}

package business;
import java.io.Serializable;
public class User implements Serializable {

private String email;
private String firstName;
private String lastName;
public User() { email = ""; firstName = ""; lastName = ""; }

public User(String firstName, String lastName, String email) {
this.firstName = firstName; this.lastName = lastName; this.email = email; }
public String getEmail() { return email; }

public void setEmail(String email) { this.email = email; }
public String getFirstName() { return firstName; }

public void setFirstName(String firstName) { this.firstName = firstName; }
public String getLastName() { return lastName; }

public void setLastName(String lastName) { this.lastName = lastName; }
}
package data;
import java.sql.*;
import business.User;
public class DBUser {
public static int insert(User user) {
Connection con = DBUtil.dbConnect("mohadb", "moha", "topsecret");
PreparedStatement ps = null;
String query
= "INSERT INTO User (Email, FirstName, LastName) "
+ "VALUES (?, ?, ?)";
try {
ps = con.prepareStatement(query);
ps.setString(1, user.getEmail());
ps.setString(2, user.getFirstName());
ps.setString(3, user.getLastName());
return ps.executeUpdate();
} catch (SQLException e) { System.out.println(e); return 0;
} finally { DBUtil.closePreparedStatement(ps); }
}
public static int update(User user) {
String query = "UPDATE User SET "

+ "FirstName = ?, "
+ "LastName = ? "
+ "WHERE Email = ?";
try {
ps.setString(1, user.getFirstName());
ps.setString(2, user.getLastName());
} catch (SQLException e) { System.out.println(e); return 0;
} finally { DBUtil.closePreparedStatement(ps);
}
}
public static int delete(User user) {
String query = "DELETE FROM User "

try {
} catch (SQLException e) {
System.out.println(e);
return 0;
} finally {
DBUtil.closePreparedStatement(ps);
}
}

public static boolean emailExists(String email) {
ResultSet rs = null;
String query = "SELECT Email FROM User "

try {
ps.setString(1, email);
rs = ps.executeQuery();
return rs.next();
} catch (SQLException e) {
System.out.println(e);
return false;
} finally {
DBUtil.closeResultSet(rs);
DBUtil.closePreparedStatement(ps);
}
}
+dbUtil sont tres
important
public static User selectUser(String email) {
ResultSet rs = null;
String query = "SELECT * FROM User "
try {
ps.setString(1, email);
rs = ps.executeQuery();
User user = null;
if (rs.next()) {
user = new User();
user.setFirstName(rs.getString("FirstName"));
user.setLastName(rs.getString("LastName"));
user.setEmail(rs.getString("Email"));
}
return user;
} catch (SQLException e) { System.out.println(e); return null;
} finally { DBUtil.closeResultSet(rs); DBUtil.closePreparedStatement(ps);
} }}
<!DOCTYPE html>
<html> <head>
<meta charset="utf-8">
<title>Data Validation on the Server</title>
<link rel="stylesheet" href="css/main.css" type="text/css"/> </head>
<body>
<h1>Join our email list</h1>
<p>To join our email list, enter your name and email address below.</p>
<p><i>${message}</i></p>
<form action="emailList" method="post">
<input type="hidden" name="action" value="add">
<label class="pad_top">Email:</label>
<input type="email" name="email" value="${user.email}" required><br>
<label class="pad_top">First Name:</label>
<input type="text" name="firstName" value="${user.firstName}" required><br>
<label class="pad_top">Last Name:</label>
<input type="text" name="lastName" value="${user.lastName}" required><br>
<label> </label>
<input type="submit" value="Join Now" class="margin_left">
</form> </body> </html>
<!DOCTYPE html>
<html> <head>
<meta charset="utf-8">
<title>Data Validation on the server</title>
<link rel="stylesheet" href="css/main.css" type="text/css"/> </head>
<body>
<h1>Thanks for joining our email list</h1>
<p>Here is the information that you entered:</p>
<label>Email:</label>
<span>${user.email}</span><br>
<label>First Name:</label>
<span>${user.firstName}</span><br>
<label>Last Name:</label>
<span>${user.lastName}</span><br>
<p>To enter another email address, click on the Back button in your browser or the
Return button shown below.</p>
<form action="" method="post">
<input type="hidden" name="action" value="join">
<input type="submit" value="Return">
</form></body></html>
/* The styles for the elements */
body {
font-family: Arial, Helvetica, sans-serif;
font-size: 85%; margin-left: 2em; margin-right: 2em; width: 400px; }
h1 { font-size: 140%; color: teal; margin-bottom: .5em; }
h2 { font-size: 120%; color: teal; margin-bottom: .5em; }
label { float: left; width: 7em; margin-bottom: 0.5em; font-weight: bold; }
input[type="text"], input[type="email"] { /* An attribute selector */

width: 15em; margin-left: 0.5em; margin-bottom: 0.5em; }
span { margin-left: 0.5em; margin-bottom: 0.5em; }
br { clear: both; }
/* The styles for the classes */

.pad_top { padding-top: 0.25em; }
.margin_left { margin-left: 0.5em; }
package email;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import business.User;
import data.DBUser;
public class EmailListServlet extends HttpServlet {

@Override
String url = "/index.html";
// get current action

String action = request.getParameter("action");
if (action == null) {
action = "join"; // default action
}
// perform action and set URL to appropriate page
if (action.equals("join")) {
url = "/index.jsp"; // the "join" page
}
else if (action.equals("add")) {
// get parameters from the request
String firstName = request.getParameter("firstName");
String lastName = request.getParameter("lastName");
String email = request.getParameter("email");
// store data in User object

User user = new User(firstName, lastName, email);

// validate the parameters
String message;
if (UserDB.emailExists(user.getEmail())) {
message = "This email address already exists.<br>" +
"Please enter another email address.";
url = "/index.jsp";
}
else {
message = "";
url = "/thanks.jsp";
UserDB.insert(user);
}
request.setAttribute("user", user);
request.setAttribute("message", message);
}
getServletContext()
.getRequestDispatcher(url)
.forward(request, response);
}
}
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
<servlet>
<servlet-name>EmailListServlet</servlet-name>
<servlet-class>email.EmailListServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>EmailListServlet</servlet-name>
<url-pattern>/emailList</url-pattern>
</servlet-mapping>
<session-config>
<session-timeout>30</session-timeout>
</session-config>
</web-app>

• Il est possible de stocker dans le fichier
web.xml des paramètres d'initialisation pour
une application.
• On distingue deux catégories de paramètres
d'initialisation:
1. Paramètres d'initialisation de contexte;
2. Paramètres d'initialisation d'une servlet;

• Les paramètres d'initialisation de contexte sont disponibles
pour toutes les servlets.
• Pour définir un paramètre d'initialisation de contexte, il
faut utiliser un élément . Suivi par deux
éléments enfants et .
• Pour définir plusieurs paramètres de contexte, il faut
utiliser d'autres éléments juste après le
premier.
• Exemple:

• Les paramètres d'initialisation de servlet sont disponibles
uniquement pour une servlet.
• Pour définir un paramètre d'initialisation de servlet, il faut utiliser
l'élément à l'intérieur de l'élément
• L'élément doit venir après les éléments
et à l'intérieur de l'élément
• Exemple:
<init-param>
<param-name>CheminRelatifFichier</param-name>
<param-value>/WEB-INF/EmailList.txt</param-value>
</init-param>

Elément Description
<context-param> Définit un paramètre pour toutes les servlets d'une
application
<servlet> Identifie une servlet à l'intérieur d'une application
<servlet-name> Définit le nom de la servlet. Ce nom est utilisé dans la suite

du fichier XML et doit être unique
<servlet-class> Identifie la servlet en spécifiant son package et le nom de la
classe
<init-param> Définit une paire name/value pour un paramètre
d'initialisation d'une servlet
<param-name> Définit le nom d'un paramètre
<param-value> Définit la valeur d'un paramètre

• Avec la spécification 3.0 des servlets (Tomcat 7.0) et ultérieur, vous pouvez
utiliser les annotations @WebServlet et @InitParam pour spécifier les
paramètres d'initialisation d'une servlet.
• Exemple:
init-params={@InitParam(name="CheminRelatifFichier",
value="/WEB-INF/EmailList.txt")
}
)
• Il faut répéter l'annotation @InitParam pour chaque paire name/value.

• Pour retrouver les paramètres d'initialisation, il faut utiliser la méthode
de l'objet pour un paramètre de contexte et
celle de l'objet pour un paramètre de la servlet.
• Pour obtenir les objets et d'une servlet, il faut
utiliser les deux méthodes de la classe présentées ci-dessous.
Méthode Description
Returns a reference to the
ServletContext in which this servlet is
public ServletContext getServletContext()
running and which contains information
about the entire web application context
Returns a ServletConfig object that
public ServletConfig getServletConfig() contains information about a single servlet's
configuration.

• ServletContext et ServletConfig sont tous les deux des interfaces qui
contiennent les méthodes ci-dessous.
Méthode Description
Returns a String containing the value of the named

String getInitParameter (context-wide with ServletContext or Servlet-wide with the
(String name) ServletConfig object) initialization parameter, or null if the
parameter does not exist.
Returns the names of the (context's with ServletContext

object or servlet's with ServletConfig) initialization
Enumeration<String>
parameters as an Enumeration of String objects, or an
getInitParameterNames()
empty Enumeration if the context/servlet has no
initialization parameters.
Sets the context initialization parameter with the given

boolean setInitParameter
name and value on this ServletContext
(String name, String value)
L'objet ServletConfig ne possède pas cette méthode.

Exemple d'application utilisant
les paramètres d'initialisation de contexte

Fichier : web.xml
<web-app version="3.1" xmlns=……. xmlns:xsi=…… xsi:….>
<context-param>
<param-name>databaseURL</param-name>
<param-value>jdbc:mysql://localhost:3306/ELibrairie</param-value>
</context-param>
<context-param>
<param-name>username</param-name>
<param-value>moha</param-value>
</context-param>
<context-param>
<param-name>password</param-name>
<param-value>topsecret</param-value>
</context-param>

<servlet>
<servlet-name>EntryServlet</servlet-name>
<servlet-class>mypkg.EntryServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>EntryServlet</servlet-name>
<url-pattern>/start</url-pattern>
</servlet-mapping>
</web-app>

Package pkg;
Import ……….
…………………..
public class EntryServlet extends HttpServlet {
private String dbURL, userName, userPassword;

@Override
public void init(ServletConfig config) throws ServletException{
super.init(config);
// Retrouver les paramètres de l'application à partir du fichier web.xml
// Ces paramètres sont databaseURL, username et password
ServletContext sc = config.getServletContext();
dbURL = sc.getInitParameter("databaseURL");
userName = sc.getInitParameter("username");
userPassword=sc.getInitParameter("password");
}
………..
}
Exemple de programme utilisant les
paramètres d'initialisation de servlet

Exemple de programme utilisant les paramètres
d'initialisation de servlet
<web-app version="3.1" xmlns=……. xmlns:xsi=…. xsi:…>
<servlet>
<servlet-name>InternationalizedHelloWorld</servlet-name>
<servlet-class>mypack.InternationalizedHelloWorld</servlet-class>
<init-param>
<param-name>greeting</param-name>
<param-value>AHLAN WA SAHLAN!</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>InternationalizedHelloWorld</servlet-name>
<url-pattern>/InternationalizedHelloWorld</url-pattern>
</servlet-mapping>
</web-app>

package mypack;
public class InternationalizedHelloWorld extends HttpServlet {
@Override
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {
out.println("<html>"); out.println("<head>");
String greeting;
greeting = getServletConfig().getInitParameter("greeting");
out.println("<title>" +greeting+"</title>");
out.println("</head>");
out.println("<body>"); out.println("<h1>" +greeting+"</h1>");
out.println("</body>"); out.println("</html>");
}
}
Retrouver les noms et valeurs de tous
les parametres d'initialization
d'une servlet avec ServletConfig
An other manner
Retrouver les noms et valeurs de tous les
parametres d'initialization d'une servlet avec
ServletConfig
In this example, we are getting all the

initialization parameter from the web.xml
file and printing this information in the
servlet.

web.xml
<web-app xmlns:xsi=…………>
<display-name>initparameters</display-name>
<servlet>
<servlet-name>DemoServlet</servlet-name>
<servlet-class>mypkg.DemoServlet</servlet-class>
<init-param>
<param-value>system</param-value>
</init-param>
<init-param>
<param-value>oracle</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>DemoServlet</servlet-name>
</servlet-mapping>
</web-app>
@WebServlet("/DemoServlet")
public class DemoServlet extends HttpServlet {

HttpServletResponse response) throws ServletException,
IOException {
ServletConfig config=getServletConfig();
Enumeration<String> e=config.getInitParameterNames();
String str="";
while(e.hasMoreElements()){
str=e.nextElement();
out.print("<br>Name: "+str);
out.print(" value: "+config.getInitParameter(str));
}
out.close();
}}
ServletConfig Interface
An object of ServletConfig is created by the web container for

each servlet. This object can be used to get configuration
information from web.xml file.
If the configuration information is modified from the web.xml

file, we don't need to change the servlet. So it is easier to
manage the web application if any specific content is modified
from time to time.

Advantage of ServletConfig
The core advantage of ServletConfig is that you don't need to edit the servlet
file if information is modified from the web.xml file.
Methods of ServletConfig interface

1. public String getInitParameter(String name):Returns the parameter value
for the specified parameter name.
2. public Enumeration getInitParameterNames():Returns an enumeration of
all the initialization parameter names.
3. public String getServletName():Returns the name of the servlet.
4. public ServletContext getServletContext():Returns an object of
ServletContext.

How to get the object of ServletConfig
1. getServletConfig() method of Servlet interface returns the object of
ServletConfig.
Syntax of getServletConfig() method
public ServletConfig getServletConfig();
Example of getServletConfig() method
ServletConfig config=getServletConfig();
//Now we can call the methods of ServletConfig interface

ServletContext Interface
An object of ServletContext is created by the web

container at time of deploying the project. This object
can be used to get configuration information from
web.xml file. There is only one ServletContext object
per web application.
If any information is shared to many servlet, it is better
to provide it from the web.xml file using the <context-
param> element.

Advantage of ServletContext
Easy to maintain if any information is shared to

all the servlet, it is better to make it available for
all the servlet. We provide this information from
the web.xml file, so if the information is changed,
we don't need to modify the servlet. Thus it
removes maintenance problem.

Usage of ServletContext Interface
There can be a lot of usage of ServletContext object. Some of them are as follows:
1. The object of ServletContext provides an interface between the container and
servlet.
2. The ServletContext object can be used to get configuration information from
the web.xml file.
3. The ServletContext object can be used to set, get or remove attribute from the
web.xml file.
4. The ServletContext object can be used to provide inter-application
communication.

Commonly used methods of ServletContext interface
There is given some commonly used methods of ServletContext
interface.
public String getInitParameter(String name):Returns the
parameter value for the specified parameter name.
public Enumeration getInitParameterNames():Returns the
names of the context's initialization parameters as an Enumeration
of String objects.
public void setAttribute(String name,Object object):sets the
given object in the application scope.
public Object getAttribute(String name):Returns the attribute for
the specified name.
public void removeAttribute(String name):Removes the attribute
with the given name from the servlet context.

How to get the object of ServletContext interface
1. getServletContext() method of ServletConfig interface returns

the object of ServletContext.
2. getServletContext() method of GenericServlet class returns
the object of ServletContext.
Syntax of getServletContext() method
public ServletContext getServletContext()
Example of getServletContext() method
//We can get the ServletContext object from ServletConfig object
ServletContext application=getServletConfig().getServletContext();
//Another convenient way to get the ServletContext object

ServletContext application=getServletContext();

Example of ServletContext to get the initialization
parameter
In this example, we are getting the initialization parameter
from the web.xml file and printing the value of the
initialization parameter. Notice that the object of
ServletContext represents the application scope. So if we
change the value of the parameter from the web.xml file, all
the servlet classes will get the changed value. So we don't
need to modify the servlet. So it is better to have the
common information for most of the servlets in the web.xml
file by context-param element. Let's see the simple example:
web.xml
<web-app>
<servlet>
<servlet-name>sonoojaiswal</servlet-name>
<servlet-class>DemoServlet</servlet-class>
<context-param>
<param-name>dname</param-name>
<param-value>sun.jdbc.odbc.JdbcOdbcDriver</param-value>
</context-param>
<servlet-mapping>
<url-pattern>/context</url-pattern>
</servlet-mapping>
</servlet>
</web-app>

DemoServlet.java
import java.io.*;
public class DemoServlet extends HttpServlet{
public void doGet(HttpServletRequest req,HttpServletResponse res)
throws ServletException,IOException
{
res.setContentType("text/html");
PrintWriter pw=res.getWriter();
//creating ServletContext object
ServletContext context=getServletContext();
//Getting the value of the initialization parameter and printing it
String driverName=context.getInitParameter("dname");
pw.println("driver name is="+driverName);
pw.close();
}}

Example of ServletContext to get all the
initialization parameters
In this example, we are getting all the initialization

parameter from the web.xml file. For getting all the
parameters, we have used the
getInitParameterNames() method in the servlet
class.

web.xml
<web-app>
<servlet>
<servlet-class>DemoServlet</servlet-class>
</servlet>
<context-param>
<param-name>dname</param-name>
<param-value>sun.jdbc.odbc.JdbcOdbcDriver</param-value>
</context-param>
<context-param>
<param-value>system</param-value>
</context-param>
<context-param>
<param-value>oracle</param-value>
</context-param>
<servlet-mapping>
<url-pattern>/context</url-pattern>
</servlet-mapping>
</web-app>
DemoServlet.java
import java.io.*;
public class DemoServlet extends HttpServlet{
public void doGet(HttpServletRequest req,HttpServletResponse res)
throws ServletException,IOException
{
res.setContentType("text/html");
PrintWriter out=res.getWriter();
ServletContext context=getServletContext();
Enumeration<String> e=context.getInitParameterNames();
String str="";
while(e.hasMoreElements()){
str=e.nextElement();
out.print("<br> "+context.getInitParameter(str));
}
}}

My 02 Servlets 2

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

My 02 Servlets 2

Transféré par

Droits d'auteur :

Formats disponibles

Comment développer

Préparé par Hassouni Larbi

1. Ecrire le code de la classe pour la servlet

2. Mapper la classe de la servlet à une URL

Larbi Hassouni Servlets 2

Larbi Hassouni Servlets 3

+ init () : void HttpServletRequest HttpServletResponse

# doGet (HttpServletRequest req, HttpServletResponse resp) : void

Doit définir au moins une des méthodes :

Larbi Hassouni Servlets 4

Larbi Hassouni Servlets 5

protected void processRequest(HttpServletRequest request,

Larbi Hassouni Servlets 6

Larbi Hassouni Servlets 8

Larbi Hassouni Servlets 9

Larbi Hassouni Servlets 10

Larbi Hassouni Servlets 11

Larbi Hassouni Servlets 12

• Le traitement est généralement réalisé sur le serveur à

Larbi Hassouni Servlets 14

@WebServlet(name = "MyFormServlet01", urlPatterns = {"/MyFormServlet01"})

Larbi Hassouni Servlets 16

Larbi Hassouni Servlets 17

Larbi Hassouni Servlets 20

Larbi Hassouni Servlets 29

Larbi Hassouni Servlets 30

public void init() { message = "Hello World!"; }

public void doGet(HttpServletRequest request,

Larbi Hassouni Servlets 32

Larbi Hassouni Servlets 33

Larbi Hassouni Servlets 34

Larbi Hassouni Servlets 35

Larbi Hassouni Servlets 36

Example of using getRequestDispatcher method

Larbi Hassouni Servlets 37

The RequestDispatcher interface provides two methods. They are:

Larbi Hassouni Servlets 38

Larbi Hassouni Servlets 40

Larbi Hassouni Servlets 41

Larbi Hassouni Servlets 42

In this example, we are validating the password entered by the user. If

Larbi Hassouni Servlets 43

Larbi Hassouni Servlets 45

public class WelcomeServlet extends HttpServlet {

protected void doPost(HttpServletRequest request,

Larbi Hassouni Servlets 47

Larbi Hassouni Servlets 48

Larbi Hassouni Servlets 49

Larbi Hassouni Servlets 50

• Rediriger une réponse à une url relative au

• Rediriger une réponse à une url sur un autre

Larbi Hassouni Servlets 51

In this example, we are redirecting the

Larbi Hassouni Servlets 52

Larbi Hassouni Servlets 53

public class MySearcher extends HttpServlet {

Larbi Hassouni Servlets 54

Larbi Hassouni Servlets 55

Larbi Hassouni Servlets 58

CREATE TABLE User (

INSERT INTO User (email, prenom nom)VALUES

Larbi Hassouni Servlets 59

public static void closePreparedStatement(PreparedStatement ps) {