Detaillierter Prozess zum Erstellen einer SpringMVC-Umgebung

Dieser Artikel stellt Ihnen den detaillierten Prozess zum Aufbau der SpringMVC-Umgebung vor. Er hat einen gewissen Referenzwert. Ich hoffe, er wird Ihnen hilfreich sein.

Spring MVC bietet ein hervorragendes Web-Framework, das auf dem MVC-Designkonzept für die Präsentationsschicht basiert. Es ist derzeit eines der gängigsten MVC-Frameworks.

Nach Spring 3.0 hat es Struts2 vollständig übertroffen und wird als das beste MVC-Framework bezeichnet. Nachdem Sie SpringMVC gelernt haben, werden Sie sofort die Grausamkeit spüren, die Struts2 mit sich bringt.

Spring MVC verwendet eine Reihe von MVC-Anmerkungen, um POJO zu einem Controller für die Verarbeitung von Anforderungen zu machen. Es besteht keine Notwendigkeit, eine Schnittstelle zu implementieren, und der Kopplungsgrad ist gering.

Und Spring MVC bietet eine gute Unterstützung für den Ruhestil. .

Nutzt eine lose gekoppelte, steckbare Komponentenstruktur, die erweiterbarer und flexibler ist als andere MVC-Frameworks.

Erstellen Sie eine Spring MVC-Umgebung

1) Erstellen Sie eine MVC-Umgebung basierend auf der Schnittstellenmethode. Implementieren Sie die Controller-Schnittstelle, um MVC zu implementieren

2) Basierend auf der Annotationsmethode vereinfacht die Verwendung von Annotationen in Spring 3.0 und späteren Versionen die herkömmliche MVC-Konfiguration erheblich und die Flexibilität und Wartbarkeit werden erheblich verbessert.

Um SpringMVC zu implementieren, besteht der erste Schritt darin, das entsprechende JAR-Paket zu importieren

Dann ist es mit Struts2 auch so Konfigurieren Sie einen Kerncontroller in Web.xml. Wird zum Abfangen von Anfragen verwendet.

<!-- 配置SpringMVC的请求的Servlet -->
  <servlet>
          <servlet-name>DispatcherServlet</servlet-name>
              <servlet-class>
                  org.springframework.web.servlet.DispatcherServlet
            </servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
 </servlet>
  <servlet-mapping>
      <servlet-name>DispatcherServlet</servlet-name>
      <url-pattern>/</url-pattern>
  </servlet-mapping>

Fühlen Sie sich vertraut, wenn Sie das sehen? Es sind nur ein paar Zeilen mehr als Struts2. init-param ist die Spring-Datei, die während der Initialisierung geladen werden soll. Wenn mehrere Dateien vorhanden sind, können Sie sie durch Kommas trennen.

load-on-startup wird sofort beim Start geladen. /Alle Anfragen abfangen. (Gleichzeitig werden auch CSS und JS abgefangen);

Dann schreiben wir einen Controller

package com.miya.spring.mvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/Miya")
public class MiyaHelloController {

    @RequestMapping("/hello")
    public String hello(){
        System.out.println("hello Miya");
        return "/hello";
    }
}

@Controller Diese Anmerkung erfordert nicht viel. Sagen Sie, deklarieren Sie einen Controller.

@RequestMapping wird in der Klasse definiert, um ein Leerzeichen zu deklarieren. Deklarieren Sie über der Methode einen Anforderungspfad

und geben Sie eine Zeichenfolge zurück. Wo ist der Pfad, auf den Sie zugreifen möchten?

<context:component-scan base-package="com.miya.spring.mvc"/>
    
    <!-- 视图解析器 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/views"/>
        <!-- 后缀 -->
        <property name="suffix" value=".jsp"/>
    </bean>

In unserer Spring XML-Konfiguration scannen wir zunächst alle Annotationen und konfigurieren dann einen Ansichtsparser.

Wenn wir dieses „Hallo“ zurückgeben, ist es Präfix + Ergebnis(Hallo) +Suffix, um auf unsere Ansicht zuzugreifen.

Jetzt versuchen wir es direkt in index.jsp auszuführen.

<%
response.sendRedirect(request.getContextPath() + "/Miya/hello");    
%>

request.getContextPath() ruft den Stammpfad Ihres Webprojekts ab, nämlich webContent (webRoot in MyEclipse). Dann können Sie jetzt unseren Namespace Miya sehen, gefolgt von dem darin definierten Methodenanforderungspfad

hello. Die Adresse, die wir schließlich besucht haben: http://localhost:8080/SpringMvcDemo1/Miya/hello, hat auf die Datei WEB-INF/views/hello.jsp zugegriffen. Und diese Anfrage ist immer noch eine Rest-Style-Anfrage.

Wenn Sie hier ankommen, werden Sie feststellen, dass es viel praktischer ist als Struts2. Für jede Konfigurationsanfrage in Struts2 müssen Sie viele Aktionen in Struts2 konfigurieren, und manchmal enthält die Sturts-Datei Tausende von Zeilen , und Sie sind zu alt, um einen zu finden. Die Anfrage dauerte eine halbe Stunde.

Eine andere Möglichkeit, dies zu implementieren, besteht darin, die von Spring bereitgestellte Controller-Schnittstelle zu implementieren und die Methoden in der Schnittstelle neu zu schreiben.

package com.miya.spring.mvc.controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
public class MiyaWordController implements Controller{
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("/hello");
        return modelAndView;
    }
}

Sie können die Ansicht in ModelAndView festlegen. Dann müssen wir eine Bean in Spring XML konfigurieren. Name ist der Anforderungspfad, Klasse ist die angegebene Controller-Klasse

<bean name="/Miya/word" class="com.miya.spring.mvc.controller.MiyaWordController"></bean>

Hinweis: Wir haben alle Anforderungen im Projekt abgefangen, was zu Bildern, Stilen und JS für alle führt Bericht 404. Wir können im Frühjahr fertig sein Externe Ressourcendateien werden in XML eingeführt, und diese Art der Schnittstellenimplementierung führt zu einer zu hohen Kopplung, und jede Funktion muss in einer Klasse geschrieben werden, wodurch unser Code aufgebläht wird. Daher wird die Verwendung von Anmerkungen derzeit sehr empfohlen Beliebt und viele Frameworks unterstützen Annotationsmethoden, und die Syntax ist einfach, was den Code prägnant macht.

<!-- 引入外部样式 -->
<mvc:resources location="/css/" mapping="/css/**"></mvc:resources>

Das obige ist der detaillierte Inhalt vonDetaillierter Prozess zum Erstellen einer SpringMVC-Umgebung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!