Ein einfaches Tutorial zum Einstieg
Der Quellcode dieser Instanz und das Glas in der Instanz
Quellcode: http://xiazai.vevb.com/201612/yuanma/springmvc_jb51.zip
Erforderliches JAR: http://xiazai.vevb.com/201612/yuanma/springmvcjar_jb51.zip
Ein weiterer Artikel über SpringMVC-Datei-Upload, Multi-File Upload: //www.vevb.com/article/100491.htm
Beispiele für einfache Annotationskonfiguration:
1. Erstellen Sie ein Projekt:
1. Erstellen Sie ein neues dynamisches Webprojekt:
2. Nennen Sie das Projekt: SpringMVC_01
3. Fügen Sie Tomcat Runtime Environment/Abhängigkeitsbibliothek hinzu. Wenn es sich um myeClipse handelt, ist dieser Schritt beim Erstellen eines Webprojekts nicht erforderlich.
Klicken Sie mit der rechten Maustaste auf das Projekt und klicken Sie auf Erstellen Sie Pfad-> Bibliothek hinzufügen:
Nach dem Hinzufügen gibt es zusätzliche Tomcat -Servlet -Pakete
4. Fügen Sie schließlich die für Frühlings- und Springmvc erforderlichen Gläser hinzu, und ich füge das Projekt die folgenden Gläser hinzu
2. Konfigurationsdatei:
1. Konfigurieren Sie zuerst einen DispatcherServlet in web.xml und geben Sie die URL an, die über <Servlet-Mapping> abgefangen werden muss. Die folgende XML konfiguriert eine Abfangen -URL mit Suffixed.html.
<!-Konfigurieren Sie Spring MVC-DispatcherServlet-> <servlet> <servlet-name> mvc </servlet-name> <Servlet-Klasse> org.springframework.web.Servlet.DispatcherServlet </Servlet-Class> <! <Param-name> contextconfigLocation </param-name> <param-value> /web-inf/classes/mvc* <servlet-name> mvc </servlet-name> <URL-Muster>*
Konfigurieren Sie zuerst ein Servlet und laden Sie dann die SpringMVC XML -Datei in den Federkontext. Konfigurieren Sie dann Servlet-Mapping, Servlet-Name ist der konfigurierte Name im Servlet und geben Sie dann an, dass die zu abgefangene URL *.html ist
2. Konfigurieren Sie den Kontext -Listener von Spring und geben Sie den Pfad zur XML -Konfigurationsdatei von Spring an.
<!-Hören Sie sich den Spring Context Container an-> <Hörer> <Hörer-Klasse> org.springFramework.web.Context.ContextloaderListener </Listener-Class> </Listener> <!-Laden Sie die Spring XML-Konfigurationsdatei in den Frühlingskontext-Container-<context-Param> <param-name> </param-name> </param> <param-name> <param-value> classPath: root-context.xml </param-value> </context-param>
Der hier angegebene Pfad -Klassenpfad befindet sich in der Klassenpfaddatei, nachdem das Projekt zusammengestellt wurde.
Endgültige Web.xml -Dateiinhalt:
<? XSI: scheMalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app-/dopp-/dopp-/dopp-nam/dopp-nam/dopp-nam/dopp-nam/dopp-nam/dopp-d.-d.-d.-d. Listener> <Hörer-Klasse> org.springframework.web.context.contextloaderListener </Listener-Klasse> </Listener> <!-Laden der Spring XML-Konfigurationsdatei in den Spring Context Container-> <context-param <param-value> classPath: root-context.xml </param-value> </context-param> <!-Konfigurieren Sie Spring MVC-DispatcherServlet-> <Servlet> <Servlet-name> mvc </servlet-name> <Servlet-Class> org.springFrame.Web.Web.Servlet. <init-param> <!-- Load the SpringMVC xml into the spring context container --> <param-name>contextConfigLocation</param-name> <param-value> /WEB-INF/classes/mvc*.* </param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <!-- The url that needs to be intercepted Durch Konfigurieren des Dispatcherservlets-> <Servlet-Mapping> <servlet-name> mvc </servlet-name> <URL-PATTERN>*.
3. Erstellen Sie die XML -Datei, die für SpringMVC und die XML -Datei von ApplicationContext erforderlich ist. Da das für Init-Param erforderliche Format im im ersten Schritt konfigurierten Servlet: mvc*.*. Es soll eine Datei finden, die mit MVC beginnt. Beim Erstellen der XML -Datei von SpringMVC muss ich mit MVC beginnen. Ich habe es benannt: MVC-context.xml und gemäß der Konfiguration in Context-Param die ApplicationContext-Datei: root-context.xml;
4. Konfigurieren Sie mvc-context.xml:
Importieren Sie zuerst Root-context.xml über das Import-Tag und scannen Sie dann den angegebenen Paketnamen über das Komponenten-Scan-Tag, um die Federannotation aller Java-Klassen unter dem Paket zu Wirkung zu erzielen.
Konfigurieren Sie dann die Ansicht von SpringMVC Rendering Parser, damit sein Präfix/Seite/und sein Suffix .JSP ist, damit die Pfade, die SpringMVC rendern müssen, in/page/return value.jsp gefunden werden können.
<!-Laden Sie die globale Konfigurationsdatei von Spring-> <beans: import ressourcen = "root-context.xml" /> <!-SpringMVC-Konfiguration-> <!-Lassen Sie Spring alle Klassen unter org.swingLife.controller über Komponenten-scan scannen, so dass die Frühlingscode-Annotationen wirksam werden-> <context: component-scan: component-scan Basis-Package = "org.swinglife.controller"> </context: component-scan> <!-Konfigurieren Sie die Ansicht von SpringMVC mit seinem Präfix als:/page/und dessen Suffix als .jsp rendern die Ansicht zu/page/<Methode Return-Wert> .jsp-<Beans: Bean Prefix = "/page/page/"/page/"p:" p: "p:" p: ".
Schließlich sind mvc-context.xml und root-context.xml:
mav-context.xml:
<? xmlns: beans = "http://www.springframework.org/schema/beans" xmlns: p = "http://www.springframework.org/schema/p" xmlns: aop = "http://www.spingframeWrate xmlns: context = "http://www.springframework.org/schema/context" xsi: schemalocation = "http://www.spingframework.org/schema/mvc/wwwwwwwwwwwwwwwwwwww.org/schema/mvc http://www.springframework.org/schema/aop http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- Load Spring's global configuration file --> <beans:import resource="root-context.xml" /> <!-- SpringMVC configuration --> <!-- Let SCRING Alle Klassen unter org.swinglife.controller über den Komponenten-Scan, um die Code-Annotationen von Spring zu ermöglichen-> <Kontext: Komponenten-scan-Basis-Package = "org.swinglife Rendern Sie die Ansicht in/page/<Methode Rückgabewert> .jsp-> <beans: bean p: prefix = "/page/" p: suffix = ". Jsp"> </beans: beans>
root-context.xml:
<? xmlns: context = "http://www.springframework.org/schema/context" xsi: schemalocation = "http://www.spingframework.org/schema/beans http://www.springframework http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-32.xsd http://www.spingframework.org/sschema/tx/tx/tx/tx/tx/tx/tx/tx/tx/tx/tx/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd "> <!-Root Context: Definiert freigegebene Ressourcen, die für alle anderen Webkomponenten sichtbar sind-> </beans>
3. Schreiben Sie Controller
1. Erstellen Sie org.swingLife.Controller -Paket, um die Controller -Klasse zu speichern, und erstellen Sie dann eine neue homecontroller.java, um den Controller auf der Homepage zu schreiben
2. Verwenden Sie die Annotation @Controller, um die HomeController -Klasse als Controller zu definieren, und verwenden Sie @RequestMapping ("Wert"), um den Pfad- oder Methodennamen zu geben, um in der Methode zugreifen zu können. SpringMVC kann ein Pojo in einen Controller umwandeln, der die Anfrage über eine @Controller -Annotation bearbeitet, und angeben, welche Anforderungen für den Controller über @RequestMapping erforderlich sind.
@Controller Public Class Homecontroller { /**** Homepage kehren Sie zu /page/home.jsp Seite zurück* @return* /@RequestMapping ("index") public modelAndView index () {// Modell erstellen und anzeigen, um die Seite zu rendern. Und geben Sie an, dass die zurückgegebene Seite das Homepage modelAndview mav = new ModelAndView ("Home") ist. MAV zurückgeben; }}Das ModelAndView -Objekt ist in der Methode definiert. Durch dieses Objekt wird die zu rendere Ansicht als Zuhause angegeben und gibt schließlich modelAndview zurück. Rendern Sie die Seite in Home.jsp.
3. Schließlich erstellen /page/home.jsp im Webcontent -Verzeichnis, damit SpringMVC die Seitenansicht finden und rendern kann.
<%@ page Language = "java" contentType = "text/html; charset = gb18030" pageCoding = "gb18030"%> <! docType html public "-// w3c // dtd html 4.01 transitional // en" " "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=GB18030"> <title>home</title> </head> <body> <h2>spring mvc instance</h2> </body> </html>
Jetzt wurde ein kompletter SpringMVC -Modus erstellt. Sie können das Projekt zum Testen ausführen.
4. Schreiben Sie die Einreichung und Lieferung von Parametern:
1. Schreiben Sie eine neue UserController -Klasse, um davon auszugehen, dass der Benutzer angemeldet ist. Senden Sie Benutzername und Passwort zur Verarbeitung an den Controller, und nach dem Anmelden werden der Benutzername und das Passwort an die erfolgreiche Seite übergeben.
Erstellen Sie UserController.java
Erstellen /page/succ.jsp als Benutzer erfolgreiche Anmeldeseite
Code in Usercontroller:
@Controller Public Class UserController { /**** Benutzeranmeldung* <P> Annotationskonfiguration, nur Beitrag darf diese Methode übermitteln. Die Anmeldeseite. if (this.checkParams (neuer String [] {Benutzername, Passwort})) {// Geben Sie die Seite an, die als Succ.jsp modelAndView mav = new ModelAndView ("Procc") zurückgegeben werden soll. // den Parameter an die Seite mav.addObject ("Benutzername", Benutzername) zurückgeben; mav.addObject ("Passwort", Passwort); MAV zurückgeben; } Neue modelAndView zurückgeben ("Home"); } / **** Überprüfen Sie, ob der Parameter leer ist }} return true; } Geben Sie zuerst @Controller an und geben Sie @RequestMapping als Anmeldemethode an.
Es ist zu beachten, dass der Seitenmethodenmodus in diesem Zeitpunkt in @RequestMapping angegeben ist, dass der Seitenmethodenmodus den Post -Modus sein muss, andernfalls ist er nicht zugänglich. Zweitens gibt der Wertparameter den Zugriffspfad an.
Und setzen Sie den Parameter in der Anmeldemethode, und der Parameter ist das Namensattribut im Formular.
Fügen Sie dann die Anforderung über die AddObject -Methode von ModelAndView Parameter hinzu, damit diese Parameter auf der zurückgegebenen Seite angezeigt werden können.
Zusätzlich dazu gibt es andere Möglichkeiten, Parameter in die Seite zu übergeben:
/**** Eine andere Form des Parameterüberlaufs* Verarbeiten Sie die angeforderten Parameter. * @param userername * @param password * @param request * @return */ @RequestMapping (value = "login", method = requestMethod.post) public modelAndView Login (String -Benutzername, String -Passwort, httpServletRetReque) {Request.SetatTribute ("Username", Username); Request.SetAttribute ("Passwort", Passwort); Neue modelAndView zurückgeben ("Procc"); }Die obige Methode wird direkt verwendet, indem der Anforderung Parameter hinzugefügt wird.
2. Seite Schreiben Sie die Seite und Formularseite: Formular:
Succ.jsp:
<body> <h2>Login</h2> username:${username } <p> password:${password } </body> form:<form action="login.html" method="post"> username:<input type="text" name="username" /> <p> password:<input type="password" name="password"/> <p> <input type="submit" value="submit" /> </form> 3. Führen Sie das Projekt endlich aus, um zu testen:
OK ist alles fertig. Das obige ist ein relativ einfaches Beispiel für SpringMVC.
Im angegebenen Quellcode gibt es eine andere Methode, die die Zeichenfolge direkt als Rückgabewert verwendet, um die Anzeigeseite anzugeben.
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.