Spring - przegląd struktury MVC

Framework Spring Web MVC zapewnia architekturę model-widok-kontroler i gotowe komponenty, których można używać do tworzenia elastycznych i luźno powiązanych aplikacji internetowych. Wzorzec MVC powoduje oddzielenie różnych aspektów aplikacji (logika wejściowa, logika biznesowa i logika interfejsu użytkownika), zapewniając jednocześnie luźne sprzężenie między tymi elementami.

  • Plik Model hermetyzuje dane aplikacji i ogólnie będą składać się z POJO.

  • Plik View odpowiada za renderowanie danych modelu i generalnie generuje HTML dane wyjściowe, które przeglądarka klienta może zinterpretować.

  • Plik Controller odpowiada za przetwarzanie User Requests i Building Appropriate Model i przekazuje go do widoku w celu renderowania.

DispatcherServlet

Struktura modelu Spring Web kontrolera widoku (MVC) została zaprojektowana wokół DispatcherServlet, który obsługuje wszystkie żądania i odpowiedzi HTTP. Na poniższej ilustracji przedstawiono przepływ pracy przetwarzania żądań w Spring Web MVC DispatcherServlet.

Poniżej znajduje się sekwencja zdarzeń odpowiadająca przychodzącemu żądaniu HTTP do DispatcherServlet -

  • Po otrzymaniu żądania HTTP DispatcherServlet sprawdza plik HandlerMapping zadzwonić do odpowiedniego Kontrolera.

  • Administrator przyjmuje żądanie i wywołuje odpowiednie metody obsługi na podstawie wykorzystanych GET lub POST method. Metoda usługi ustawi dane modelu w oparciu o zdefiniowaną logikę biznesową i zwróci nazwę widoku do DispatcherServlet.

  • DispatcherServlet będzie korzystał z pomocy ViewResolver aby odebrać zdefiniowany widok dla żądania.

  • Po sfinalizowaniu widoku DispatcherServlet przekazuje dane modelu do widoku, który jest ostatecznie renderowany w przeglądarkach.

Wszystkie wyżej wymienione komponenty, tj. HandlerMapping, Controller i ViewResolver są częścią WebApplicationContext, która jest przedłużeniem równiny ApplicationContext z kilkoma dodatkowymi funkcjami niezbędnymi dla aplikacji internetowych.

Wymagana konfiguracja

Musimy zmapować żądania, które mają obsługiwać DispatcherServlet, przy użyciu mapowania adresu URL w web.xmlplik. Poniżej znajduje się przykład pokazujący deklarację i mapowanieHelloWeb 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>

Plik web.xml plik zostanie zachowany w formacie WebContent/WEB-INFkatalogu Twojej aplikacji internetowej. Po zainicjowaniuHelloWeb DispatcherServlet, framework spróbuje załadować kontekst aplikacji z pliku o nazwie [servlet-name]-servlet.xmlznajduje się w katalogu WebContent / WEB-INF aplikacji. W tym przypadku nasz plik będzieHelloWeb-servlet.xml.

Następnie <servlet-mapping>tag wskazuje, które adresy URL będą obsługiwane przez który DispatcherServlet. Tutaj wszystkie żądania HTTP kończące się na .jsp będą obsługiwane przezHelloWeb DispatcherServlet.

Jeśli nie chcesz używać domyślnej nazwy pliku jako [servlet-name]-servlet.xml i domyślną lokalizację jako WebContent / WEB-INF, możesz dostosować tę nazwę pliku i lokalizację, dodając nasłuchiwanie serwletów ContextLoaderListener w pliku web.xml w następujący sposób -

<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>

Teraz sprawdźmy wymaganą konfigurację HelloWeb-servlet.xml plik umieszczony w katalogu WebContent / WEB-INF aplikacji internetowej.

<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>

Poniżej przedstawiono kilka ważnych kwestii HelloWeb-servlet.xml plik -

  • Plik [servlet-name]-servlet.xml Plik zostanie użyty do stworzenia zdefiniowanych komponentów bean, przesłaniając definicje wszystkich beanów zdefiniowanych o tej samej nazwie w zasięgu globalnym.

  • Plik <context:component-scan...> tag zostanie użyty do aktywacji funkcji skanowania adnotacji Spring MVC, która pozwala na użycie adnotacji takich jak @Controller i @RequestMappingitp.

  • Plik InternalResourceViewResolverbędzie mieć zdefiniowane reguły rozwiązywania nazw widoków. Zgodnie z powyższą regułą, logiczny widok nazwanyhello jest delegowany do implementacji widoku znajdującej się pod adresem /WEB-INF/jsp/hello.jsp.

Zrozummy teraz, jak tworzyć rzeczywiste komponenty, tj. Kontroler, model i widok.

Definiowanie kontrolera

Serwlet DispatcherServlet deleguje żądanie do kontrolerów w celu wykonania specyficznej dla niego funkcjonalności. Plik@Controlleradnotacja wskazuje, że dana klasa pełni rolę kontrolera. Plik@RequestMapping adnotacja służy do mapowania adresu URL na całą klasę lub konkretną metodę obsługi.

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

}

Plik @Controlleradnotacja definiuje klasę jako kontroler Spring MVC. Tutaj pierwsze użycie@RequestMapping wskazuje, że wszystkie metody obsługi na tym kontrolerze są względne w stosunku do /hello ścieżka.

Następna adnotacja @RequestMapping (method = RequestMethod.GET) służy do deklarowania printHello()metoda jako domyślna metoda obsługi kontrolera do obsługi żądania HTTP GET. Możemy zdefiniować inną metodę obsługi dowolnego żądania POST pod tym samym adresem URL.

Możemy również napisać powyższy kontroler w innej formie, gdzie możemy dodać dodatkowe atrybuty w @RequestMapping w następujący sposób -

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

}

Plik value atrybut wskazuje adres URL, na który mapowana jest metoda obsługi, a plik method atrybut definiuje metodę usługi do obsługi żądania HTTP GET.

Poniżej znajduje się kilka ważnych punktów, na które należy zwrócić uwagę w odniesieniu do kontrolera zdefiniowanego powyżej:

  • Zdefiniujesz wymaganą logikę biznesową w ramach metody usługi. Możesz wywołać inną metodę wewnątrz tej metody zgodnie z wymaganiami.

  • Na podstawie zdefiniowanej logiki biznesowej utworzysz model w ramach tej metody. Możesz ustawić różne atrybuty modelu, a widok będzie miał dostęp do tych atrybutów, aby przedstawić wynik. W tym przykładzie tworzony jest model z atrybutem „komunikat”.

  • Zdefiniowana metoda usługi może zwrócić ciąg, który zawiera nazwę pliku viewdo wykorzystania do renderowania modelu. Ten przykład zwraca „hello” jako nazwę widoku logicznego.

Tworzenie widoków JSP

Spring MVC obsługuje wiele typów widoków dla różnych technologii prezentacji. Obejmują one -JSPs, HTML, PDF, Excel Worksheets, XML, Velocity Templates, XSLT, JSON, Atom i RSS pasze, JasperReportsitp. Jednak najpopularniejsze są szablony JSP napisane w języku JSTL. Zatem napiszmy prosty widok hello w /WEB-INF/hello/hello.jsp -

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

Tutaj ${message}Oto atrybut, który ustawiliśmy w kontrolerze. W widoku może być wyświetlanych wiele atrybutów.