vuoi
o PayPal
tutte le volte che vuoi
MODEL VIEW
1- Attraverso la view l'utente genera un evento.
2- Il controller cattura l'evento e attiva la funzionalità presente nel model.
3- Il controller riceve i dati generati dal model.
4- Visualizzazione attraverso una view dei dati.
MVC IN UN APPLICATIVO WEB JAVA
In questo paragrafo verrà definito come applicare il pattern MVC in un'applicazione web implementata in ambiente Java.
L'applicazione sarà realizzata sfruttando i SERVLET e le JSP.
Inoltre, attraverso il framework HIBERNATE l'applicativo interagisce con il database MySQL.
2.1 - Servlet
I Servlet sono delle applicazioni scritte in Java che vengono attivate a seconda del tipo di request HTTP effettuata dal client (GET o POST).
I dati prodotti vengono iniettati nella request effettuata dal client e successivamente viene richiamata una pagina JSP nella quale vengono prelevati alcuni o tutti i parametri presenti nella request (compresi quelli elaborati dalla Servlet).
Infine, la pagina
JSP viene trasformata in HTML attraverso un interprete presente nel server e viene inviata al client come response. Di seguito è riportata la sintassi della Servlet. ```html@WebServlet (name = "n_servlet", url = "path")
public class n_servlet extends HttpServlet {
// Attivazione sul metodo GET
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.getParams(key); // Estraggo valore dalla request
// Richiamo il Model
request.setAttribute(key, value); // Inserisco una variabile nella request
request.getRequestDispatcher(path).forward(request, response);
}
// Attivazione sul metodo POST
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// stesso codice
}
}
```
In alternativa alla pagina JSP è possibile rispondere con un file JSON. Così facendo trasformeremo l'applicazione WEB in un web services.La sintassi corretta (da inserire nel metodo doGet/doPost) è la seguente:
```java
JSONObject a = new JSONObject();
a.put("chiave","valore");
PrintWriter write = response.getWriter();
write.write(a.toJSONString());
write.close();
```
62.2 - JSP
Le pagine JSP sono delle pagine HTML dove è possibile estrarre variabili dalla request ed effettuare cicli iterativi (pagina dinamica).
Di seguito è riportata la sintassi.
Sintassi estrazione variabile dalla request:
```html
${key}
```
Estrazione valore associato alla variabile key impostata nella servlet.
Sintassi ciclo iterativo:
```html
<% taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core" %>
```
(Ad inizio pagina)
```html
è possibile associare:
- Model: Service, logica di business dell’applicazione
- View: Pagine JSP
- Controller: Servlet
Lo schema a blocchi riportato di seguito definisce l’architettura dell’applicazione.
7GET POST execute Services GET Database(model) POST Servlet Web Aggiunta dati Browser nella request Servlet HTML JSP(view) HTML
L’utente attraverso una specifica richiesta attiva la servlet dedicata la quale risponde, inviando al client, la pagina HTML richiesta. Appena si avvia la servlet, si esegue la funzione appartenente al model e si inseriscono i dati ottenuti all’interno della richiesta. Successivamente viene passato il controllo alla pagina JSP dove vengono iniettati al suo interno i dati relativi della “request”. Il server produce la risposta trasformando in HTML la pagina JSP.
Nella maggior parte dei casi le funzioni del model che vengono richiamate appena si attiva la servlet contengono diverse chiamate al database.
Il framework Hibernate
Il tuo compito è formattare il testo fornito utilizzando tag html.
ATTENZIONE: non modificare il testo in altro modo, NON aggiungere commenti, NON utilizzare tag h1;
permette di gestire le operazioni CRUD controllando contemporaneamente la consistenza sui dati.
2.3 - Hibernate
Hibernate è un framework che semplifica l'uso dei database relazionali nelle applicazioni Java mappando i dati relazionali in oggetti Java accessibili dall'applicazione attraverso un session manager.
Il framework in questione inoltre, semplifica il lavoro dei programmatori, evitando loro di occuparsi dei dettagli di accesso al DB e consente loro di lavorare con degli oggetti Java.
Configurazione
Prima di utilizzare le funzionalità del framework, occorre configurarlo correttamente. Di seguito viene riportato un esempio di configurazione.
Proprietà di configurazione
Definizioni delle classi
Nelle definizioni delle classi, occorre inserire tutte le classi, appartenenti al blocco model che mappano le tabelle del nostro database.
Di seguito viene riportato un esempio che specifica come una tabella deve essere mappata all'interno del blocco model.
Relazioni-
Metodi Getter e Setter
Le relazioni tra tabelle si mappano nel modo seguente:
Uno a Molti - bidirezionale
Consideriamo le seguenti tabelle con relazione 1 a N.
N1 10
Queste due tabelle verranno mappate attraverso due classi: Categoria.java e Veicolo.java.
Ognuno dei file avrà la stessa struttura della classe mostrata come esempio in precedenza.
La tabella con cardinalità N avrà, nel rispettivo file Java, la seguente notazione:
@ManyToOne
@JoinColumn (name='x', referencedColumnName='y')
Dove x indica il nome della colonna relativa alla Foreign key (categoria_pk), mentre y indica il nome della colonna relativa alla chiave primaria della tabella con cardinalità 1 (id_categoria).
La tabella con cardinalità 1 avrà, nel rispettivo file Java, la seguente notazione:
@OneToMany(mappedBy = 'x', cascade=cascadeType.All, orphanRemove=true)
Dove x indica il nome dell'attributo utilizzato per esprimere
L'entità nella classe che mappa la tabella con cardinalità 1 (categoria). @ManyToOne
Molti a Molti - bidirezionale
Prendiamo in considerazioni le seguenti tabelle: 11
La relazione molti a molti si implementa inserendo una terza tabella contente le chiavi primarie delle due tabelle (chiavi esterne). Ogni tabella ha relazione uno a molti rispetto a quella nuova.
Le classi che mapperanno le due tabelle avranno la notazione @ManyToMany
Nella classe employee.java sarà presente:
@ManyToMany(cascade=cascadeType.All)
@JoinTable(Name = 'a',joinColumns = {@JoinColumn(name = 'b') },inverseJoinColumns = {@JoinColumn(name = 'c')})Dove a indica il nome della terza tabella, b indica il nome della colonna riferita alla chiave primaria della tabella employe mentre c indica il nome della chiave primaria della tabella project.
Nella classe project.java sarà presente:
@ManyToMany(mappedBy='a')Dove a indica il nome dell'attributo
associato alla notazione @ManyToMany della classe che mappa la tabella employe (employe.java).
NB Se per scopi progettuali la terza tabella deve contenere altri attributi oltre alle due chiavi esterne, occorre mapparle con la relazione una a molti studiata in precedenza.
Operazioni CRUD
Ogni operazione CRUD rispetta la seguente procedura:
- apertura
- chiusura
- sessione
- sessione1
- creazione
- esecuzione
- operazione
- transizione
- transizione
- CRUD
Riportiamo in seguito alcuni esempi pratici:
Esempio Lettura
Esempio Eliminazione
Esempio Modifica
Esempio Inserimento
2.4 - Progettazione del model
In questo paragrafo descriviamo come strutturare il model all'interno dell'applicazione.
Occorre creare un package dove inserire inizialmente tutte le classi relative ai dati che vengono elaborati dall'applicazione (ogni tabella del database ha la sua classe). In ogni classe bisogna definire: le proprietà, il costruttore, i metodi getter e setter, il metodo toString (opzionale) e le notazioni
<!-- per la mappatura delle tabelle in oggetti (solo se si utilizza un framework ORM) -->
<public class="n_classe">
<!-- Attributi -->
<!-- Costruttore -->
<!-- Getter e Setter -->
</public>
<!-- Successivamente occorre creare delle interfacce dove definire (senza implementare) tutte le funzioni relative alle operazioni CRUD -->
<public interface="n_interfaceDAO">
<!-- funzione 1 -->
<!-- funzione 2 -->
<!-- funzione n -->
</public>
<!-- Una volta creati i modelli dei dati e le interfacce, occorre creare le classi che implementano la connessione al database e l'esecuzione delle operazioni da effettuare sul DB stesso (implementazione dei metodi descritti nell'interfaccia) -->
<public class="n_classeDAODB" implements="n_interfaceDAO">
<!-- Implementazione dei metodi dell'interfaccia -->
<@Override>
<!-- funzione_n -->
</public>
<!-- Così facendo, si è strutturato in maniera corretta il blocco model del paradigma MVC -->
<!-- Per richiamarlo, come descritto in precedenza, occorre inserire nella servlet di riferimento la seguente -->
Per ricavare i dati da salvare nella request bisogna accedere ai metodi presenti in var.
163 - AUTENTICAZIONE E SESSIONI
In questo capitolo verrà analizzato il metodo di autenticazione all'applicazione web, sfruttando Servlet e JSP.
Il metodo consiste nella seguente procedura:
- Creare una pagina JSP (login.jsp) dove inserire il form relativo al login
- Creare la servlet in ascolto sul metodo POST all'indirizzo url definito nella form creata al passo precedente.
- Estrarre nella servlet creata i parametri di login e procedere con l'autenticazione
<form action="${pageContext.request.contextPath}/login" method="post">
<input type="text" name="username" />
<input type="password" name="password" />
<input type="submit" value="login" />
</form>@Override 17
Accedi a tutti gli appunti
Tutor AI: studia meglio e in meno tempo
