Dynamic Web Project

Last Updated on 2 anni | Published: 01/06/2024

Pattern MVC

Il pattern MVC (Model-View-Controller) è un’architettura di sviluppo software che separa l’applicazione in tre componenti principali: Model (Modello), View (Vista) e Controller (Controllore). Questo pattern è molto utilizzato nello sviluppo di applicazioni web, comprese quelle basate su servlet e JavaServer Pages (JSP).

Componenti del Pattern

  1. Model (Modello):
    • Il Model rappresenta i dati e la logica di business dell’applicazione. È responsabile di gestire lo stato dell’applicazione e rispondere alle richieste di recupero, aggiornamento e manipolazione dei dati. In un contesto di servlet, il Model può includere oggetti JavaBean, entità JPA (Java Persistence API) o altri componenti che rappresentano i dati e la logica di business.
  2. View (Vista):
    • La View è la parte dell’applicazione che si occupa di visualizzare i dati agli utenti. In un’applicazione basata su servlet, le JSP sono spesso utilizzate come View. La View riceve i dati dal Model, generalmente attraverso il Controller, e li rende in un formato leggibile per l’utente (come HTML).
  3. Controller (Controllore):
    • Il Controller è il componente che gestisce le richieste dell’utente, interagisce con il Model per ottenere o manipolare i dati e determina quale View deve essere visualizzata. Nel contesto delle servlet, il Controller è solitamente implementato con una servlet. Il Controller riceve una richiesta HTTP, esegue la logica di business necessaria, e quindi delega la richiesta a una JSP o un’altra View per la visualizzazione dei risultati.

MVC e Servlet

  • Ricezione della richiesta:

    • L’utente invia una richiesta al server web (ad esempio, tramite un modulo HTML).
    • La richiesta viene intercettata da una servlet che funge da Controller.

  • Elaborazione della richiesta nel Controller:

    • Il Controller (la servlet) analizza la richiesta e determina quale azione deve essere eseguita.
    • Se necessario, il Controller interagisce con il Model per recuperare o aggiornare i dati.
    • I dati vengono preparati in modo tale che la View possa visualizzarli correttamente. Il Controller può mettere i dati in un oggetto HttpServletRequest o HttpSession come attributi.

  • Selezione della View:

    • Il Controller determina quale View (ad esempio, una JSP) deve essere utilizzata per presentare i dati all’utente.
    • Il Controller invia una richiesta alla View selezionata (usando RequestDispatcher per inoltrare la richiesta alla JSP).

  • Renderizzazione della View:

    • La View (JSP) utilizza i dati forniti dal Controller per generare una risposta HTML che viene inviata al browser dell’utente.
    • La View è responsabile solo della presentazione e non contiene logica di business.

Vantaggi dell' utilizzo del Pattern

  • Separazione delle preoccupazioni: Ogni componente (Model, View, Controller) ha un compito specifico, il che rende il codice più organizzato e manutenibile.
  • Flessibilità: È possibile modificare una parte dell’applicazione (ad esempio, la View) senza influenzare le altre (ad esempio, il Model).
  • Riutilizzabilità: La logica di business (Model) può essere riutilizzata da diverse View, migliorando la modularità del codice.

I paragrafi successivi mostrano come utilizzare le classi Servlet per implementare  un Pattern MVC.

Dynamic Web Project - Servlet

Le applicazioni web dinamiche in Java sono alla base di molte soluzioni web moderne. In questo articolo, esploreremo come creare un Dynamic Web Project in Eclipse, utilizzare pagine JSP (Java Server Pages) e configurare Apache Tomcat come server di applicazioni.

Prima di iniziare a  creare progetti web dinamici  dobbiamo aggiungere un web server locale, che nel nostro caso corrisponde alla versione di Apache TomCat che abbiamo installato, lo possiamo  fare  attraverso il menu  Window – Show View – Server. Successivamente possiamo creare un primo progetto, selezionando la prospettiva JavaEE, in alto a destra sulla barra degli strumenti, e con il menu File – New – Dynamic Web Project  si inizia a configurare il progetto inserendo il nome del progetto, la versione del target runtime, che corrisponde al Server TomCat aggiunto ed il file descrittore web.xml (flag presente sull’ ultima schermata prima del Finish).

Una volta terminata la  struttura del progetto in webapp – WEB-INF possiamo modificare il file web.xml ed aggiungere  la pagina JSP iniziale, attraverso il <welcome-file>

Pagine JSP

Le JavaServer Pages (JSP) sono una tecnologia server-side che consente di creare pagine web dinamiche utilizzando Java. Le JSP combinano la semplicità dell’ HTML con la potenza del linguaggio Java, offrendo un modo efficiente per costruire contenuti dinamici per le applicazioni web. In questo articolo, esploreremo cosa sono le pagine JSP, come funzionano, i vantaggi del loro utilizzo, e come implementarle efficacemente.

Le pagine JSP sono documenti basati su template che vengono elaborati sul server per generare contenuti dinamici e interattivi che vengono inviati al client, tipicamente un browser web. Le JSP permettono di inserire codice Java direttamente all’interno del codice HTML utilizzando specifiche direttive e scriptlet.

Sintassi di Base delle JSP

Una pagina JSP è un file con estensione .jsp che può contenere:

  • HTML: Per la struttura e il contenuto statico.
  • Java: Per la logica e la generazione dinamica del contenuto.
  • JSP Tags: Per facilitare le interazioni con Java senza utilizzare codice Java puro.
<%@ page language=”java” contentType=”text/html; charset=UTF-8″ pageEncoding=”UTF-8″%>
<!DOCTYPE html>
<html>
<head>
  <meta charset=”UTF-8″>
  <title>Pagina JSP di Esempio</title>
  <% String nome=”Topolino”%>
</head>
<body>
  <h1>Benvenuto alla mia Pagina JSP</h1>
  <p>Personaggio Storico: <%= nome %></p>
</body>
</html>

In questo esempio della pagina index.jsp il codice <% String nome=”Topolino” %> viene eseguito sul server ed inserisce il nome del personaggio nella pagina HTML.

Vantaggi delle JSP

  1. Separazione della Logica dalla Presentazione: Consente di separare la logica dell’applicazione dal design e dalla presentazione.
  2. Supporto per i Tag Personalizzati: Estende le funzionalità JSP attraverso tag personalizzati.
  3. Semplicità e Facilità d’Uso: La sintassi JSP è simile all’HTML, rendendo facile la sua adozione per sviluppatori con background in HTML.
  4. Supporto per i Framework: Può essere integrata con framework MVC come Spring e Struts per costruire applicazioni web complesse.

Classe Servlet

Le servlet Java sono componenti server-side del framework Java Enterprise Edition (Java EE) utilizzate per estendere le funzionalità di un server web.

Le servlet forniscono una soluzione efficace per la gestione delle richieste HTTP e la generazione di risposte dinamiche da parte del server. Nell’ecosistema delle applicazioni web Java, le servlet sono uno dei mattoni fondamentali per lo sviluppo di applicazioni robuste e scalabili.

Struttura delle Servlet Java

Una servlet Java è una classe Java che implementa l’interfaccia javax.servlet.Servlet. Questa interfaccia definisce i metodi fondamentali che una servlet deve implementare per gestire le richieste HTTP. Ecco la struttura base di una servlet, che è possibile creare attraverso il menu File/New/Servlet :

Fig-1

In questa implementazione, la servlet Controllo estende HttpServlet, che a sua volta implementa l’interfaccia Servlet.

Il metodo doGet viene chiamato dal container servlet per gestire le richieste HTTP di tipo GET, mentre il metodo doPost per gestire le richieste di tipo POST. Inoltre come possiamo notare dalla Fig-1 la classe Controllo viene configurata come Servlet utilizzando l’ annotazione @WebServlet, dove urlPattern rappresenta il percorso URL al quale la Servlet risponderà.

Ciclo di Vita delle Servlet

Le servlet Java seguono un ciclo di vita ben definito all’interno del container servlet. Questo ciclo comprende i seguenti passaggi:

  1. Inizializzazione: Il container servlet carica la servlet e chiama il suo metodo init(). Questo passaggio è eseguito solo una volta durante il ciclo di vita della servlet.
  2. Gestione delle Richieste: Quando il container servlet riceve una richiesta che corrisponde alla servlet, chiama il metodo appropriato (doGet, doPost, ecc.) per gestire la richiesta.
  3. Distruzione: Quando la servlet non è più necessaria o il container servlet è in fase di spegnimento, il metodo destroy() viene chiamato per consentire alla servlet di rilasciare risorse o eseguire altre operazioni di pulizia.
Implementazione del metodo doGet
Ecco un esempio dettagliato di una semplice servlet in un progetto Java, con una pagina index.jsp che effettua una chiamata GET alla servlet. La servlet genera una risposta utilizzando l’oggetto HttpServletResponse e il metodo getWriter per scrivere contenuti HTML.

package com.example;

import java.io.IOException;
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(“/hello“)
public class HelloServlet extends HttpServlet {
      private static final long serialVersionUID = 1L;

      protected void doGet(HttpServletRequest request, HttpServletResponse response)
                                           throws ServletException, IOException {
          response.setContentType(“text/html“);
          response.setCharacterEncoding(“UTF-8“);

           // Utilizzo del metodo getWriter per generare la risposta
           response.getWriter().println(
          “<html>” +
          “<head><title>Risposta dalla Servlet</title></head>” +
           “<body>” +
           “<h1>Hello, World from Servlet!</h1>” +
           “<p>Questa pagina è stata generata da una servlet.</p>” +
           “</body></html>”
         );
    }
}

Nell’ esempio la classe Servlet HelloServlet è stata mappata attraverso l’ annotazione @WebServlet all’ url “/hello“.

La pagina di chiamata, che è la JSP iniziale, potrebbe essere molto simile alla seguente:

<!DOCTYPE html>
<html>
<head>
   <meta charset=”UTF-8″>
   <title>Index Page</title>
</head>
<body>
   <h1>Pagina Index</h1>
   <p> Clicca <a href=”hello“>qui</a> per chiamare la servlet.</p>
</body>
</html>

In conclusione l’ uso di href per puntare ad un URL crea una richiesta HTTP GET.

Passaggio e Recupero di Parametri URL

Il passaggio di parametri attraverso un URL è una tecnica fondamentale per inviare dati dal client al server in applicazioni web. Quando un client (come un browser web) invia una richiesta HTTP a un server, può includere dati nella URL sotto forma di parametri di query.

Questi parametri sono coppie chiave-valore che vengono aggiunte alla fine dell’URL e possono essere facilmente recuperate dal server per elaborare la richiesta. Le servlet Java offrono un modo semplice per accedere e gestire questi parametri.

I parametri di query vengono aggiunti alla fine dell’URL dopo il simbolo ?, e sono separati da & se ce ne sono più di uno. La sintassi è la seguente:

  http://example.com/servlet?param1=value1&param2=value2  

Ecco un esempio di come una servlet Java può recuperare due parametri dalla stringa URL e stamparli su una pagina HTML.

// Importazione delle classi necessarie

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;

// Annotazione per mappare la servlet a una specifica URL
@WebServlet(“/dp“)
public class ExampleServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    // Metodo per gestire le richieste GET
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
                                          throws ServletException, IOException {

        // Recupero dei parametri dalla query string
        String param1 = request.getParameter(“x“);
        String param2 = request.getParameter(“y“);

        // Impostazione del tipo di contenuto della risposta
        response.setContentType(“text/html“);

        // Ottiene il writer per scrivere la risposta HTML
        PrintWriter out = response.getWriter();

        // Scrittura della risposta HTML
        out.println(“<html>”);
        out.println(“<head><title>Display Parameters</title></head>”);
        out.println(“<body>”);
        out.println(“<h1>Values of Parameters</h1>”);
        out.println(“<p>Parametro 1: ” + param1 + “</p>”);
        out.println(“<p>Parametro 2: ” + param2 + “</p>”);
        out.println(“</body>”);
        out.println(“</html>”);
     }
}

Supponiamo che il server web sia in esecuzione sulla porta 8080 e il contesto del progetto sia /MyApp. Puoi accedere alla servlet con una URL che contiene i parametri, come mostrato di seguito:

http://localhost:8080/MyApp/ds?x=valore1&y=valore2

Implementazione del metodo doPost

Una richiesta POST è un tipo di richiesta HTTP utilizzata per inviare dati al server, tipicamente per la creazione o l’aggiornamento di risorse. Questa richiesta è una delle molte operazioni definite dal protocollo HTTP (Hypertext Transfer Protocol) e viene comunemente utilizzata nei form HTML e nelle API REST.

Caratteristiche di una Richiesta POST
  1. Invio di Dati: I dati sono inviati nel corpo della richiesta, non nell’URL. Questo consente l’invio di grandi quantità di dati o dati sensibili che non dovrebbero essere visibili nella stringa URL.
  2. Corpo della Richiesta: Include i dati inviati al server, che possono essere formattati in vari modi, come:
    • application/x-www-form-urlencoded: Dati formati come coppie chiave-valore, tipico per i moduli HTML.
    • multipart/form-data: Usato per inviare file e dati binari.
    • application/json: Dati formattati come JSON, comune nelle API REST.

Vediamo di seguito come la servlet gestisce il metodo doPost, ad esempio se vogliamo inviare al server i nostri dati:

<%@ page language=”java” contentType=”text/html; charset=ISO-8859-1″
    pageEncoding=”ISO-8859-1″%>
<!DOCTYPE html>
<html>
<head>
<meta charset=”ISO-8859-1″>
<title>SERVLET POST</title>
</head>
<body>
<!– Per questa action vedere Servlet Menu metodo doPost –>
<!– Il parametro rep è visibile sull’ url, gli input no –>
<form action=”menu?rep=meccanica” method=”POST”>
    <table>
       <tr>
          <td>nome</td><td><input type=”text” name=”nome”></td>
          <td>cognome</td><td><input type=“text” name=“cognome”></td>
      <tr>
      <tr>
          <td><input type=”submit” value=”INVIO“></td>
      </tr>
   </table>
</form>
</body>
</html>
import java.io.IOException;
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(“/menu”)
public class Menu extends HttpServlet {
     private static final long serialVersionUID = 1L;
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws
     ServletException, IOException {
 
      }
 
      protected void doPost(HttpServletRequest request, HttpServletResponse response) throws
      ServletException, IOException {
            String reparto=request.getParameter(“rep“); // parametro di index.jsp inviato tramite GET ?
            System.out.println(“Nome: “+request.getParameter(“nome“));
            System.out.println(“Cognome: “+request.getParameter(“cognome”));
            System.out.println(“Reparto: “+reparto);
     }
}
Gestione delle Pagine

 È comune utilizzare Servlet per gestire la logica delle applicazioni e poi inoltrare la richiesta a una pagina JSP per la presentazione. Questo approccio separa la logica di business (Servlet) dalla logica di presentazione (JSP). I paragrafi successivi mostrano attraverso esempi pratici come questo sia possibile:

<%@ page language=”java” contentType=”text/html; charset=ISO-8859-1″
    pageEncoding=”ISO-8859-1″%>
<!DOCTYPE html>
<html>
<head>
    <meta charset=”ISO-8859-1″>
    <title>Insert title here</title>
</head>
<body>
     <table border=”0″ cellspacing=”10″>
     <tr>
          <td><a href=”scelta?x=1″>Clienti</a></td>
    </tr>
    <tr>
         <td><a href=”scelta?x=2″>Fornitori</a></td>
    </tr>
    </table>
</body>
</html>
package controlli;
 
import java.io.IOException;
import javax.servlet.RequestDispatcher;
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 = “scelta”, urlPatterns = { “/scelta” })
public class Scelta extends HttpServlet {
      private static final long serialVersionUID = 1L;
      private RequestDispatcher spedizione;
 
      protected void doGet(HttpServletRequest request, HttpServletResponse response) throw
      ServletException, IOException {
         int scelta=Integer.parseInt(request.getParameter(“x”));
         switch (scelta) {
         case 1:
            spedizione=request.getServletContext().getRequestDispatcher(“/pagine/clienti.jsp”);
            spedizione.forward(request, response);
        break;
       case 2:
          spedizione=request.getServletContext().getRequestDispatcher(“/pagine/fornitori.jsp”);
          spedizione.forward(request, response);
       break;
     }
  }
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws
     ServletException, IOException {
 
    }
}

Il paragrafo mostra la pagina index.jsp e la corrispondente Servlet /scelta per gestire le richieste, dove possiamo notare la presenza della classe RequestDispatcher necessaria per ottenere le pagine.

Gestione degli Attributi

In un’applicazione web basata su Java, i metodi getAttribute e setAttribute sono fondamentali per la gestione delle informazioni che devono essere condivise tra diverse parti dell’applicazione, come Servlet, JSP. Questi metodi permettono di memorizzare e recuperare oggetti associati a specifiche richieste, sessioni, o al contesto dell’applicazione.

LABORATORIO

Questa esercitazione utilizza gli scriplet Java per comunicare con il back-end, implementa una  Servlet come classe di controllo per rispondere alle varie richieste provenienti dalla pagina iniziale default.jsp, invia parametri da una richiesta di tipo GET (tag href) e li recupera attraverso la Servlet con il metodo getParameter(). Questo esempio evidenzia un primo utilizzo del pattern MVC, dove la parte Model potrebbe essere una classe contenete accessi ai dati, il Controller è la servlet e le View in questo caso sono i println().

Si può importare in Eclipse versione 2022-03 prospettiva JavaEE mentre per il Server TomCat dovete inserire il vostro Targeted Runtime dalle Properties del progetto oltre a verificare anche la versione di Java:

In questa esercitazione si evidenzia l’ utilizzo degli Attributi nella classe di controllo Servlet,  in che modo si possono configurare attraverso il metodo setAttribute(chiave,oggetto) e come recuperarli da una pagina JSP con scriplet java. La classe RequestDispatcher  ci da la possibilità di inoltrare richieste verso altre  pagine JSP preventivamente create e depositate in opportuni folder di back-end. Il progetto, che evidenzia la presenza del pattern MVC.

Importare il progetto in Eclipse come descritto e verificare anche la versione di Java installata:

Con questo esempio si dimostra l’ utilizzo delle form nelle pagine JSP, ovvero moduli HTML con un back-end Java, infatti invieremo dati alla Servlet attraverso interfacce client HTML. Anche in questo caso si utilizza il metodo getParmeter() di una richiesta evidenziando la differenza tra i dati inviati con GET e quelli inviati con POST.

Importare il progetto in Eclipse come descritto e verificare anche la versione di Java installata:

In questa esercitazione viene mostrato l’ utilizzo dei metodi get/set Parameters e get/set Attribute dell’ oggetto request, per gestire un ArrayList di Persone.

Importare il progetto in Eclipse e verificare anche la versione di Java installata:

Questa esercitazione, che utilizza scriplet Java dimostra come gestire attraverso Servlet una tabella Studenti di una database MySql. Si può risalire ai nomi tabelle/tracciati record di Studenti e Login attraverso le classi DaoStudenti e DaoLogin (vedi rispetivamente il metodo per inserire studenti ed il metodo per risolvere il login) mentre per i tipi di campi potreste consultare il modello BeanStudenti. In questa esercitazione si evidenzia anche l’ utilizzo del costrutto try-catch ( vedi il codice sorgente ).

Importare il progetto in Eclipse e verificare anche la versione di Java installata:

L’ esercitazione seguente è una implementazione della precedente dal punto di vista soprattutto front-end. Infatti si utilizza la libreria JQuery per alcune pagine. Ovviamente l’ utilizzo di Javascript è marginale ma lascia intendere il suo funzionamento. Con l’ occasione mediante get e set Attributi delle servlet è stato possibile gestire il messaggio di errore quando l’utente inserito non viene riconosciuto.

Importare il progetto come il precedente:

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *