Detailliertes Beispiel für SpringBoot + nginx zum Erreichen der Ressourcen-Upload-Funktion

Server {
 hören Sie 9090;
 Servername localhost;

 location ~ .(jpg|png|jpeg|gif|bmp)$ { #Erkennbares Dateisuffix root /usr/nginx/image/; #Bildzuordnungspfad autoindex on; #Automatische Indizierung aktivieren läuft in 1 Stunde ab; #Ablaufzeit}
 Standort ~ .(css|js)$ {
  root /usr/nginx/static/;
  Autoindex aktiviert;
  läuft in 1 Stunde ab;
 } 
 Speicherort ~ .(AVI|mov|rmvb|rm|FLV|mp4|3GP)$ {
  root /usr/nginx/video/;
  Autoindex aktiviert;
  läuft in 1 Stunde ab;
 }

<übergeordnetes Element>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.1.7.RELEASE</version>
</übergeordnet>
<Abhängigkeiten>
 <Abhängigkeit>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <version>2.1.7.RELEASE</version>
 </Abhängigkeit>
 <Abhängigkeit>
  <groupId>org.springframework.boot</groupId>
  <artifactId>Spring-Boot-Starter-Test</artifactId>
  <version>2.1.7.RELEASE</version>
  <scope>Test</scope>
 </Abhängigkeit>
 <!-- Apache Tool Kit -->
 <Abhängigkeit>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-lang3</artifactId>
  <version>3.8.1</version>
 </Abhängigkeit>
 <Abhängigkeit>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-io</artifactId>
  <version>1.3.2</version>
 </Abhängigkeit>
 <Abhängigkeit>
  <groupId>commons-net</groupId>
  <artifactId>commons-net</artifactId>
  <version>3.6</version>
 </Abhängigkeit>
 <!-- Datei-Upload-Komponente-->
 <Abhängigkeit>
  <groupId>commons-Dateiupload</groupId>
  <artifactId>Commons-Dateiupload</artifactId>
  <version>1.3.3</version>
 </Abhängigkeit>
 <Abhängigkeit>
  <groupId>org.projektlombok</groupId>
  <artifactId>Lombok</artifactId>
  <version>1.16.22</version>
 </Abhängigkeit>
 <Abhängigkeit>
  <groupId>com.jcraft</groupId>
  <artifactId>jsch</artifactId>
  <version>0.1.54</version>
 </Abhängigkeit>
 <Abhängigkeit>
  <groupId>joda-zeit</groupId>
  <artifactId>joda-Zeit</artifactId>
  <version>2.10.3</version>
 </Abhängigkeit>
</Abhängigkeiten>

ftp:
 Host: Ihre eigene Server-IP
 Benutzername: Serverkonto Passwort: Serverkennwort Port: 22
 Stammpfad: /usr/nginx/image
 img:
 url: http://ip:9090/ # ftp.img.url kann weggelassen werden. Es wird nur verwendet, um den Dateipfad zurückzugeben, nachdem die Datei erfolgreich hochgeladen wurde.

importiere com.jcraft.jsch.*;
importiere org.slf4j.Logger;
importiere org.slf4j.LoggerFactory;
importiere org.springframework.beans.factory.annotation.Value;
importiere org.springframework.stereotype.Component;
importiere java.io.InputStream;
importiere java.util.Properties;
@Komponente
öffentliche Klasse FtpUtil {
 privater statischer Logger logger = LoggerFactory.getLogger(FtpUtil.class);
 /**
  * FTP-Server-IP-Adresse */
 privater statischer String-Host;
 @Wert("${ftp.host}")
 öffentliche void setHost(String val){
  FtpUtil.host = Wert;
 }
 /**
  * Hafen */
 privater statischer Int-Port;
 @Wert("${ftp.port}")
 öffentliche void setPort(int val){
  FtpUtil.port = Wert;
 }
 /**
  * Benutzername*/
 privater statischer String-Benutzername;
 @Wert("${ftp.userName}")
 öffentliche void setUserName(String val){
  FtpUtil.Benutzername = Wert;
 }
 /**
  * Passwort*/
 privates statisches String-Passwort;
 @Wert("${ftp.password}")
 öffentliche void setPassword(String val){
  FtpUtil.password = Wert;
 }
 /**
  * Das Stammverzeichnis, in dem die Bilder gespeichert sind */
 privater statischer String-RootPath;
 @Wert("${ftp.rootPath}")
 öffentliche void setRootPath(String val){
  FtpUtil.rootPath = Wert;
 }
 /**
  * Pfad zum Speichern des Bildes */
 privater statischer String imgUrl;
 @Wert("${ftp.img.url}")
 öffentliche void setImgUrl(String val){
  FtpUtil.imgUrl = Wert;
 }
 /**
  * Verbindung herstellen */
 privater statischer ChannelSftp getChannel() löst Ausnahme aus{
  JSch jsch = new JSch();
  //->ssh root@host:port
  Sitzung sshSession = jsch.getSession(Benutzername,Host,Port);
  //Passwort sshSession.setPassword(password);
  Eigenschaften sshConfig = neue Eigenschaften();
  sshConfig.put("StrictHostKeyChecking", "nein");
  sshSession.setConfig(sshConfig);
  sshSession.connect();
  Kanal Kanal = sshSession.openChannel("sftp");
  Kanal.verbinden();
  Rückgabekanal (ChannelSftp);
 }
 /**
  * Bild per FTP hochladen * @param inputStream Bild-E/A-Stream * @param imagePath Pfad, Verzeichnis erstellen, falls es nicht existiert * @param imagesName Bildname * @return urlStr Bildspeicherpfad */
 öffentliche statische String putImages(InputStream inputStream, String imagePath, String imagesName){
  versuchen {
   sftp = getChannel();
   String-Pfad = Stammpfad + Bildpfad + "/";
   createDir(Pfad, sftp);
   //Dateien hochladen sftp.put(inputStream, path + imagesName);
   logger.info("Upload erfolgreich!");
   sftp.quit();
   sftp.exit();
   //Den zurückgegebenen Pfad verarbeiten String resultFile;
   Ergebnisdatei = Bild-URL + Bildpfad + Bildername;
   Ergebnisdatei zurückgeben;
  } Fang (Ausnahme e) {
   logger.error("Hochladen fehlgeschlagen: " + e.getMessage());
  }
  zurückkehren "";
 }
 /**
  * Erstellen Sie ein Verzeichnis */
 private static void createDir(String path,ChannelSftp sftp) löst SftpException { aus.
  String[] Ordner = Pfad.split("/");
  sftp.cd("/");
  für (String Ordner: Ordner) {
   wenn ( Ordnerlänge() > 0 ) {
    versuchen {
     sftp.cd(Ordner);
    }fang ( SftpException e ) {
     sftp.mkdir(Ordner);
     sftp.cd(Ordner);
    }
   }
  }
 }
 /**
  * Bild löschen */
 öffentliche statische void delImages(String imagesName){
  versuchen {
   sftp = getChannel();
   String-Pfad = Stammpfad + Bildername;
   sftp.rm(Pfad);
   sftp.quit();
   sftp.exit();
  } Fang (Ausnahme e) {
   e.printStackTrace();
  }
 }
}

importiere java.util.Random;
öffentliche Klasse IDUtils {
 /**
  * Generiere einen zufälligen Bildnamen */
 öffentliche statische Zeichenfolge genImageName() {
  //Holen Sie sich den Long-Integer-Wert der aktuellen Zeit einschließlich Millisekunden long millis = System.currentTimeMillis();
  //Drei Zufallszahlen hinzufügen Random random = new Random();
  int end3 = zufällig.nextInt(999);
  //Wenn es weniger als drei Ziffern sind, füge 0 davor hinzu
  String str = Millis + String.format("%03d", end3);
  gibt str zurück;
 }
}

importiere com.wzy.util.FtpUtil;
importiere com.wzy.util.IDUtils;
importiere lombok.extern.slf4j.Slf4j;
importiere org.joda.time.DateTime;
importiere org.springframework.stereotype.Service;
importiere org.springframework.web.multipart.MultipartFile;
importiere java.io.IOException;
importiere java.io.InputStream;
/**
 * @Paket: com.wzy.service
 * @Autor: Clarence1
 * @Datum: 2019/10/4 21:34
 */
@Service
@Slf4j
öffentliche Klasse NginxService {
 öffentliches Objekt Bild hochladen(MultipartFile UploadFile) {
  //1. Einen neuen Dateinamen für das hochgeladene Bild generieren //1.1 Den ursprünglichen Dateinamen abrufen String oldName = uploadFile.getOriginalFilename();
  //1.2 Verwenden Sie die Toolklasse IDUtils, um einen neuen Dateinamen zu generieren: neuer Dateiname = neuerName + Dateisuffix String newName = IDUtils.genImageName();
  behaupten, alterName != null;
  neuerName = neuerName + alterName.substring(alterName.letzterIndexvon("."));
  //1.3 Erstellen Sie ein Unterverzeichnis zum Speichern von Dateien auf dem Server. String filePath = new DateTime().toString("/yyyyMMdd/");
  //2. Laden Sie das Bild auf den Bildserver hoch //2.1 Holen Sie sich den hochgeladenen E/A-Stream InputStream input = null;
  versuchen {
   Eingabe = UploadFile.getInputStream();
  } Fang (IOException e) {
   e.printStackTrace();
  }
  //2.2 Rufen Sie zum Hochladen die Toolklasse FtpUtil auf return FtpUtil.putImages(input, filePath, newName);
 }
}

importiere com.fasterxml.jackson.core.JsonProcessingException;
importiere com.fasterxml.jackson.databind.ObjectMapper;
importiere com.wzy.service.NginxService;
importiere lombok.extern.slf4j.Slf4j;
importiere org.springframework.beans.factory.annotation.Autowired;
importiere org.springframework.web.bind.annotation.PostMapping;
importiere org.springframework.web.bind.annotation.RequestParam;
importiere org.springframework.web.bind.annotation.RestController;
importiere org.springframework.web.multipart.MultipartFile;
importiere java.util.HashMap;
importiere java.util.Map;
@RestController
@Slf4j
öffentliche Klasse NginxController {
 @Autowired
 privater NginxService nginxService;
 /**
  * Sie können Bilder und Videos hochladen. Konfigurieren Sie dazu einfach ein erkennbares Suffix in der Nginx-Konfiguration*/
 @PostMapping("/hochladen")
 öffentliche Zeichenfolge Bildupload(@RequestParam(Wert = "Datei") MultipartFile UploadFile) {
  lang begin = System.currentTimeMillis();
  Zeichenfolge json = "";
  versuchen {
   Objektergebnis = nginxService.uploadPicture(uploadFile);
   json = neuer ObjectMapper().writeValueAsString(Ergebnis);
  } Fang (JsonProcessingException e) {
   e.printStackTrace();
  }
  langes Ende = System.currentTimeMillis();
  log.info("Aufgabe abgeschlossen, insgesamt benötigte Zeit: [" + (end-begin) + "] Millisekunden");
  gib JSON zurück;
 }
 @PostMapping("/uploads")
 öffentliches Objekt BilderUpload(@RequestParam(Wert = "Datei") MultipartFile[] UploadFile) {
  lang begin = System.currentTimeMillis();
  Map<Objekt, Objekt> map = neue HashMap<>(10);
  int-Anzahl = 0;
  für (MultipartFile-Datei: UploadFile) {
   Objektergebnis = nginxService.uploadPicture(Datei);
   map.put(Anzahl, Ergebnis);
   zählen++;
  }
  langes Ende = System.currentTimeMillis();
  log.info("Aufgabe abgeschlossen, insgesamt benötigte Zeit: [" + (end-begin) + "] Millisekunden");
  Rückfahrkarte;
 }
}