Die Anleitung zum Sping MVC für den Anfänger - Hello Spring 4 MVC

Die Vorstellung
Maven Project erstellen
Melden Sie Maven und web.xml
Die Konfiguration von Spring MVC
Jsp & Spring Controller
Die Applikation Spring MVC laufen
Der Thread der Applikation
Controller und die Methode
Die Konfiguration von Static Resource im Spring MVC

1. Die Vorstellung

Das Dokument wird nach der Quelle von... geschrieben

Eclipse 4.6 (NEON)
Spring 4.0.3.RELEASE

Die Hinweise: Sie sollen die Unterlagen über die Einführung der Struktur Spring Framework und über was macht Spring durch eine Anleitung über HelloWorld Spring bei ... vorschauen:
Die Anleitung zum Sping für den Anfänger
(Das Zweck: Die Vorstellung über Spring, die Erklärung von @Service, @Component, @Repository, ... und das Beispiel HelloWorld)

das Beispiel sehen

2. Maven Project erstellen

Ein Maven Project Typ erstellen. Maven hilt us bei dem besten Management der Bibliothek. Sie sind frei., die anderen Aufgabe zu behandeln

Auf die Eclipse wählen Sie:

File/New/Other...

Wählen Sie (archetype) "maven-archetype-webapp".

Geben Sie ein

Group Id: org.o7planning
Artifact Id: HelloSpringMVC
Package: org.o7planning.hellospringmvc

Das ist die erstellte Struktur von Projekt.

Sie sorgen bitte nicht dafür, dass eine Fehleranmeldung gleich nach der Erstellung des Projekt auftrittet. Der Grund liegt darin, dass Sie die Bibliothek Servlet nicht gemeldet haben.

Eclipse erstellt das Project Maven , das die falsche Struktur hat. Sie sollen prüfen

Stellen Sie sicher, dass Sie Java >= 6 benutzen

Project Properties:

3. Melden Sie Maven und web.xml

Melden Sie die Bibliothek zu benutzen

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.o7planning</groupId>
  <artifactId>HelloSpringMVC</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>HelloSpringMVC Maven Webapp</name>
  <url>http://maven.apache.org</url>


    <dependencies>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>

        <!-- Servlet Library -->
        <!-- http://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

        <!-- Spring dependencies -->
        <!-- http://mvnrepository.com/artifact/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.3.1.RELEASE</version>
        </dependency>

        <!-- http://mvnrepository.com/artifact/org.springframework/spring-web -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>4.3.1.RELEASE</version>
        </dependency>

        <!-- http://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.1.RELEASE</version>
        </dependency>

    </dependencies>
   

    <build>
        <finalName>HelloSpringMVC</finalName>
        <plugins>
       
            <!-- Config: Maven Tomcat Plugin -->
            <!-- http://mvnrepository.com/artifact/org.apache.tomcat.maven/tomcat7-maven-plugin -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <!-- Config: contextPath and Port (Default: /HelloSpringMVC : 8080) -->
                <!--
                <configuration>
                    <path>/</path>
                    <port>8899</port>
                </configuration>
                -->   
            </plugin>
        </plugins>
    </build>   
   
</project>

benutzen Sie Servlet API 3 oder neure:

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    id="WebApp_ID" version="3.0">
   
    <display-name>HelloSpringMVC</display-name>
   
</web-app>

4. Die Konfiguration von Spring MVC

SpringWebAppInitializer ist die Implementierungsklasse (implements) der Interface WebApplicationInitializer. Spring liest die Konfigurationsinformation in der Klasse um Ihre Web-Applikation zu initialisieren (initial).

Normalerweise können Sie Servlet, die Servlet Filter,und Servlet Listener statt der Registrierung in der web.xml registrieren

Ein wichtige Servlet ist org.springframework.web.servlet.DispatcherServlet, Sie sollen es registrieren.

SpringWebAppInitializer.java

package org.o7planning.hellospringmvc.config;

import javax.servlet.FilterRegistration;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;

import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.ContextLoaderListener;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.servlet.DispatcherServlet;

public class SpringWebAppInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        AnnotationConfigWebApplicationContext appContext = new AnnotationConfigWebApplicationContext();
        appContext.register(ApplicationContextConfig.class);

        // Dispatcher Servlet
        ServletRegistration.Dynamic dispatcher = servletContext.addServlet("SpringDispatcher",
                new DispatcherServlet(appContext));
        dispatcher.setLoadOnStartup(1);
        dispatcher.addMapping("/");
        
        dispatcher.setInitParameter("contextClass", appContext.getClass().getName());

        servletContext.addListener(new ContextLoaderListener(appContext));
        
        // UTF8 Charactor Filter.
        FilterRegistration.Dynamic fr = servletContext.addFilter("encodingFilter", CharacterEncodingFilter.class);

        fr.setInitParameter("encoding", "UTF-8");
        fr.setInitParameter("forceEncoding", "true");
        fr.addMappingForUrlPatterns(null, true, "/*");        
    }

}

Die Klasse ApplicationContextConfig ist für die Meldung der Spring BEAN. Sie wird durch @Configuration kommentiert

@ComponentScan("org.o7planning.hellospringmvc.*") - sagt Spring, die anderen Spring BEAN, die Controller in der direkte Sub-Package von der Package org.o7planning.hellospringmvc zu suchen.

ApplicationContextConfig.java

package org.o7planning.hellospringmvc.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
@ComponentScan("org.o7planning.hellospringmvc.*") 
public class ApplicationContextConfig { 
 
     

    @Bean(name = "viewResolver")
    public InternalResourceViewResolver getViewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/WEB-INF/pages/");
        viewResolver.setSuffix(".jsp");
        return viewResolver;
    }
 

}

Die Klasse WebMvcConfig , die aus WebMvcConfigurerAdapter verlängert, ist für die Konfiguration der Ressources in Spring MVC, zum Beispiel die static Resources (Image, CSS, Javascript,..)

WebMvcConfig.java

package org.o7planning.hellospringmvc.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;


@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter {

    // Static Resource Config 
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/css/**").addResourceLocations("/css/").setCachePeriod(31556926);
        registry.addResourceHandler("/img/**").addResourceLocations("/img/").setCachePeriod(31556926);
        registry.addResourceHandler("/js/**").addResourceLocations("/js/").setCachePeriod(31556926);
    }

    
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
 
}

5. Jsp & Spring Controller

Die Klasse Controller ist zur Kontrolle der Applikation-Thread

HelloWorldController.java

package org.o7planning.hellospringmvc.controller;

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

@Controller
public class HelloWorldController {

    @RequestMapping("/hello")
    public String hello(Model model) {
       
        model.addAttribute("greeting", "Hello Spring MVC");
       
        return "helloworld";
       
    }

}

/WEB-INF/pages/helloworld.jsp

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Spring MVC -HelloWorld</title>
</head>


<body>
    <h1>${greeting}</h1>
</body>


</html>

6. Die Applikation Spring MVC laufen

Zum ersten Mal sollen Sie vor dem Durchführung das ganze Projekt bauen (build)

Klicken Sie auf Projekt und wählen

Run As/Maven install

Die Konfiguration laufen

Geben Sie ein

Name: Run HelloSpringMVC
Base directory: ${workspace_loc:/HelloSpringMVC}
Goals: tomcat7:run

Klicken Sie auf Run zum Laufen

Zum ersten Mal kostet es ziemlich lang weil das Programm die Bibliothek tomcat plugin zum Laufen herunterladen

Alle Dinge sind fertig

URL laufen

http://localhost:8080/HelloSpringMVC/hello

7. Der Thread der Applikation

Sie erledigen das Projekt und das Projekt läuft erfolgreich. Jetzt sehen wir, wie funktioniert das Programm

8. Controller und die Methode

HttpServletRequest & HttpServletResponse

Sie können HttpServletRequest, HttpServletResponse in die Methode von Controller benutzen.

OtherExampleController.java

package org.o7planning.tutorial.springmvc;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class OtherExampleController {

  ......

  @RequestMapping("/somePath")
  public String requestResponseExample(HttpServletRequest request,
          HttpServletResponse reponses, Model model) {

      // Todo something here

      return "someView";
  }

  ......
}

Redirect im Controller

Benutzen Sie die Präfix "redirect:" im rükgegebenen String von der Methode können Sie eine andere Seite umleiten (redirect). Sehen Sie ein Beispiel

RedirectExampleController.java

package org.o7planning.hellospringmvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class RedirectExampleController {

   @RequestMapping(value = "/redirect", method = RequestMethod.GET)
   public String authorInfo(Model model) {

      // Do somethong here

       return "redirect:/hello";
   }
}

URL laufen:

http://localhost:8080/HelloSpringMVC/redirect

Zum Beispiel @RequestParam

@RequestParam benutzen um einen Parameter von request in einem Parameter einer Methode in Ihrem Controller zu binden (bind)

Unten ist das die Code

RequestParamExampleController.java

package org.o7planning.hellospringmvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class RequestParamExampleController {
 
  @RequestMapping("/user")
  public String userInfo(Model model,
          @RequestParam(value = "name", defaultValue = "Guest") String name) {

      model.addAttribute("name", name);

      if ("admin".equals(name)) {
          model.addAttribute("email", "admin@example.com");
      } else {
          model.addAttribute("email", "Not set");
      }
      return "userInfo";
  }

}

/WEB-INF/pages/userInfo.jsp

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>User Info</title>
</head>
<body>

  <h2>${name}</h2>

  Email: ${email}
  <br>


</body>
</html>

URL laufen:

http://localhost:8080/HelloSpringMVC/user?name=admin

ZUm Beispiel @PathVariable

Im Spring MVC können Sie @PathVariable benutzen um einen Parameter der Methode mit einer Variable Template URI (URI Template Variable) zu binden.

Zum Beispiel: Das ist ein Muster von URI:

/web/fe/{sitePrefix}/{language}/document/{id}/{naturalText}

Und die folgenden URI entsprechen den Muster oben

/web/fe/default/en/document/8108/spring-mvc-for-beginners
/web/fe/default/vi/document/8108/spring-mvc-cho-nguoi-moi-bat-dau
.....

Die folgende Code zeigt the Nutzungsweise

PathVariableExampleController.java

package org.o7planning.hellospringmvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class PathVariableExampleController {


  /**
   * @PathVariable Example:
   *
   * <pre>
   *
   *   http://o7planning.org/web/fe/default/en/document/8108/spring-mvc-for-beginners
   *  
   *   or
   *  
   *   http://localhost:8080/HelloSpringMVC/web/fe/default/en/document/8108/spring-mvc-for-beginners
   *
   * </pre>
   */
  @RequestMapping("/web/fe/{sitePrefix}/{language}/document/{id}/{naturalText}")
  public String documentView(Model model,
          @PathVariable(value = "sitePrefix") String sitePrefix,
          @PathVariable(value = "language") String language,
          @PathVariable(value = "id") Long id,
          @PathVariable(value = "naturalText") String naturalText) {

      model.addAttribute("sitePrefix", sitePrefix);
      model.addAttribute("language", language);
      model.addAttribute("id", id);
      model.addAttribute("naturalText", naturalText);

      String documentName = "Java tutorial for Beginners";
      if (id == 8108) {
          documentName = "Spring MVC for Beginners";
      }

      model.addAttribute("documentName", documentName);

      return "documentView";
  }
}

/WEB-INF/pages/documentView.jsp

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>${documentName}</title>
</head>
<body>

   <h3>${documentName}</h3>

   Site Prefix: ${sitePrefix}
   <br> Language: ${language}
   <br> ID: ${id}
   <br> Natural Text: ${naturalText}
   <br>

</body>
</html>

URL laufen:

http://localhost:8080/HelloSpringMVC/en/10129/spring-mvc-tutorial-for-beginners

Zum Beispiel @ResponseBody

Wenn Sie eine Methode in Controller mit @ResponseBody kommentieren, wandelt Spring die rückgegebene Wert der Methode zur String um und in Http Response automatisch schreiben. In diesem Fall brauchen Sie ein bestimmtes View .

Beachten Sie: Die Methode gibt unbedingt das Stringstyp rück

Das einfache Beispiel über @ResponseBody, und die Methode gibt das String rück

ResponseBodyExample1Controller.java

package org.o7planning.hellospringmvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class ResponseBodyExample1Controller {

   // Simple example, method returns String.
   @RequestMapping(value = "/saveResult")
   @ResponseBody
   public String authorInfo(Model model) {
       return "saved";
   }

   
}

Das Ergebnis des Beispiel bekommen Sie

http://localhost:8080/HelloSpringMVC/saveResult

Das Beispiel über @ResponseBody, die Methode gibt das Objekt-Typ rück

TODO

9. Die Konfiguration von Static Resource im Spring MVC

Um die Static Resource (*.css, *.js, image, ..) zu benutzen, sollen Sie einige Konfiguration. Sie können die Anleitung bei... sehen

Konfigurieren Sie statische Ressourcen in Spring MVC

Die Anleitung zum Sping MVC für den Anfänger - Hello Spring 4 MVC

1. Die Vorstellung

2. Maven Project erstellen

3. Melden Sie Maven und web.xml

4. Die Konfiguration von Spring MVC

5. Jsp & Spring Controller

6. Die Applikation Spring MVC laufen

7. Der Thread der Applikation

8. Controller und die Methode

9. Die Konfiguration von Static Resource im Spring MVC

Anleitungen Spring MVC

Anleitungen Spring MVC

Neueste Artikel