Una guida per principianti all'architettura MVC in Java

Pubblicato: 2018-04-10

Se sei legato alla scena dello sviluppo web, ti sarai sicuramente imbattuto nell'acronimo "MVC" centinaia di volte, se non di più. MVC è oggi uno dei modelli di design più discussi nel mondo della programmazione web, e giustamente. In questo articolo, ti condurremo attraverso il mondo dell'architettura MVC. Parleremo delle basi di MVC, dei suoi vantaggi e, infine, di un semplice codice che ti aiuterà a comprendere l'implementazione di MVC in Java in modo più chiaro.

Sommario

Qual è esattamente l'architettura MVC?

Prima di entrare nei dettagli tecnici, chiariamo alcune cose: MVC NON è un modello di progettazione, è un modo per strutturare le tue applicazioni. Negli ultimi anni, le applicazioni Web utilizzano ampiamente l'architettura MVC, quindi è naturale confonderla con un design pattern esclusivo per le applicazioni Web. Tuttavia, diciamo che MVC è stato descritto per la prima volta nel lontano 1979, prima dell'era del WWW, quando non esisteva il concetto di applicazioni web. L'architettura utilizzata oggi per le applicazioni web è un adattamento del modello originale.
In effetti, questa architettura è stata inizialmente inclusa nei due principali framework di sviluppo web: Struts e Ruby on Rails. Questi due ambienti hanno aperto la strada alla maggior parte dei framework Web successivi, e quindi la popolarità di questa architettura ha continuato a crescere.

Impara a creare applicazioni come Swiggy, Quora, IMDB e altro

Il modello architettonico MVC segue un'idea elementare: dobbiamo separare le responsabilità in qualsiasi applicazione sulla base seguente:

  • Modello: gestisce i dati e la logica aziendale.
  • Visualizza: presenta i dati all'utente quando richiesto.
  • Controller: intrattiene le richieste degli utenti e recupera le risorse necessarie.

Ciascuno dei componenti ha una serie delimitata di attività che garantisce il buon funzionamento dell'intera applicazione insieme alla completa modularità. Diamo un'occhiata a ciascuno di questi componenti in modo più dettagliato.

Controllore

Il controller è come il gestore dell'applicazione: esegue il coordinamento tra il modello e la vista per intrattenere una richiesta dell'utente. Le richieste dell'utente vengono ricevute come richiesta HTTP get o post, ad esempio, quando l'utente fa clic su qualsiasi elemento della GUI per eseguire qualsiasi azione.
La funzione principale di un controller è chiamare e coordinarsi con il modello per recuperare tutte le risorse necessarie per agire. Di solito, alla ricezione di una richiesta dell'utente, il controller chiama il modello appropriato per l'attività in questione.

Modello

Il modello è semplicemente i dati per la nostra applicazione. I dati sono "modellati" in modo che siano facili da archiviare, recuperare e modificare. Il modello è il modo in cui applichiamo le regole ai nostri dati, che alla fine rappresentano i concetti gestiti dalla nostra applicazione.
Per qualsiasi applicazione software, tutto è modellato come dati che possono essere gestiti facilmente. Che cos'è un utente, un libro o un messaggio per un'app? Niente di veramente, solo dati che devono essere trattati secondo regole specifiche. Ad esempio, la data non deve essere superiore alla data corrente, l'e-mail deve essere nel formato corretto, il nome non deve contenere più di "x" caratteri, ecc.

Ogni volta che un utente fa una richiesta al titolare, contatta il modello appropriato che restituisce una rappresentazione dei dati di ciò che l'utente ha richiesto. Questo modello sarà lo stesso per un particolare lavoro, indipendentemente da come desideriamo mostrarlo all'utente. Ecco perché possiamo scegliere qualsiasi vista disponibile per il rendering dei dati del modello.
Inoltre, un modello contiene anche la logica per aggiornare il controller pertinente ogni volta che si verifica un cambiamento nei dati del modello.

Visualizzazione

Come suggerisce il nome, la vista è responsabile del rendering dei dati ricevuti dal modello. Potrebbero esserci modelli pre-progettati in cui è possibile adattare i dati e potrebbero esserci anche diverse viste per modello a seconda dei requisiti.

Qualsiasi applicazione web è strutturata tenendo presenti questi tre componenti fondamentali. Potrebbe esserci un controller primario che è responsabile della ricezione di tutte le richieste e della chiamata del controller specifico per azioni specifiche. Comprendiamo meglio il funzionamento di un'applicazione web sotto l'architettura MVC usando un esempio.

Vediamo un esempio

Facciamo un esempio di una cartoleria online. L'utente può visualizzare articoli, acquistare, aggiungere articoli al carrello, aggiungere articoli all'ordine corrente o persino aggiungere/rimuovere articoli (se è l'amministratore).
Ora, vediamo cosa accadrà quando un utente fa clic sul titolo "Penne" per visualizzare l'elenco delle penne.
La nostra applicazione avrà un controller particolare per gestire tutte le domande relative alle penne. Diciamo che si chiama “pens_controller.php”. Avremo anche un modello che memorizzerà i dati relativi alle penne che abbiamo – chiamiamolo “pens_model.php”. Infine, avremo diverse viste per presentare i dati: un elenco di penne, una tabella che mostra le penne, una pagina per modificare l'elenco, ecc.
La figura seguente mostra il flusso di controllo completo dal momento in cui un utente fa clic su "penne", fino a quando il risultato viene visualizzato davanti a lui:

Innanzitutto, "pens_controller.php" gestisce la richiesta dell'utente (1) come richiesta GET o POST. Possiamo anche avere un "index.php" che è il controller centrale che chiamerà "pens_controller" ogni volta che sarà necessario.
Il controller esamina quindi la richiesta ei parametri e chiama il modello richiesto, in questo caso "pens_model.php". Il controller chiede al modello di restituire l'elenco delle penne disponibili (2).
A questo punto, il modello ricerca nel database le informazioni necessarie (3), applica la logica se necessario e restituisce i dati al controllore(4).
Il controller quindi seleziona una vista appropriata (5) e presenta i dati (6 e 7). Se una richiesta proviene da un dispositivo palmare, verrà utilizzata una vista adatta o se l'utente ha selezionato un tema particolare, verrà selezionata la sua vista e così via.
Come diventare uno sviluppatore full stack

I vantaggi dell'architettura MVC

Un problema comune affrontato dagli sviluppatori di applicazioni in questi giorni è il supporto per diversi tipi di dispositivi. L'architettura MVC risolve questo problema poiché gli sviluppatori possono creare interfacce diverse per dispositivi diversi e, in base al dispositivo da cui viene effettuata la richiesta, il controller selezionerà una vista appropriata. Il modello invia gli stessi dati indipendentemente dal dispositivo utilizzato, il che garantisce una coerenza completa su tutti i dispositivi.
La separazione MVC isola magnificamente la vista dalla logica aziendale. Riduce inoltre le complessità nella progettazione di applicazioni di grandi dimensioni mantenendo strutturati il ​​codice e il flusso di lavoro. Ciò semplifica notevolmente la manutenzione, il test, il debug e il riutilizzo del codice generale.

Una semplice implementazione di MVC utilizzando Java

Avremo i seguenti tre:

    1. StudentObject : il modello.

    1. StudentView: visualizza la classe per stampare i dettagli sulla console.

  1. StudentController: un controller che memorizza i dati in studentObject e aggiorna StudentView di conseguenza

Passaggio 1: crea il modello

 studente di classe pubblica {
   private String rollNo ;
   nome stringa privato ;
   
   public String getRollNo () {
      rotolo di ritorno n .;
   }
   
   public void setRollNo ( String rollNo ) {
      questo . rollNo = rollNo ;
   }
   
   public String getName () {
      nome restituito ;
   }
   
   public void setName ( nome stringa ) {
      questo . nome = nome ;
   }
}

Il codice è autoesplicativo. Consiste in funzioni per ottenere/impostare il numero del rotolo e i nomi degli studenti. Chiamiamolo “student.java”.
Passaggio 2: crea la vista

 classe pubblica StudentView {
   public void printStudentDetails ( String studentName , String studentRollNo ){
      Sistema . fuori . println ( "Studente: " );
      Sistema . fuori . println ( "Nome: " + nomestudente );
      Sistema . fuori . println ( "Roll No: " + studentRollNo );
   }
}

Questo serve semplicemente per stampare i valori sulla console. Chiamiamo questo "studentView.java".
Passaggio 3: crea il controller

 StudentController di classe pubblica {
   modello Studente privato ;
   vista StudentView privata ;
   public StudentController ( Modello Studente , Vista StudentView ){
      questo . modello = modello ;
      questo . vista = vista ;
   }
   public void setStudentName ( nome stringa ){
modello . setName ( nome );
   }
   public String getStudentName (){
      modello di ritorno . getName ();
   }
   public void setStudentRollNo ( String rollNo ){
modello . setRollNo ( rollNo );
   }
   public String getStudentRollNo (){
      modello di ritorno . getRollNo ();
   }
   public void updateView (){
vista . printStudentDetails ( modello . getName (), modello . getRollNo ());
   }
}

Chiamalo "StudentController.java". Uno sguardo superficiale ti dirà che questo controller è solo responsabile di chiamare il modello per ottenere/impostare i dati e quindi aggiornare la vista.
Ora, diamo un'occhiata a come tutto questo è legato insieme.
Passaggio 4: crea il file Java principale

 classe pubblica MVCPatternDemo {
   public static void main ( String [] args ) {
      //preleva il record dello studente in base al suo numero di matricola dal database
      Modello studente = retriveStudentFromDatabase ();
      //Crea una vista: per scrivere i dettagli degli studenti sulla console
      Vista StudentView = nuova Vista Studente ();
      StudentController controller = nuovo StudentController ( modello , vista );
controllore . updateView ();
      //aggiorna i dati del modello
controllore . setStudentName ( "Giovanni" );
controllore . updateView ();
   }
   Studente statico privato retriveStudentFromDatabase (){
      Studente studente = nuovo Studente ();
studente . setName ( "Robert" );
studente . setRollNo ( "10" );
      studente di ritorno ;
   }
}

Questo si chiama "MVCPatternDemo.java". Come puoi vedere, recupera i dati dello studente dal database o da una funzione (in questo caso stiamo usando una funzione per impostare i valori) e li inserisce nel modello Studente. Quindi, inizializza la vista che avevamo creato in precedenza.
Inoltre, inizializza anche il nostro controller e lo lega al modello e alla vista. Il metodo updateView() è una parte del controller che aggiorna i dettagli dello studente sulla console.
Passaggio 5: verifica il risultato
Se tutto va bene, il risultato dovrebbe essere: 

 Alunno:
Nome: Roberto
Rotolo n.: 10
Alunno:
Nome: Giovanni
Rotolo n.: 10

Se ottieni questo come output, congratulazioni! Hai implementato con successo l'architettura MVC utilizzando Java, anche se per una semplice applicazione. Per quanto semplice, questa applicazione è sufficiente per dimostrare i poteri dell'architettura MVC.
15 Domande da conoscere per l'intervista MVC di primavera

Avvolgendo…
Dopo tanto detto e fatto, è difficile enfatizzare di più la potenza dell'architettura MVC in qualsiasi applicazione web/desktop in questi giorni. Fornisce un livello completamente nuovo di modularità al codice che lo rende molto più leggibile e manutenibile. Quindi, se vuoi scalare a nuove vette nella tua carriera come sviluppatore di applicazioni, ottenere l'architettura MVC e il suo funzionamento dovrebbe essere la tua massima priorità.

Iscriviti ai corsi di ingegneria del software dalle migliori università del mondo. Guadagna programmi Executive PG, programmi di certificazione avanzati o programmi di master per accelerare la tua carriera.

Lascia un commento e facci sapere come ti piace questo articolo!

Diventa uno sviluppatore full stack

Diploma PG di UpGrad e IIIT-Bangalore in sviluppo software
Richiedi ora un Master in Ingegneria del Software