SpringMVC-Framework (ausführliche Erklärung)

1. Einleitung

1.1. Was ist MVC?

Spring MVC ist ein Java-basiertes, anforderungsgesteuertes, leichtes Web-Framework, das das MVC-Entwurfsmuster implementiert. Durch die Trennung von (M)-Modell, (V)-Ansicht und (C)-Controller wird die Webschicht von Verantwortlichkeiten und komplexen Webanwendungen entkoppelt Es ist in Teile mit klarer Logik unterteilt, was die Entwicklung vereinfacht, Fehler reduziert und die Zusammenarbeit zwischen Entwicklern im Team erleichtert.

1.2, Vor- und Nachteile von SpringMVC

Vorteile von MVC:
Mehrere Ansichten teilen sich ein Modell, was die Wiederverwendbarkeit von Code erheblich verbessert. Die
drei Module von MVC sind unabhängig voneinander und haben eine lose gekoppelte Architektur.
Der Controller verbessert die Flexibilität und Konfigurierbarkeit von Anwendungen und
ist förderlich für das Software-Engineering-Management.

Perfekte Systemarchitektur = lose Kopplung + hohe Wiederverwendbarkeit + hohe Skalierbarkeit

MVC-Nachteile:
Komplexe Prinzipien
, erhöhte Komplexität der Systemstruktur und -implementierung,
ineffizienter Zugriff auf Modelldaten durch Ansichten

1.3, MVC-Muster

1. Ansichtsentsprechende Komponente: JSP- oder HTML-Datei
2. Controller-entsprechende Komponente: Servlet
3. Modellentsprechende Komponente: JavaBean
   
   JSP Model1
   
   JSP Model2
4. Servlet: Akzeptieren Sie Front-End-Anfragen und rufen Sie JavaBeans auf
5. JavaBean: Geschäfte abwickeln und Datenbank betreiben
6. JSP: Reagieren Sie auf die Verarbeitungsergebnisse an den Browser und präsentieren Sie sie dem Benutzer,
   
   der MVC verarbeitet,
   
   Spring MVC
7. Ersetzen Sie Servlet im JSP Model2-Modell durch Controller
8. Nachdem der Controller die Anforderung erhalten hat, schließt er die Geschäftsverarbeitung ab und verwendet das Modellobjekt zum Speichern der Verarbeitungsergebnisse.
9. Der Controller ruft den entsprechenden View-Parser View auf, um die Verarbeitungsergebnisse anzuzeigen, und schließlich erhält der Client die Antwortinformationen.

Zweitens verwenden Sie SpringMvc

21. Erstellen Sie das Maven-Web-Projekt und ändern Sie die Datei web.xml im Verzeichnis WEB-INF unter dem Verzeichnis webapp.

2.2, der Inhalt der Datei web.xml ist wie folgt

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>


<!--  页面中输入的中文，调到后端，出现乱码解决的问题  -->
  <filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>
      org.springframework.web.filter.CharacterEncodingFilter
    </filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
      <param-name>forceEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

</web-app>

2.3, Einführung von SpringMVC-Abhängigkeiten

<?xml version="1.0" encoding="UTF-8"?>

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.xinxi2</groupId>
  <artifactId>SpringMvc1</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>SpringMvc1 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
    <spring.version>5.2.5.RELEASE</spring.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>


  <!-- log4j 日志jar-->

  <dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
  </dependency>

  <!-- 连接mysql5 的驱动 -->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.10</version>
  </dependency>

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.2</version>
  </dependency>

  <!-- mybatis依赖 -->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.2.2</version>
  </dependency>
  <!-- 参考版本对应 http://www.mybatis.org/spring/ -->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.2.2</version>
  </dependency>

  <!-- 数据源管理  使用了dbcp2数据 -->
  <dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-dbcp2</artifactId>
    <version>2.1.1</version>
  </dependency>
  <dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.4.2</version>
  </dependency>

  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
  </dependency>
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.0</version>
    <scope>provided</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${spring.version}</version>
  </dependency>

  <!-- commons 文件上传jar -->
  <dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>1.4</version>
  </dependency>
  <dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
  </dependency>

  <!-- jstl -->
  <dependency>
    <groupId>jstl</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
  </dependency>

  <!-- 加入JSON转换工具 -->
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
  </dependency>

  </dependencies>

  <build>
    <finalName>SpringMvc1</finalName>
  </build>
</project>

2.4, erstellen Sie die Datei springmvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="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">

<!--  扫描  -->
    <context:component-scan base-package="com.controller"></context:component-scan>
</beans>

2.5, erstellen Sie eine Controller-Klasse

import java.util.List;
import java.util.Map;


//标记该类为处理层类
@Controller
@RequestMapping("/hello")

public class HelloController {
    
    
   	
    //把请求路径映射到该方法上
    @RequestMapping("/hello01")
    public String hello01(){
    
    
        System.out.println("hello01");
        
        //请求转发到hello01.jsp界面
        return "hello01.jsp";
    }
}

2.6, SpringMVC-Laufprozess

1. Der Client fordert http://localhost:8080/springMVC17/hello an
2. Kommen Sie zum Tomcat-Server.
3. Der Front-End-Controller DipatcherServlet von Springmvc akzeptiert alle Anfragen.
4. Überprüfen Sie, mit welchem ​​@RequestMaping Ihre Anfrageadresse übereinstimmt.
5. Führen Sie die entsprechende Methode aus. Die Methode gibt einen String zurück. Springmvc analysiert die Zeichenfolge in die weiterzuleitende Webseite.
6. Verketten Sie die Zeichenfolge über den Ansichtsparser.
7. Holen Sie sich die gespleißte Adresse und suchen Sie die entsprechende Webseite.
8. Rendern Sie die Webseite für den Client

2.7, verwenden Sie Model zum Hochladen von Daten

    @RequestMapping("/hello03")
    public String hello03(Student student,Model model){
    
    
        System.out.println("hello03"+student.getUsername()+"  "+student.getPwd()+" "+student.getBirthday()+" "+student.getAge());
        model.addAttribute("linyuhao","hh");
        return "hello01.jsp";
    }

Laden Sie Daten mit HttpServletRequest hoch

    @RequestMapping("/hello04")
    public String hello04(HttpServletRequest request){
    
    
        System.out.println("hello04");
        request.setAttribute("guangtou","gg");
        return "hello01.jsp";
    }

2.8, verwenden Sie Map zum Hochladen von Daten

    @RequestMapping("/hello05")
    public String hello05(Map map){
    
    
        System.out.println("hello05");
        int count = 1/0;
        map.put("wangdao","qq");
        return "redirect:/login.jsp";
    }

2.9, Statisches Ressourcenladeproblem

Dazu müssen wir die statischen Ressourcen in die SpringMVC-Konfigurationsdatei laden

<!--  解决了静态资源的加载问题  -->
    <mvc:resources mapping="/static/**" location="/static/"></mvc:resources>

3. So implementieren Sie die Seitenumleitung

In der Methode der Controller-Schicht ist der Rückgabewert vom Typ String und eine Schnittstelle wird mithilfe der Anforderungsweiterleitungsmethode zurückgegeben. Wenn Sie die Umleitung verwenden möchten, um zu anderen Seiten zu springen, fügen Sie im Rückgabewert „redirect:“ hinzu, / wenn springmvc Wenn die von Ihnen zurückgegebene Zeichenfolge „redirect:“ enthält, wird davon ausgegangen, dass Sie umleiten möchten.

return „redirect:/login.jsp“;

    @RequestMapping("/hello05")
    public String hello05(Map map){
    
    
        System.out.println("hello05");
        int count = 1/0;
        map.put("wangdao","qq");
        return "redirect:/login.jsp";
    }

4. Abfangjäger

4.1. Abfangjäger erstellen

package com.Interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

public class LoginInterceptor implements HandlerInterceptor {
    
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
    
        System.out.println("preHandle");
//        拦截规则，自己根据业务需求实现
        String username = request.getParameter("username");
        if (null==username || "".equals(username)){
    
    
            response.sendRedirect("/index.jsp");
            return false;
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    
    
        System.out.println("postHandle:handle执行完,渲染之前");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    
    
        System.out.println("afterCompletion:handle执行完,渲染之后");
    }
}

Die von uns erstellte Interceptor-Klasse muss die HandlerInterceptor-Schnittstelle implementieren und die preHandle-Methode überschreiben.
Wenn wir den von uns definierten Interceptor verwenden möchten, müssen wir den Interceptor in der Datei springmvc.xml registrieren.

    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/hello/**"/>
            <mvc:exclude-mapping path="/hello/hello04"/>
            <bean class="com.Interceptor.LoginInterceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>

5. Datei-Upload

5.1. Auf den lokalen Server hochladen

Der erste Schritt besteht darin, die Abhängigkeiten für den Datei-Upload zu importieren.

  <!-- commons 文件上传jar -->
  <dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>1.4</version>
  </dependency>
  <dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
  </dependency>

Der zweite Schritt besteht darin, eine Seite zu erstellen. Hierbei ist zu beachten, dass die Übermittlungsmethode „Post-Übermittlung“ sein muss. Der Formulartyp enctype muss auf das Format „multipart/form-data“ eingestellt werden. Das Namensattribut des Eingabe-Tags Hier kann nicht weggelassen werden und muss von der Controller-Schicht empfangen werden. Die Parameternamen sind gleich.

<%--
  Created by IntelliJ IDEA.
  User: lenovo
  Date: 2023/6/25
  Time: 16:39
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>上传文件</title>
</head>
<body>
    <form action="/hello/hello03" method="post" enctype="multipart/form-data">
        <input type="text" name="username"><br>
        <input type="file" name="photo"><br>
        <input type="text" name="age"><br>
        <input type="text" name="birthday">
        <input type="submit" value="提交">
    </form>
</body>
</html>

Der dritte Schritt besteht darin, den Datei-Upload-Parser in der SpringMVC-Konfigurationsdatei zu konfigurieren.

<!--  配置multipartResolver，用于上传文件，使用spring的CommonsMultipartResolver  -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxInMemorySize" value="5000000"></property>
        <property name="defaultEncoding" value="UTF-8"></property>
    </bean>

Der vierte Schritt besteht darin, eine Methode zu erstellen, die die Datei-Upload-Schnittstelle implementiert. @RequestMapping stellt die angeforderte Schnittstelle dar.

    @RequestMapping("/uploadPage")
    public String uploadPage(){
    
    
        return "upload.jsp";
    }

    @RequestMapping("/upload")
    @ResponseBody // 此方法的返回值就是响应体的内容
    public String upload(String username, MultipartFile photo,HttpServletRequest request){
    
    

        String fileType = photo.getOriginalFilename();
        int index = fileType.lastIndexOf(".");
        fileType = fileType.substring(index);
        String path = request.getSession().getServletContext().getRealPath("static"+File.separator+"uploadfiles");
        long filename = System.currentTimeMillis();
        System.out.println(path);
        System.out.println(fileType);
        System.out.println(path+"\\"+filename+fileType);
        File file = new File(path+"\\"+filename+fileType);
        try {
    
    
            photo.transferTo(file);
        } catch (IOException e) {
    
    
            e.printStackTrace();
        }
        return "上传成功!";
    }

6. Inhaltliche Ergänzung

@RestController entspricht @Controller+@ResponseBody.
Alle Methoden unter dieser Annotation geben JSON-Daten zurück.
@RequestMapping: Funktion: Ordnen Sie den Anforderungspfad der Antwortmethode zu.

@RequestParam(value = „u“): Legen Sie den Namen des Anforderungsparameters fest, den Sie akzeptieren. Abfrageparameter

@Param(value="name"): Legen Sie die Parameter in der Mapper-Mapping-Datei in mybatis fest

@RequestMapping(value = „/addUser“, method = RequestMethod.POST)
Methode: Gibt die von dieser Schnittstelle akzeptierte Anforderungsmethode an. Jede Anforderungsmethode kann akzeptiert werden, wenn sie nicht festgelegt ist.
@GetMapping("addUser"): Gibt an, dass nur Anforderungen in der Get-Übermittlungsmethode akzeptiert werden

@RequestBody: Konvertieren Sie die angeforderten JSON-Daten in ein Java-Objekt. Vom Front-End zum Back-End
@ResponseBody: Konvertieren Sie Java-Daten vom Back-End zum Front-End in JSON