Spring - Panoramica di MVC Framework

Il framework Spring Web MVC fornisce un'architettura model-view-controller e componenti pronti che possono essere utilizzati per sviluppare applicazioni web flessibili e liberamente accoppiate. Il pattern 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 HTML output che il browser del client può interpretare.

• Il Controller è responsabile del trattamento User Requests e Building Appropriate Model 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 è mostrato nella figura 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 il file HandlerMapping per chiamare il controller appropriato.

• Il Titolare accetta la richiesta e chiama i metodi di servizio appropriati in base a quelli utilizzati GET o POST method. 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à aiuto da ViewResolver per prendere la vista definita per la richiesta.

• Una volta finalizzata la visualizzazione, DispatcherServlet passa i dati del modello alla visualizzazione, che viene infine visualizzata sui browser.

Tutti i componenti sopra menzionati, cioè HandlerMapping, Controller e ViewResolver fanno parte di WebApplicationContext, che è un'estensione della pianura 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 in web.xmlfile. Quello che segue è un esempio per mostrare la dichiarazione e la mappaturaHelloWeb 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.xml il file verrà conservato nel file WebContent/WEB-INFdirectory 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àHelloWeb-servlet.xml.

Successivamente, il <servlet-mapping>tag indica quali URL verranno gestiti da quale DispatcherServlet. Qui, tutte le richieste HTTP che terminano con .jsp saranno gestite dalHelloWeb DispatcherServlet.

Se non si desidera utilizzare il nome file predefinito come [servlet-name]-servlet.xml e posizione predefinita come WebContent / WEB-INF, è possibile personalizzare questo nome file e posizione aggiungendo il listener servlet ContextLoaderListener nel tuo 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.xml file, posizionato nella directory WebContent / WEB-INF dell'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 alcuni punti importanti su HelloWeb-servlet.xml file -

• Il [servlet-name]-servlet.xml verrà utilizzato per creare i bean definiti, sovrascrivendo le definizioni di tutti i bean definiti con lo stesso nome nell'ambito globale.

• Il <context:component-scan...> verrà utilizzato per attivare la capacità di scansione delle annotazioni Spring MVC, che consente di utilizzare annotazioni come @Controller e @RequestMapping, eccetera.

• Il InternalResourceViewResolveravrà 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.

Vediamo ora come creare i componenti effettivi, ovvero Controller, Model e View.

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 /hello sentiero.

La prossima annotazione @RequestMapping (method = RequestMethod.GET) viene utilizzato per dichiarare il file printHello()come metodo di servizio predefinito del controller per gestire la richiesta HTTP GET. Possiamo definire un altro metodo per gestire qualsiasi richiesta POST allo stesso URL.

Possiamo anche scrivere il controller sopra in un'altra forma, dove possiamo 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 method l'attributo definisce il metodo del servizio per gestire la richiesta HTTP GET.

Di seguito sono riportati alcuni punti importanti da notare riguardo al titolare del trattamento sopra definito:

• Definirai la logica aziendale richiesta all'interno di un metodo di servizio. È possibile chiamare un altro metodo all'interno di questo metodo secondo il requisito.

• In base alla logica di business definita, creerai un modello all'interno di questo metodo. È possibile impostare diversi attributi del modello e questi attributi saranno accessibili dalla vista per presentare il risultato. 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 -JSPs, HTML, PDF, Excel Worksheets, XML, Velocity Templates, XSLT, JSON, Atom e RSS feed, JasperReports, ecc. Tuttavia, i più comuni sono i modelli JSP scritti con JSTL. Quindi, scriviamo una semplice visualizzazione ciao in /WEB-INF/hello/hello.jsp -

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

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