Problème avec la création d'une commande en base de données

Je suis le tutoriel Créez votre application web avec Java EE. arrivé au tp 6 du fil rouge, je suis bloqué depuis un bon moment. Quelqu'un pourrait m'aider s'il vous plaît. Merci d'avance.Le même processus marche pour la servlet CreationClient mais bloque pour CreationCommande Voilà mon erreur
Rapport d''exception

message "Servlet.init()" pour la servlet [CreationCommande] a généré une exception

description Le serveur a rencontré une erreur interne qui l''a empêché de satisfaire la requête.

exception

javax.servlet.ServletException: "Servlet.init()" pour la servlet [CreationCommande] a généré une exception
	org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:475)
	org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:80)
	org.apache.catalina.valves.AbstractAccessLogValve.invoke(AbstractAccessLogValve.java:651)
	org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:342)
	org.apache.coyote.http11.Http11Processor.service(Http11Processor.java:498)
	org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:66)
	org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:796)
	org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1374)
	org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:49)
	java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)
	java.lang.Thread.run(Thread.java:748)

cause mère

java.lang.NullPointerException
	com.mauricefilRouge.servlets.CreationCommande.init(CreationCommande.java:43)
	javax.servlet.GenericServlet.init(GenericServlet.java:158)
	org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:475)
	org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:80)
	org.apache.catalina.valves.AbstractAccessLogValve.invoke(AbstractAccessLogValve.java:651)
	org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:342)
	org.apache.coyote.http11.Http11Processor.service(Http11Processor.java:498)
	org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:66)
	org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:796)
	org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1374)
	org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:49)
	java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)
	java.lang.Thread.run(Thread.java:748)

Voici les codes
servlet creationCommande

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
package com.mauricefilRouge.servlets;
 
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
 
import com.mauricefilRouge.beans.Client;
import com.mauricefilRouge.beans.Commande;
import com.mauricefilRouge.dao.ClientDao;
import com.mauricefilRouge.dao.CommandeDao;
import com.mauricefilRouge.dao.DAOFactory;
import com.mauricefilRouge.forms.CreationCommandeForm;
 
/**
 * Servlet implementation class creationCommande
 */
public class CreationCommande extends HttpServlet {
	private static final long serialVersionUID = 1L;
 
	/* Constantes */
	public static final String CONF_DAO_FACTORY ="daoFactory" ;
	public static final String CHEMIN = "chemin";
	public static final String ATT_COMMANDE = "commande";
	public static final String ATT_FORM = "form";
	public static final String SESSION_CLIENTS= "clients";
	public static final String SESSION_COMMANDES= "commandes";
	public static final String APPLICATION_CLIENTS = "initClients";
	public static final String APPLICATION_COMMANDES = "initCommandes";
	public static final String VUE_SUCCES = "/WEB-INF/afficherCommande.jsp";
	public static final String VUE_FORM = "/WEB-INF/creerCommande.jsp";
 
	private ClientDao clientDao;
	private CommandeDao commandeDao;
 
	public void init() throws ServletException{
    	/* Récupération d'une instance de nos DAO Client et Commande */
    	this.clientDao = ((DAOFactory)getServletContext().getAttribute(CONF_DAO_FACTORY)).getClientDao();
    	this.commandeDao = ((DAOFactory)getServletContext().getAttribute(CONF_DAO_FACTORY)).getCommandeDao();
    }
	/**
         * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
         */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 
		/* À la réception d'une requête GET, simple affichage du formulaire */
		this.getServletContext().getRequestDispatcher( VUE_FORM).forward( request, response );
	}
 
	/**
         * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
         */
	@SuppressWarnings("unchecked")
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 
		/* Lecture du paramètre 'chemin' passé à la servlet via la déclaration  dans le web.xml */
		String chemin = this.getServletConfig().getInitParameter(CHEMIN);
		// Préparation de l'objet formulaire
		CreationCommandeForm form = new CreationCommandeForm(clientDao, commandeDao);
 
		//Traitement de la requête et récupération du bean en résultant 
		System.out.println("CommandeDao" + commandeDao);
		Commande commande = form.creerCommande(request, chemin);
 
 
		// Ajout du bean et de l'objet métier à la requete
		request.setAttribute(ATT_FORM, form);
		request.setAttribute(ATT_COMMANDE, commande);
 
		/* Si aucune erreur */
		if ( form.getErreurs().isEmpty() ) {
		/* Alors récupération de la map des clients dans la session */
		HttpSession session = request.getSession();
		Map<Long, Client> clients = (HashMap<Long, Client>) session.getAttribute(SESSION_CLIENTS);
		/* Si aucune map n'existe, alors initialisation d'une nouvelle map */
		if ( clients == null ) {
			clients = new HashMap<Long, Client>();
		}
		/* Puis ajout du client de la commande courante dans la	map */
		clients.put( commande.getClient().getId(), commande.getClient() );
		/* Et enfin (ré)enregistrement de la map en session */
		session.setAttribute( SESSION_CLIENTS, clients );
		/* Ensuite récupération de la map des commandes dans la session */
		Map<Long, Commande> commandes = (HashMap<Long, Commande>) session.getAttribute( SESSION_COMMANDES );
		/* Si aucune map n'existe, alors initialisation d'une nouvelle map */
		if ( commandes == null ) {
			commandes = new HashMap<Long, Commande>();
		}
		/* Puis ajout de la commande courante dans la map */
 
		commandes.put( commande.getId(), commande );
 
		/* Et enfin (ré)enregistrement de la map en session */
 
		session.setAttribute( SESSION_COMMANDES, commandes );
 
		/* Affichage de la fiche récapitulative */
 
		this.getServletContext().getRequestDispatcher(VUE_SUCCES).forward( request, response );
		} else {
 
		/* Sinon, ré-affichage du formulaire de création avec les erreurs */
 
		this.getServletContext().getRequestDispatcher(VUE_FORM).forward( request, response );
		}
 
	}
}

Le code du DAOFactory

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
package com.mauricefilRouge.dao;
 
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
 
import com.jolbox.bonecp.BoneCP;
import com.jolbox.bonecp.BoneCPConfig;
 
public class DAOFactory {
	private static final String FICHIER_PROPERTIES ="/com/mauricefilRouge/dao/dao.properties";
	private static final String PROPERTY_URL = "url";
	private static final String PROPERTY_DRIVER = "driver";
	private static final String PROPERTY_NOM_UTILISATEUR ="nomutilisateur";
	private static final String PROPERTY_MOT_DE_PASSE ="motdepasse";
 
	BoneCP connectionPool = null;
 
 
	public DAOFactory(BoneCP connectionPool) {
		this.connectionPool = connectionPool;
 
	}
 
	/* Méthode chargée de récupérer les informations de connexion à labase de
	* données, charger le driver JDBC et retourner une instance de laFactory */
 
	public static DAOFactory getInstance() throws DAOConfigurationException {
		Properties properties = new Properties();
		String url;
		String driver;
		String nomUtilisateur;
		String motDePasse;
		BoneCP connectionPool = null;
 
		ClassLoader classloader = Thread.currentThread().getContextClassLoader();
		InputStream fichierProperties = classloader.getResourceAsStream(FICHIER_PROPERTIES);
 
		if (fichierProperties == null) {
			throw new DAOException("Le fichier properties "+ FICHIER_PROPERTIES + " est introuvable");
		}
		try {
			properties.load(fichierProperties);
			url = properties.getProperty(PROPERTY_URL);
			driver = properties.getProperty(PROPERTY_DRIVER);
			nomUtilisateur = properties.getProperty(PROPERTY_NOM_UTILISATEUR);
			motDePasse = properties.getProperty(PROPERTY_MOT_DE_PASSE);
		} catch (IOException e) {
			throw new DAOConfigurationException("Impossible de charger le fichier properties "+ FICHIER_PROPERTIES, e);
		}
		try {
			Class.forName(driver);
		} catch (ClassNotFoundException e) {
			throw new DAOConfigurationException("Le driver est introuvable dans le clapath "+ e);
		}
		try {
			/* Création d'une configuration de pool de connexions via l'objet BoneCPConfig et les différents setters associés.*/
			BoneCPConfig config = new BoneCPConfig();
			config.setJdbcUrl(url);
			config.setUsername(nomUtilisateur);
			config.setPassword(motDePasse);
			/* Paramétrage de la taille du pool */
			config.setMinConnectionsPerPartition(5);
			config.setMaxConnectionsPerPartition(10);
			config.setPartitionCount(2);
			/* Création du pool à partir de la configuration, via l'objet BoneCP */
 
			connectionPool = new BoneCP(config);
 
 
		} catch (SQLException e) {
			e.printStackTrace();
			throw new DAOConfigurationException( "Erreur de configuration du pool de connexions.", e );
		}
 
		/* Enregistrement du pool créé dans une variable d'instance via un appel au constructeur de DAOFactory */
		DAOFactory instance = new DAOFactory(connectionPool);
		return instance;
 
		}
 
	/* Méthode chargée de fournir une connexion à la base de données */
	/* package */
	Connection getConnection() throws SQLException{
		return connectionPool.getConnection();
 
	}
	/* Méthodes de récupération de l'implémentation des différents DAO */
	public ClientDao getClientDao() {
		return new ClientDaoImpl( this );
	}
 
	public CommandeDao getCommandeDao() {
		return new CommandeDaoImpl(this);
	}
 
}

Le code de l'implémentation du DaoCommande: CommandeDaoImp

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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
package com.mauricefilRouge.dao;
import static com.mauricefilRouge.dao.DAOUtiitaire.fermeturesSilencieuses;
import static com.mauricefilRouge.dao.DAOUtiitaire.initialisationRequetePreparee;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
 
import org.joda.time.DateTime;
 
import com.mauricefilRouge.beans.Commande;
import com.sun.jmx.snmp.Timestamp;
 
public class CommandeDaoImpl implements CommandeDao {
	private static final String SQL_SELECT = "SELECT id, id_client, date, montant, mode_paiement, statut_paiement, "
			+ "mode_livraison, statut_livraison FROM Commande ORDER BY id";
	private static final String SQL_SELECT_PAR_ID = "SELECT id, id_client, date, "
					+ "montant, mode_paiement, statut_paiement, mode_livraison, statut_livraison FROM Commande WHERE id = ?";
	private static final String SQL_INSERT = "INSERT INTO Commande (id_client, date, montant, "
					+ "mode_paiement, statut_paiement, mode_livraison, statut_livraison) VALUES (?, ?, ?, ?, ?, ?, ?)";
	private static final String SQL_DELETE_PAR_ID = "DELETE FROM Commande WHERE id = ?";
	private DAOFactory daoFactory;
	public CommandeDaoImpl(DAOFactory daoFactory) {
		this.daoFactory = daoFactory;
	}
 
	/* Implémentation de la méthode définie dans l'interface CommandeDao */
@Override
	public void creer(Commande commande) throws DAOException {
		Connection connexion = null;
		PreparedStatement preparedStatement = null;
		ResultSet valeursAutoGenerees = null;
 
		try {
			connexion = daoFactory.getConnection();
			preparedStatement = initialisationRequetePreparee(connexion, SQL_INSERT, true, 
					commande.getClient().getId(), new Timestamp(commande.getDate().getMillis()),
					commande.getMontant(), commande.getModePaiement(), commande.getStatutPaiement(), 
					commande.getModeLivraison(), commande.getStatutLivraison());
			int statut = preparedStatement.executeUpdate();
			if (statut == 0) {
				throw new DAOException("Échec de la création de la commande, aucune ligne ajoutée dans la table");
			}
			valeursAutoGenerees = preparedStatement.getGeneratedKeys();
			if (valeursAutoGenerees.next()) {
				commande.setId(valeursAutoGenerees.getLong(1));
			}else {
				throw new DAOException("Échec de la création de la commande, aucun id auto-généré retourné");
			}
		} catch (SQLException e) {
			throw new DAOException(e);
		}finally {
			fermeturesSilencieuses(valeursAutoGenerees, preparedStatement, null);
		}
 
	}
 
	/* Implémentation de la méthode définie dans l'interface CommandeDao */
	@Override
	public Commande trouver(Long id)throws DAOException {
		return trouver(SQL_SELECT_PAR_ID, id);
	}
 
	private Commande trouver(String sql, Object... objets) {
		Connection connexion = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Commande commande = null;
 
		try {
			/* Récupération d'une connexion depuis la Factory */
			connexion = daoFactory.getConnection();
			/* Préparation de la requête avec les objets passés en arguments (ici, uniquement un id) et exécution. */
			preparedStatement = initialisationRequetePreparee(connexion, sql, false, objets);
			resultSet = preparedStatement.executeQuery();
			/* Parcours de la ligne de données retournée dans le ResultSet */
			if (resultSet.next()) {
				commande = map(resultSet);
			}
		} catch (SQLException e) {
			throw new DAOException(e);
		}finally {
			fermeturesSilencieuses(resultSet, preparedStatement, connexion);
		}
		return commande;
	}
 
	@Override
	public void supprimer(Commande commande) throws DAOException{
		Connection connexion = null;
		PreparedStatement preparedStatement = null;
 
		try {
			connexion = daoFactory.getConnection();
			preparedStatement = initialisationRequetePreparee(connexion, SQL_DELETE_PAR_ID, true, commande.getId());
			int statut = preparedStatement.executeUpdate();
			if (statut == 0) {
				throw new DAOException("Échec de la suppression de la commande, aucune ligne supprimée de la table");
			}else {
				commande.setId(null);
			}
		} catch (SQLException e) {
			throw new DAOException(e);
		}finally {
			fermeturesSilencieuses(preparedStatement, connexion);
		}
 
	}
 
	@Override
	public List<Commande> lister()throws DAOException {
		Connection connexion = null;
		PreparedStatement preparedStatement = null;
		ResultSet resulSet = null;
		List<Commande> commandes = new ArrayList<Commande>();
		try {
			connexion = daoFactory.getConnection();
			preparedStatement = connexion.prepareStatement(SQL_SELECT);
			resulSet = preparedStatement.executeQuery();
			while (resulSet.next()) {
				commandes.add(map(resulSet));
			}
		} catch (SQLException e) {
			throw new DAOException(e);
		}finally {
			fermeturesSilencieuses(resulSet, preparedStatement, connexion);
		}
		return commandes;
	}
 
	/* Simple méthode utilitaire permettant de faire la correspondance (le mapping) entre une 
	 * ligne issue de la table des clients (un ResultSet) et un bean Client.*/
 
	private Commande map(ResultSet resulSet) throws SQLException {
		Commande commande = new Commande();
		commande.setId(resulSet.getLong("id"));	
		/* Petit changement ici : pour récupérer un client, il nous faut faire appel à la méthode trouver() 
		 * du DAO Client, afin de récupérer un bean Client à partir de l'id présent dans la table Commande.	*/
		ClientDao clientDao = daoFactory.getClientDao();
		commande.setClient(clientDao.trouver(resulSet.getLong("id_client")));
		commande.setDate(new DateTime(resulSet.getTimestamp("date")));
		commande.setMontant( resulSet.getDouble( "montant" ) );
		commande.setModePaiement( resulSet.getString("mode_paiement" ) );
		commande.setStatutPaiement( resulSet.getString("statut_paiement" ) );
		commande.setModeLivraison( resulSet.getString("mode_livraison" ) );
		commande.setStatutLivraison( resulSet.getString("statut_livraison" ) );
 
		return commande;
	}
 
 
}

mon fichier web.xml

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
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
  <filter>
    <filter-name>Set Character Encoding</filter-name>
    <filter-class>org.apache.catalina.filters.SetCharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
      <param-name>ignore</param-name>
      <param-value>false</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>Set Character Encoding</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <filter>
  	<filter-name>PrechargementSessionFilter</filter-name>
  	<filter-class>com.mauricefilRouge.filters.PrechargementSessionFilter</filter-class>
  </filter>
  <filter-mapping>
  	<filter-name>PrechargementSessionFilter</filter-name>
  	<url-pattern>/*</url-pattern>
  </filter-mapping>
  <listener>
  	<listener-class>com.mauricefilRouge.config.InitialisationDaoFactory</listener-class>
  </listener>
  <servlet>
    <servlet-name>CreationClient</servlet-name>
    <servlet-class>com.mauricefilRouge.servlets.CreationClient</servlet-class>
   <init-param>
   	 <param-name>chemin</param-name>
   	 <param-value>/fichiers/images</param-value>
   </init-param>
    <multipart-config>
      <location>C:/fichierstmp/</location>
      <max-file-size>2097152</max-file-size>
      <max-request-size>10485760</max-request-size>
      <file-size-threshold>1048576</file-size-threshold>
    </multipart-config>
  </servlet>
   <servlet>
    <servlet-name>ListeClients</servlet-name>
    <servlet-class>com.mauricefilRouge.servlets.ListeClients</servlet-class>
  </servlet>
  <servlet>
    <servlet-name>SuppressionClient</servlet-name>
    <servlet-class>com.mauricefilRouge.servlets.SuppressionClient</servlet-class>
  </servlet>
  <servlet>
    <servlet-name>CreationCommande</servlet-name>
    <servlet-class>com.mauricefilRouge.servlets.CreationCommande</servlet-class>
    <init-param>
	   <param-name>chemin</param-name>
	   <param-value>/fichiers/images</param-value>
   </init-param>
    <multipart-config>
      <location>C:/fichierstmp/</location>
      <max-file-size>2097152</max-file-size>
      <max-request-size>10485760</max-request-size>
      <file-size-threshold>1048576</file-size-threshold>
    </multipart-config>
  </servlet>
  <servlet>
    <servlet-name>ListeCommandes</servlet-name>
    <servlet-class>com.mauricefilRouge.servlets.ListeCommandes</servlet-class>
  </servlet>
  <servlet>
    <servlet-name>SuppressionCommande</servlet-name>
    <servlet-class>com.mauricefilRouge.servlets.SuppressionCommande</servlet-class>
  </servlet>
  <servlet>
    <servlet-name>Image</servlet-name>
    <servlet-class>com.mauricefilRouge.servlets.Image</servlet-class>
    <init-param>
      <param-name>chemin</param-name>
      <param-value>/fichiers/images</param-value>
    </init-param>
  </servlet>
 
  <servlet-mapping>
    <servlet-name>CreationClient</servlet-name>
    <url-pattern>/creerClient</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>ListeClients</servlet-name>
    <url-pattern>/listeClients</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>SuppressionClient</servlet-name>
    <url-pattern>/suppressionClient</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>CreationCommande</servlet-name>
    <url-pattern>/creerCommande</url-pattern>
  </servlet-mapping>
   <servlet-mapping>
    <servlet-name>ListeCommandes</servlet-name>
    <url-pattern>/listeCommandes</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>SuppressionCommande</servlet-name>
    <url-pattern>/suppressionCommande</url-pattern>
  </servlet-mapping>
<servlet-mapping>
    <servlet-name>Image</servlet-name>
    <url-pattern>/images/*</url-pattern>
  </servlet-mapping>
</web-app>