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

View more categories:

1- Die Vorstellung

Spring 4 MVC

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:

(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

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

8.1- 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";
  }

  ......
}

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

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

8.4- 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
  1. /web/fe/default/en/document/8108/spring-mvc-for-beginners
  2. /web/fe/default/vi/document/8108/spring-mvc-cho-nguoi-moi-bat-dau
  3. .....
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:

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

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

View more categories: