Primavera - MVC Framework

Il framework Spring Web MVC fornisce l'architettura Model-View-Controller (MVC) e componenti pronti che possono essere utilizzati per sviluppare applicazioni web flessibili e liberamente accoppiate. Il modello MVC consente di separare i diversi aspetti dell'applicazione (logica di input, logica di business e logica dell'interfaccia utente), fornendo al contempo un accoppiamento libero tra questi elementi.

Il Model incapsula i dati dell'applicazione e in generale saranno costituiti da POJO.
Il View è responsabile del rendering dei dati del modello e in generale genera output HTML che il browser del client può interpretare.
Il Controller è responsabile dell'elaborazione delle richieste degli utenti e della creazione di un modello appropriato e lo passa alla vista per il rendering.

Il DispatcherServlet

Il framework MVC (model-view-controller) di Spring Web è progettato attorno a un DispatcherServlet che gestisce tutte le richieste e le risposte HTTP. Il flusso di lavoro di elaborazione delle richieste di Spring Web MVC DispatcherServlet è illustrato nel diagramma seguente:

Di seguito è riportata la sequenza di eventi corrispondenti a una richiesta HTTP in arrivo a DispatcherServlet -

Dopo aver ricevuto una richiesta HTTP, DispatcherServlet consulta HandlerMapping per chiamare il controller appropriato .
Il Controller accetta la richiesta e chiama i metodi di servizio appropriati in base al metodo GET o POST utilizzato. Il metodo del servizio imposterà i dati del modello in base alla logica aziendale definita e restituirà il nome della vista a DispatcherServlet .
Il DispatcherServlet richiederà l'aiuto di ViewResolver per prelevare la vista definita per la richiesta.
Una volta finalizzata la visualizzazione, DispatcherServlet passa i dati del modello alla vista che viene infine visualizzata nel browser.

Tutti i componenti sopra menzionati, cioè HandlerMapping, Controller e ViewResolver sono parti di WebApplicationContext w che è un'estensione del semplice ApplicationContext con alcune funzionalità extra necessarie per le applicazioni web.

Configurazione richiesta

È necessario mappare le richieste che si desidera vengano gestite da DispatcherServlet , utilizzando una mappatura URL inweb.xmlfile. Il seguente è un esempio per mostrare la dichiarazione e la mappaturaHelloWeb Esempio di DispatcherServlet -

<web-app id = "WebApp_ID" version = "2.4"
   xmlns = "http://java.sun.com/xml/ns/j2ee" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/j2ee 
   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    
   <display-name>Spring MVC Application</display-name>
   
   <servlet>
      <servlet-name>HelloWeb</servlet-name>
      <servlet-class>
         org.springframework.web.servlet.DispatcherServlet
      </servlet-class>
      <load-on-startup>1</load-on-startup>
   </servlet>

   <servlet-mapping>
      <servlet-name>HelloWeb</servlet-name>
      <url-pattern>*.jsp</url-pattern>
   </servlet-mapping>

</web-app>

Il web.xmlIl file verrà conservato nella directory WebContent / WEB-INF della tua applicazione web. Dopo l'inizializzazione diHelloWeb DispatcherServlet, il framework tenterà di caricare il contesto dell'applicazione da un file denominato [servlet-name]-servlet.xmlsi trova nella directory WebContent / WEB-INF dell'applicazione. In questo caso, il nostro file saràHelloWebservlet.xml.

Successivamente, il tag <servlet-mapping> indica quali URL verranno gestiti da quale DispatcherServlet. Qui tutte le richieste HTTP che terminano con.jsp sarà gestito da HelloWeb DispatcherServlet.

Se non si desidera utilizzare il nome file predefinito come [nome-servlet] -servlet.xml e il percorso predefinito come WebContent / WEB-INF , è possibile personalizzare questo nome e posizione del file aggiungendo il listener servlet ContextLoaderListener nel file web.xml come segue -

<web-app...>

   <!-------- DispatcherServlet definition goes here----->
   ....
   <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/HelloWeb-servlet.xml</param-value>
   </context-param>

   <listener>
      <listener-class>
         org.springframework.web.context.ContextLoaderListener
      </listener-class>
   </listener>
   
</web-app>

Ora, controlliamo la configurazione richiesta per HelloWeb-servlet.xmlfile, posizionato nella directory WebContent / WEB-INF della tua applicazione web -

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans     
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:component-scan base-package = "com.tutorialspoint" />

   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/" />
      <property name = "suffix" value = ".jsp" />
   </bean>

</beans>

Di seguito sono riportati i punti importanti su HelloWeb-servlet.xml file -

Il file [nome-servlet] -servlet.xml verrà utilizzato per creare i bean definiti, sovrascrivendo le definizioni di qualsiasi bean definito con lo stesso nome nell'ambito globale.
Il tag <context: component-scan ...> verrà utilizzato per attivare la capacità di scansione delle annotazioni Spring MVC che consente di utilizzare annotazioni come @Controller e @RequestMapping ecc.
L'InternalResourceViewResolver avrà regole definite per risolvere i nomi delle viste. Secondo la regola sopra definita, una vista logica denominatahelloè delegato a un'implementazione della vista situata in /WEB-INF/jsp/hello.jsp .

La sezione seguente ti mostrerà come creare i tuoi componenti effettivi, cioè Controller, Modello e Vista.

Definizione di un controller

Il DispatcherServlet delega la richiesta ai controller per eseguire la funzionalità specifica per esso. Il@Controllerl'annotazione indica che una particolare classe svolge il ruolo di controllore. Il@RequestMapping l'annotazione viene utilizzata per mappare un URL a un'intera classe o a un particolare metodo del gestore.

@Controller
@RequestMapping("/hello")
public class HelloController { 
   @RequestMapping(method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");
      return "hello";
   }
}

Il @Controllerl'annotazione definisce la classe come controller Spring MVC. Qui, il primo utilizzo di@RequestMapping indica che tutti i metodi di gestione su questo controller sono relativi a /hellosentiero. Annotazione successiva@RequestMapping(method = RequestMethod.GET)viene utilizzato per dichiarare il metodo theprintHello () come metodo di servizio predefinito del controller per gestire la richiesta HTTP GET. È possibile definire un altro metodo per gestire qualsiasi richiesta POST allo stesso URL.

Puoi scrivere il controller sopra in un'altra forma in cui puoi aggiungere attributi aggiuntivi in @RequestMapping come segue:

@Controller
public class HelloController {
   @RequestMapping(value = "/hello", method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");
      return "hello";
   }
}

Il value attributo indica l'URL a cui è mappato il metodo del gestore e il methodl'attributo definisce il metodo del servizio per gestire la richiesta HTTP GET. I seguenti punti importanti devono essere annotati sul controller sopra definito:

Definirai la logica aziendale richiesta all'interno di un metodo di servizio. Puoi chiamare un altro metodo all'interno di questo metodo secondo i requisiti.
In base alla logica di business definita, creerai un modello all'interno di questo metodo. È possibile utilizzare diversi attributi del modello setter e questi attributi saranno accessibili dalla vista per presentare il risultato finale. Questo esempio crea un modello con il suo attributo "messaggio".
Un metodo di servizio definito può restituire una stringa, che contiene il nome di viewda utilizzare per il rendering del modello. Questo esempio restituisce "ciao" come nome della vista logica.

Creazione di viste JSP

Spring MVC supporta molti tipi di visualizzazioni per diverse tecnologie di presentazione. Questi includono: JSP, HTML, PDF, fogli di lavoro Excel, XML, modelli Velocity, XSLT, JSON, Atom e feed RSS, JasperReports, ecc. Ma più comunemente usiamo modelli JSP scritti con JSTL.

Scriviamo un semplice hello visualizza in /WEB-INF/hello/hello.jsp -

<html>
   <head>
      <title>Hello Spring MVC</title>
   </head>
   
   <body>
      <h2>${message}</h2>
   </body>
</html>

Qui ${message}è l'attributo che abbiamo impostato all'interno del Controller. Puoi avere più attributi da visualizzare nella tua vista.

Esempi di framework Spring Web MVC

Sulla base dei concetti di cui sopra, controlliamo alcuni esempi importanti che ti aiuteranno a costruire le tue applicazioni Web Spring -

Sr.No.	Esempio e descrizione
1	Esempio Spring MVC Hello World Questo esempio spiegherà come scrivere una semplice applicazione Spring Web Hello World.
2	Esempio di gestione dei moduli Spring MVC Questo esempio spiega come scrivere un'applicazione Web Spring utilizzando moduli HTML per inviare i dati al controller e visualizzare un risultato elaborato.
3	Esempio di reindirizzamento della pagina Spring Scopri come utilizzare la funzionalità di reindirizzamento delle pagine in Spring MVC Framework.
4	Esempio di pagine statiche di primavera Scopri come accedere a pagine statiche insieme a pagine dinamiche in Spring MVC Framework.
5	Esempio di gestione delle eccezioni di primavera Scopri come gestire le eccezioni in Spring MVC Framework.