Connessione MySql con JSP e Servlet

Per connettersi a un db MySql tramite le JavaServer Pages (JSP) ci sono diversi modi.

Il più semplice è di scrivere il codice direttamente dentro la pagina, ma non è il modo migliore in quanto non rispecchia il modello MVC (Model View Conroller).

Il mio modo è un buon punto di partenza, anche se si potrebbe sicuramente migliorare già usando Hibernate e le classi DAO per la connessione.

Io per la connessione invece uso il mio metodo solito, che vi riporto e che trovate spiegato meglio qua.

Come IDE uso Netbeans, ma ciò che scrivo vale per qualsiasi cosa usiate.

Prima di tutto create una nuova applicazione Web Java.

Vi verrà creata una pagina index.jsp e il file WEB-INF/web.xml, che contiene la configurazione del nostro sito.

Da Netbeans aggiungiamo i Driver JDBC per MySQL e le librerie JSTL.

Creiamo un nuovo package (l'ho chiamato operazioni_database) dentro il quale metteremo tutte le nostre classi e Servlet.

Creiamo la classe per la connessione dentro al package:

package operazioni_database;

import java.sql.*;

public class Connessione {

public static Connection getConnection() throws ClassNotFoundException, SQLException {
Connection conn = null;
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection("jdbc:mysql://host:porta/db?user=user&password=pass");
return conn;
}
}

Questa classe contiene i parametri per la connessione e la richiameremo nella Servlet.

Adesso creiamo una nuova classe che reppresenta i campi del nostro db; questa classe segue le specifiche delle JavaBeans:

package operazioni_database;

public class Movimenti {

private int id;
private int entrate;
private int uscite;
private String causale;
private String data;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public int getEntrate() {
return entrate;
}

public void setEntrate(int entrate) {
this.entrate = entrate;
}

public int getUscite() {
return uscite;
}

public void setUscite(int uscite) {
this.uscite = uscite;
}

public String getCausale() {
return causale;
}

public void setCausale(String causale) {
this.causale = causale;
}

public String getData() {
return data;
}

public void setData(String data) {
this.data = data;
}
}

Come vedete questa classe contiene solo tante variabili quanti sono i campi del nostro db, con i soli metodi get e set e costruttore vuoto.

Anche questa classe verrà usata nella servlet.

A questo punto creiamoci questa servlet.

In generale una Servlet è una normale classe che estende l'interfaccia HttpServlet.

La pecurialità è che deve essere aggiunta al file web.xml.

Abbiamo due possibilità:

• creare una nuova classe e scrivere il resto a mano
• creare una nuova servlet in modo che Netbeans la aggiunga automaticamente a web.xml

Usiamo la seconda opzione.

Andate però prima a leggervi qualcosa sulle Servlet.

La servlet creata avrà una struttua che noi cambieremo così:

package operazioni_database;

import java.io.IOException;
import java.sql.*;
import java.util.ArrayList;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class DoQuery extends HttpServlet {

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doPost(request, response);
}

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
ArrayList list = new ArrayList();
conn = Connessione.getConnection();
stmt = conn.createStatement();
rs = stmt.executeQuery("SELECT * FROM movimenti");
while (rs.next()) {
Movimenti moves = new Movimenti();
moves.setId(rs.getInt("id"));
moves.setEntrate(rs.getInt("entrate"));
moves.setUscite(rs.getInt("uscite"));
moves.setCausale(rs.getString("causale"));
moves.setData(rs.getString("data"));
list.add(moves);
}
request.setAttribute("list", list);
RequestDispatcher disp = request.getRequestDispatcher("/index.jsp");
disp.forward(request, response);
} catch (ClassNotFoundException ex) {
ex.getMessage();
} catch (SQLException ex) {
ex.getMessage();
} finally {
try {
rs.close();
stmt.close();
} catch (SQLException ex) {
ex.getMessage();
}
}
}
}

In pratica riscriviamo i metodi doPost e doGet direttamente; doGet non farà altro che richiamare doPost.

Questi due metodi raccolgono le richieste post e get proveniente dall pagina.

In Connection viene richiamata la nostra classe per la connessione al db.

Creiamo poi i soliti Statement e ResultSet per eseguire la query ed estrapolare i dati.

La cosa in più rispetto agli altri metodi usati negli altri articoli è l'uso di un ArrayList.

In questo ArrayList aggiungiamo i campi del db usando la nostra classe JavaBeans.

Questo viene fatto nel ciclo while; per tutti i risultati estrapolati dal ResulSet creiamo un nuovo oggetto Movimenti usando i campi del db che vogliamo (magari non vogliamo vederli tutti):

while (rs.next()) {
Movimenti moves = new Movimenti();
moves.setId(rs.getInt("id"));
moves.setEntrate(rs.getInt("entrate"));
moves.setUscite(rs.getInt("uscite"));
moves.setCausale(rs.getString("causale"));
moves.setData(rs.getString("data"));
list.add(moves);
}

Le ultime tre righe del try

request.setAttribute("list", list);
RequestDispatcher disp = request.getRequestDispatcher("/index.jsp");

disp.forward(request, response);

servono per:

• settare la richiesta del browser (request) con l'attributo list (il nostro ArrayList); questo ci servirà per richiamare i dati estrapolati nella jsp
• eseguire un reindirizzamento sulla pagina in modo che venga visualizzata dopo la query

Questo già potrebbe bastare, ma andiamo a vedere il file web.xml.

Netbeans ha aggiunto in maniera automatica le seguenti righe per la servlet:

<servlet>
<servlet-name>DoQuery</servlet-name>
<servlet-class>operazioni_database.DoQuery</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>DoQuery</servlet-name>
<url-pattern>/DoQuery</url-pattern>
</servlet-mapping>

E' importante sapere sempre come agire a mano in caso di bisogno.

Inoltre se eseguiamo la jsp non verrà fatta nessuna query in automatico, in quanto la servlet va attivata in qualche modo (link, bottone, form).

Se nella home page del sito (index.jsp in questo caso) avete bisogno di visualizzare i dati allora potete fare questa modifica a web.xml:

<welcome-file-list>
<welcome-file>DoQuery</welcome-file>
</welcome-file-list>

In pratica verrà richiesta prima la servlet che poi fa il forward sulla pagina.

Così simulate il classico comportamento di PHP o Asp.NET.

(Sono sicuro non sia il modo migliore, ma è la cosa migliore che mi è venuta in mente. Si accettano suggerimenti).

A questo punto vediamo la jsp:

<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Banca JSP</title>
</head>
<body>
<table>
<thead>
<th>
ID
</th>
<th>
ENTRATE
</th>
<th>
USICTE
</th>
<th>
CAUSALE
</th>
<th>
DATA
</th>
</thead>
<c:forEach items="${requestScope.list}" var="lists">
<tr>
<td>
<c:out value="${lists.id}"/>
</td>
<td>
<c:out value="${lists.entrate}"/>
</td>
<td>
<c:out value="${lists.uscite}"/>
</td>
<td>
<c:out value="${lists.causale}"/>
</td>
<td>
<c:out value="${lists.data}"/>
</td>
</tr>
</c:forEach>
</table>
</body>
</html>

In pratica, dopo aver installato le librerire JSTL, dobbiamo aggiungere a inizio pagina questa riga:

<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>

Questa serve per usare JSTL, e nello specifico la libreria c (core; ce ne stanno diverse).

Poi ho creato una tabella per rappresentare i dati e ho iterato usando forEach usando requestScope.list.

In pratica altro non ho fatto che richiamare il request settato nella servlet.

Poi ho messo dentro tante celle quanti sono i campi che voglio vedere.

A creare il numero di righe giusto ci pensa la servlet nel ciclo while, e a rappesentarle il forEach e out di JSTL.

E questo è quanto.

Potrebbe sembrare un pò confusionario, ma se leggete qualche guida a Servlet capirete in breve tempo.

Tenendo in considerazione che esiste sicuro un modo migliore, questo mi sembra un buon metodo di partenza in quanto tiene separato il codice dalla visualizzazione.

Se vedete infatti nella jsp non abbiamo scritto codice (a parte JSTL, ma in qualche modo l'output della servlet deve essere recuperato).

Abbiamo scritto una classe che rappresenta il db, una classe per eseguire la query e una jsp per rappresentare i dati!