Un framework per il pattern MVC

Simone Pulcini

Oggi parleremo di:

Framework Design Pattern e MVC Contoller in Struts e Servlet Model in Struts e Form Bean View in Struts e Java Server Pages (JSP)

Framework: definizione

Insieme di librerie di codice Implementano funzionalità per sviluppare una propria

applicazione software

Favorisce riusabilità del codice e permette di concentrarsi sullo sviluppo di funzionalità proprie. Sviluppo come integrazione Funzionalità del framework documentate attraverso le API.

Sovrainsieme delle librerie run-time proprie del linguaggio. Offre funzionalità specifiche

Design Pattern

Soluzione riutilizzabile ad un problema comune nello sviluppo di software

Soluzione proposta non è implementazione diretta.

Descritta attraverso un template, per astrarre dal linguaggio di sviluppo e dal caso specifico

Design Pattern MVC

Separa logica operativa da interfaccia utente. Interfaccia utente detta VIEW Sorgenti di dati identificate dal MODEL Interazione gestita dal CONTROLLER; notifica il

MODEL di richieste di cambiamenti risultanti dalle interazioni.

MODEL notifica VIEW dei cambiamenti nei dati

MVC: Diagramma

Controller

View Model

Problemi MVC su Web

Connessioni senza stato fra client e server Come notificare modifiche nel model? Browser deve reinterrogare il server per scoprire

modifiche nello stato dell’applicazione Differenze nella tecnologia di

implementazione fra client e server

MVC Model 2

Struts e MVC

Struts: framework che implementa il pattern MVC per lo sviluppo di web applications

Struts integra ed estende alcuni componenti di Java Enterprise Edition

Arricchisce le API Java per la gestione delle Servlet e offre tag aggiuntivi per le Java Server Pages (JSP)

Diagramma di una applicazione Struts

Application Server

Web Browser

View

Controller

ModelJSP

Struts-config.xml e Actions

ActionForm beans

Ruoli Client browser

Produce eventi di richiesta e attende una risposta. Controller

Riceve la richiesta e decide a chi mandarla. Riflette il pattern Command ed è implementato come servlet. Configurato in struts-config.xm

Business logic Aggiorna lo stato del modello e aiuta a controllare il flusso dell’applicazione. Realizzato

mediante una Action class. Model state

Rappresenta lo stato dell’applicazione. Rappresentato da bean ActionForm a livello di sessione o richiesta, non a livello di persistenza. Informazione dalla ActionForm letta mediante tag JSP.

View Componente JSP senza logica di flusso o di business o informazione di modello, solo

tag.

Componenti chiave

"request" handler fornito dall’applicazione, associato a uno URI standard.

"response" handler trasferisce il controllo a un’altra risorsa che completa la risposta.

Biblioteca di tag per creare applicazioni interattive, basate su form, con pagine lato server.

Controller in Struts

Controller di Struts basato su 4 componenti:1. ActionServlet

2. Action

3. Plugins

4. RequestProcessor Flusso di web application: da richiesta dal

client a risposta offerta da application server

Servlet: definizione

Componente di web application Java EE Programma Java che gira lato server

(differentemente da una applet che gira lato client)

Classe java che estende funzionalità offerte da un server (HTTP, FTP, SMTP ecc.) HttpServlet (da javax.servlet.http)

Architettura

Separation of concerns per Web applications

Per-action logic Accesso agli oggetti necessari per eseguire

la logica dell’azione e accedere alle risorse Traduzione, associazione e conversione da

valore stringa in HTML a tipi e primitive e da oggetti vista a oggetti business

Cross-cutting concerns per fornire funzionalità a gruppi di azioni o a tutte le azioni nell’applicazione.

Ciclo di vita

Servlet: ciclo di vita

Richiesta da client ad application server Application server verifica in web.xml a quale servlet

mappare la richiesta Classe Servlet indicata nel descrittore viene caricata,

istanziata, e inizializzata dal Servlet Container La classe genera la risposta alla richiesta ricevuta dal

client [doGet(); oppure doPost();] Se non vi sono altre richieste da soddisfare con tale

servlet, Servlet Container chiama il metodo destroy()

ActionServlet: la servlet di Struts Controller si innesta estendendo ActionServlet Questa servlet raccoglierà tutte le richieste conformi ad un certo

pattern, opportunamente dichiarato nel file web.xml Ma se c’è una sola servlet che raccoglie tutte le richieste,

come differenzio le risposte? ActionServlet prende come parametro un file di configurazione

(struts-config.xml) nel quale lo sviluppatore può dichiarare i mapping fra una risorsa richiesta (path), la logica di risposta (Action) e la pagina JSP che produce il risultato (View)

Struts genera opportunamente il codice di risposta dei metodi doGet o doPost in base a quanto dichiarato nel file di configurazione struts-config.xml

Esempio: WEB.XML

E’ il file di descrittore di ciascuna WEB APPLICATION. Viene letto dall’application Server. NON E’ UN FILE DI CONFIGURAZIONE DI STRUTS

In esso però scriveremo una dichiarazione ad hoc per far si che ogni richiesta venga elaborata da una particolare servlet che estende la ActionServlet delle API di Struts

WEB.XML<servlet>

     <servlet-name>action</servlet-name>      <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>      <init-param>        <param-name>config</param-name>        <param-value>/WEB-INF/struts-config.xml</param-value>      </init-param>

….</servlet>

<servlet-mapping>    <servlet-name>action</servlet-name>    <url-pattern>*.do</url-pattern>

</servlet-mapping>

Struts-config.xml; tag <action>

Indica mapping fra risorse View, Controller, Model Tag <action> All’interno si dichiara in quale classe è implementata la

logica di controllo che deve gestire la richiesta di una risorsa effettuata dal client, quale è la view e quale è il model con il quale si devono rappresentare i dati

Esaminiamo, per concludere il discorso sul Controller, i tipi di classi Action messi a disposizione da Struts e vediamo eventualmente come definire una nostra Action che implementa una logica non identificabile tra le Action già implementate in Struts

Actions in Struts Ogni classe di tipo Action deve estendere la classe

org.apache.struts.action.Action Ogni Action deve ridefinire il metodo execute() che ha la

seguente segnature:public ActionForward execute(

    ActionMapping mapping,    ActionForm form,    HttpServletRequest request,    HttpServletResponse response) throws Exception

Non è compito dello sviluppatore istanziare la classe ACTION!!!

Sarà la ActionServlet, in base a quanto dichiarato nel file di configurazione struts-config.xml, ad istanziare la corretta Action e a chiamare il metodo execute in essa ridefinito.

Esempio di Actionpackage org.prova;

import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.apache.struts.action.Action;import org.apache.struts.action.ActionForm;import org.apache.struts.action.ActionForward;import org.apache.struts.action.ActionMapping;

public class TestAction extends Action {  public ActionForward execute(    ActionMapping mapping,    ActionForm form,    HttpServletRequest request,    HttpServletResponse response) throws Exception{// Logica di controllo (codice Java) ……//al termine devo restituire una istanza di ActionForward per soddisfare//la segnatura del metodo execute()

       return mapping.findForward("testAction");  }}

Struts-config.xml: tag <action>

<action-mappings>

<action path="/TestAction" type=“org.prova.TestAction">

<forward name="testAction" path="/pages/TestAction.jsp"/>

</action>

</action-mappings>

Actions Built-in di Struts

Vi sono alcune Action già implementate che offrono funzionalità comuni. Possibile usarle direttamente.

org.apache.struts.actions.DispatchAction Riceve valore che può funzionare come discriminante in un

parametro della URL. Invece di execute, un metodo per ogni valore di tale parametro. A seconda del valore presente nel parametro, Struts chiamerà il metodo corrispondente

org.apache.struts.actions.ForwardAction Chiama pagina jsp. Non richiede nessuna implementazione di

codice ma solo dichiarazione opportuna in tag <action>

Esempio di Dispatch Actionpackage org.prova;

import java.io.*;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import javax.servlet.ServletException;import org.apache.struts.actions.DispatchAction;import org.apache.struts.action.ActionForm;import org.apache.struts.action.ActionForward;import org.apache.struts.action.ActionMapping;

public class Dispatch_Action extends DispatchAction {  public ActionForward add(    ActionMapping mapping, ActionForm form, HttpServletRequest request

HttpServletResponse response) throws Exception {    System.out.println("You are in add function.");      return mapping.findForward("add");  }

Dispatch action (contd.)

public ActionForward edit(    ActionMapping mapping, ActionForm form,    HttpServletRequest request,    HttpServletResponse response) 

throws Exception {

    System.out.println("You are in edit function.");            return mapping.findForward("edit");

 } 

}

Dispatch Action: struts-config.xml

<actionpath="/DispatchAction"type=“org.prova.Dispatch_Action"parameter=“discrimina"input="/pages/DispatchAction.jsp"name="DispatchActionForm"><forward name="add" path="/pages/DispatchActionAdd.jsp" /><forward name="edit" path="/pages/DispatchActionEdit.jsp" /><forward name="search“ path="/pages/DispatchActionSearch.jsp"/>

</action>

ForwardAction: struts-config.xml

Forward Action richiede sola configurazione; non è necessario scrivere codice Java

<actionpath="/success"type="org.apache.struts.actions.ForwardAction"parameter="/pages/Success.jsp"input="/pages/ForwardAction.jsp“>

</action>

Model in Struts

Struts non dettaglia scelte specifiche sulle componenti che riguardano il Modello.

Fondamentalmente il Modello deve occuparsi del reperimento di dati e informazioni ignorando comunque come esse verranno presentate nella View

Per il modello vi sono molte API che permettono ad esempio l’interfacciamento con un database (JDBC, Hibernate…)

ActionForm: il punto di raccordo tra Model e View Struts prevede struttura di supporto per raccordare i

dati ottenuti dal modello e renderli più facilmente manipolabili da una View.

ActionForm: Java Bean estende org.apache.struts.action.ActionForm, le cui variabili membro contengono i valori di un form html dichiarato nella view (oltre eventuali parametri passati nella URL e tag di tipo “hidden”)

ActionForm popolato automaticamente da Struts Ogni pagina jsp “dovrebbe” contenere la dichiarazione

di un form html. Attraverso opportuni tag dichiaritivi contenuti nella pagina JSP, Struts sarà in grado di popolare il bean associato a tale form

ActionForm: esempio

package org.prova;import org.apache.struts.action.ActionForm;

  public class DispatchActionForm extends ActionForm {

     private String discriminante =" "; 

  public String getDiscriminante( ) {         return  discriminante;    }public void setDiscriminante(String discriminante)   {    this.discriminante = discriminante}

Action Form: struts-config.xml

<form-bean name="DispatchActionForm"           type=“org.prova.DispatchActionForm"/>

View in Struts

Struts estende Java Server Pages (JSP) aggiungendo ulteriori tag a quelli già presenti

Prima di vedere alcuni esempi però è necessario richiamare alcuni concetti di base riguardanti le pagine JSP

JSP: definizione e ciclo di vita Java Server Pages è una tecnologia per la realizzazione di

pagine web con contenuti dinamici Una pagina JSP può contenere:

1. Tag HTML2. Tag XML definiti in apposite librerie esterne (Tag Libraries)3. Codice Java inserito in apposite sezioni denominate “Scriptlet”

Una pagina JSP viene caricata dall’application Server e tradotta in nell’output finale, HTML, subendo però un processo di generazione intermedio. Il container che si occupa di tradurre le JSP genera infatti una Servlet (JSP Page Implementation Class)

Il codice Java della Servlet si occupa di creare dinamicamente sullo stream di Output il sorgente HTML che viene offerto quale risposta alla richiesta effettuata dal client

JSP: Tag Libraries 1/2

Le specifiche JSP prevedono tag di base identificabili dal prefisso “jsp”

In generale un tag ha un prefisso relativo alla tag library di appartenenza seguito dal nome della funzionalità che si intende utilizzare:

<nome_prefisso:nome_funzione>…</nome_prefisso:nome_funzione>

JSP: Tag Libraries 2/2

Tag library è composta da un jar e da un file “.tld” che descrive il contenuto del jar. Ha una sintassi specifica.

Il jar e il tld permettono all’opportuno componente dell’application server di tradurre i tag in frammenti di codice java. L’application server sa dell’esistenza di nuove tag libraries perché file web.xml avrà ricevuto le opportune modifiche per le nuove dichiarazioni di tag libraries aggiuntive

Processo di traduzione da JSP in Servlet e produzione del codice HTML di output interamente server-side

JSP: scriptlet

Codice Java incluso direttamente, racchiuso tra opportuni marcatori; se necessario si possono anche scrivere tag html.

Problema manutenzione di JSP contenente scriptlet, HTML e tag appartenenti a librerie

Esistono oggi molte tag libraries, comprese quelle aggiunte da Struts e le note JSTL, che permettono tramite tag di rendere una pagina JSP facilmente “scriptless”

Tag Libraries di Struts

Bean: contiene tag per la manipolazione e l’accesso di Java Bean

Html: contiene tag per creare form HTML gestibili attraverso Struts e ulteriori tag per generare altri elementi html (ovvero permettono di non usare direttamente tag HTML dentro la pagina JSP)

Logic: contiene tag per riprodurre logica decisionale, cicli iterativi e valutazioni di valori

Esempio finale

Faremo vedere i componenti di una mini web application struts che visualizza una pagina con un form nel quale è possibile inserire un numero

Se questo numero è uguale ad 1 verrà visualizzato una pagina con un messaggio di successo.

In ogni altro caso verrà visualizzata una pagina di insuccesso.

Form bean Ci serve un bean in cui memorizzare il numero che verrà inserito nel

form visualizzato dall’utente.package org.prova;

import org.apache.struts.action.*;

import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;

public class LogicForm extends ActionForm  {        private long number;    public long getNumber()  {        return number;    }    public void setNumber(long number)  {    this.number=number;  }}

Pensiamo ora alla Action

Non ha bisogno di logica operativa particolare; dovrà soltanto restituire il mapping alla pagina successiva (ovvero la pagina dove esaminerò il valore introdotto dall’utente e stamperò un msg di successo/insuccesso)

Actionpackage org.prova;

import java.io.*;import java.util.*;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import javax.servlet.ServletException;import org.apache.struts.action.*;

public class LogicAction extends Action  {  public ActionForward execute(ActionMapping mapping,    ActionForm form,    HttpServletRequest request,    HttpServletResponse response)    throws IOException, ServletException { //Il mapping identificato dalla stringa “success” si trova in struts-config.xml             return mapping.findForward("success");    }}

Configuriamo lo struts-config.xml per il bean e per la action

<form-bean name="LogicForm"  type=“org.prova.LogicForm" />

<action path="/LogicAction"type=“org.prova.LogicAction"name="LogicForm"input="/pages/InputLogic.jsp">

<forward name="success" path="/pages/output.jsp"/>

</action>

InputLogic.jsp<%@ taglib uri="/tags/struts-html" prefix="html" %>

<%@ taglib uri="/tags/struts-logic" prefix="logic" %>

<html:html><head><title>Esempio tag Logic</title></head>

<body>

<html:form action="/LogicAction" method ="post">

<h2>Enter a number:</h2><html:text property="number"/>

<br>

InputLogic.jsp (contd.)

<br><h3>Nella pagina di output logic:equal funzionerà se il valore inserito sarà 1</h3>

<h3>altrimenti verrà eseguito logic:notEqual</h3>

<br>

<html:submit value="Submit"/>

<html:cancel/></html:form></body></html:html>

Output.jsp

<%@ taglib uri="/tags/struts-bean" prefix="bean" %><%@ taglib uri="/tags/struts-logic" prefix="logic" %>

<html><head><title>Verifichiamo il dato...</title></head>

<body><h3>Il momento della verifica!!!!!</h3>

<h4>Il numero inserito è:</h4>

Output.jsp

<bean:write name="LogicForm" property="number"/></h4>

<logic:equal name="LogicForm" property="number" value="1"><h4>Hai immesso il numero 1 e sono entrato nel tag equal</h4> </logic:equal>

<logic:notEqual name="LogicForm" property="number" value="1"><h4>Hai immesso un numero diverso da 1 e sono entrato nel tag notEqual</h4> </logic:notEqual>

</body></html>

Fonti:

Chuck Cavaness, Programming Jakarta Struts, 2nd Edition, O’Reilly, 2004

http://struts.apache.org/ http://www.infoq.com/minibooks/starting-strut

s2

http://www.roseindia.net/struts/