So erstellen Sie einen SFTP-Server und einen Image-Server auf einem Linux-Cloud-Server

<Abhängigkeit>
    <groupId>com.jcraft</groupId>
    <artifactId>jsch</artifactId>
    <version>0.1.49</version>
</Abhängigkeit>

öffentliche Klasse SFTPInfo {
    öffentliche statische endgültige Zeichenfolge SFTP_REQ_HOST = "000.00.00.00"; //IP des Cloud-Servers
    public static final String SFTP_REQ_USERNAME = "00t"; // Benutzername public static final String SFTP_REQ_PASSWORD = "00"; // Passwort public static final int SFTP_DEFAULT_PORT = 22; // Port public static String basePath="/usr/games/images"; // Das Hauptverzeichnis, in dem die Datei auf dem Server gespeichert ist (das ist der Datei-Upload-Pfad)
    public static String baseUrl="https://##.##.com/images"; //Online-Domänennamenzugriff gibt den Nginx-Zugriffspfad an (der Pfad ist hier entscheidend)
}

importiere java.io.InputStream;
importiere java.util.Properties;
importiere org.slf4j.Logger;
importiere org.slf4j.LoggerFactory;
importiere com.jcraft.jsch.Channel;
importiere com.jcraft.jsch.ChannelSftp;
importiere com.jcraft.jsch.JSch;
importiere com.jcraft.jsch.JSchException;
importiere com.jcraft.jsch.Session;
importiere com.jcraft.jsch.SftpException; 
öffentliche Klasse SftpUtils {
    privater statischer endgültiger Logger LOG = LoggerFactory.getLogger(SftpUtils.class);
 
    /**
     * Referenzbeispiel *
     * @param args
     */
    öffentlicher Kanal getChannel(Sitzung Sitzung) {
        Kanal Kanal = null;
        versuchen {
            Kanal = Sitzung.openChannel("sftp");
            Kanal.verbinden();
            LOG.info("Kanalerfolg erzielen!");
        } Fang (JSchException e) {
            LOG.info("Kanal abrufen fehlgeschlagen!", e);
        }
        Rückkanal;
    }
 
    öffentliche Session getSession(String host, int port, String username,
                              endgültiges String-Passwort) {
        Sitzung Sitzung = null;
        versuchen {
            JSch jsch = new JSch();
            jsch.getSession(Benutzername, Host, Port);
            Sitzung = jsch.getSession(Benutzername, Host, Port);
            session.setPassword(passwort);
            Eigenschaften sshConfig = neue Eigenschaften();
            sshConfig.put("StrictHostKeyChecking", "nein");
            Sitzung.setConfig(sshConfig);
            Sitzung.verbinden();
            LOG.info("Sitzung verbunden!");
        } Fang (JSchException e) {
            LOG.info("Kanal abrufen fehlgeschlagen!", e);
        }
        Sitzung zurückgeben;
    }
 
    /**
     * Ordner erstellen *
     * @param sftp
     * @param dir
     * Ordnername */
    public void mkdir(ChannelSftp sftp, String dir) {
        versuchen {
            sftp.mkdir(dir);
            System.out.println("Ordner erfolgreich erstellt!");
        } Fang (SftpException e) {
            System.out.println("Ordner konnte nicht erstellt werden!");
            e.printStackTrace();
        }
    }
 
    /**
     * @param sftp
     * @param dir
     * Upload-Verzeichnis * @param-Datei
     * Datei hochladen * @return
     */
    öffentliche Boolean UploadFile(ChannelSftp sftp, String Verzeichnis, InputStream Datei, String Dateiname) {
        Boolesche Flagge = falsch;
        versuchen {
            sftp.cd(dir);
            if (Datei != null) {
                sftp.put(Datei, Dateiname);
                Flagge=wahr;
                Flagge zurückgeben;
            } anders {
                Flagge=falsch;
                Flagge zurückgeben;
            }
        } Fang (Ausnahme e) {
 
            Flagge=falsch;
            Flagge zurückgeben;
        }
    }
 
    /**
     * Datei herunterladen *
     * @param-Verzeichnis
     * Download-Verzeichnis * @param downloadFile
     * Heruntergeladene Datei * @param saveFile
     * Der lokale Pfad * @param sftp
     */
    öffentlicher String-Download (String-Verzeichnis, String-Downloaddatei,
                           Zeichenfolge saveFile, ChannelSftp sftp) {
        String-Ergebnis = "";
        versuchen {
            sftp.cd(Verzeichnis);
            sftp.get(Datei herunterladen, Datei speichern);
            Ergebnis = "Download erfolgreich!";
        } Fang (Ausnahme e) {
            Ergebnis = "Download fehlgeschlagen!";
            LOG.info("Download fehlgeschlagen!", e);
            ;
        }
        Ergebnis zurückgeben;
    }
 
    /**
     * Dateien löschen*
     * @param-Verzeichnis
     * Um das Verzeichnis zu löschen, in dem sich die Datei befindet* @param deleteFile
     * Zu löschende Datei * @param sftp
     */
    öffentliche String löschen(String Verzeichnis, String Datei löschen, ChannelSftp sftp) {
        String-Ergebnis = "";
        versuchen {
            sftp.cd(Verzeichnis);
            sftp.rm(Datei löschen);
            Ergebnis = "Erfolgreich gelöscht!";
        } Fang (Ausnahme e) {
            Ergebnis = "Löschen fehlgeschlagen!";
            LOG.info("Löschen fehlgeschlagen!", e);
        }
        Ergebnis zurückgeben;
    }
 
    private void closeChannel(Channel channel) {
        wenn (Kanal != null) {
            wenn (channel.isConnected()) {
                Kanal.Trennen();
            }
        }
    }
 
    private void schließenSession(Sitzung Sitzung) {
        wenn (Sitzung != null) {
            wenn (session.isConnected()) {
                Sitzung.Trennen();
            }
        }
    }
 
    public void closeAll(ChannelSftp sftp, Channel channel, Session session) {
        versuchen {
            Kanal schließen(sftp);
            Kanal schließen(Kanal);
            Sitzung schließen(Sitzung);
        } Fang (Ausnahme e) {
            LOG.info("Alle schließen", e);
        }
    }
}

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

@Log("Informationen zum Hochladen von Website-Fällen")
@AntwortBody
@PostMapping("/hochladen")
@RequiresPermissions("allgemein:Fälle:Upload")
R hochladen(@RequestParam("Datei") MultipartFile-Datei,@RequestParam("ctitle") String ctitle, @RequestParam("cmessage") String cmessage,
       @RequestParam("Falleinführung") String-Falleinführung,@RequestParam("strdate") Datum strdate,@RequestParam("stpdate") Datum stpdate,
       @RequestParam("credate") Datum credate,HttpServletRequest Anfrage) wirft ParseException, IOException {
   Zeichenfolge alterName = file.getOriginalFilename();
   //Verwenden Sie die Toolklasse IDUtils, um einen neuen Dateinamen zu generieren, neuer Dateiname = neuerName + Dateisuffix String newName = IDUtils.genImageName();
   neuerName = neuerName + alterName.substring(alterName.letzterIndexvon("."));
   SftpUtils ft = neue SftpUtils();
   //Verbinden Sie die Parameter über die SFtoInfo-Parameter. Session s = ft.getSession(SFTPInfo.SFTP_REQ_HOST,SFTPInfo.SFTP_DEFAULT_PORT, SFTPInfo.SFTP_REQ_USERNAME,SFTPInfo.SFTP_REQ_PASSWORD);
   Kanal Kanal = ft.getChannel(s);
   ChannelSftp sftp = (ChannelSftp)Kanal;
   Boolescher Upload = ft.uploadFile(sftp,SFTPInfo.basePath, file.getInputStream(),neuerName);
   wenn(hochladen){
      //Upload erfolgreich schließen ft.closeAll(sftp, channel, s); //Verbindung schließen CasesDO cases=new CasesDO();
      Fälle.setCtitle(ctitle);
        // Das ist sehr wichtig. Dies ist der in die Datenbank geschriebene Zugriffspfad plus der Online-Domänenname, um auf das Bild zuzugreifen. Der Blogger hat hier ein SSL-Zertifikat hinzugefügt. // https://**.**.com/images newName=Dateiname Bild cases.setCaseimg(SFTPInfo.baseUrl + "/" + newName);
      Fälle.setCasetroduction(Falletroduction);
      Fälle.setStpdate(stpdate);
      Fälle.setCredate(credate);
      Fälle.setStrdate(strdate);
      Fälle.setCmessage(cmessage);
      wenn (casesService.save(cases) > 0) {
         return R.ok("Hochladen erfolgreich");
      }
               }anders {
      return R.error("Upload-Fehler");
   }
   return R.error();
}

var Zwischenablage = neue Zwischenablage('button.copy', {
    Text: Funktion (Trigger) {
        layer.msg('Der Dateipfad wurde in die Zwischenablage kopiert');
        gibt $(trigger).attr('url') zurück;
    }
});
layui.use('hochladen', Funktion () {
    var upload = layui.upload;
    //Führen Sie das Beispiel upload.render({ aus.
        elem: '#test1', //Bindungselement-URL: '/common/cases/upload', //Größe der Upload-Schnittstelle: 100000,
        // auto: false,
        akzeptieren: 'Datei',
        //BindAction: "#Sendet ein",
        vorher: Funktion (Objekt) {
            //Die im Obj-Parameter enthaltenen Informationen sind genau dieselben wie im Choose-Callback. Der Eingabeparameter layer.load() wird an den Hintergrund übertragen;
            diese.daten = {
                ctitle: $('#ctitle').val(),
                cmessage: $('#cmessage').val() ,
                Falleinführung: $('#casetroduction').val()
                ,strdate: $('#strdate').val()
                ,stpdate: $('#stpdate').val()
                ,credate: $('#credate').val(),
            };
        },
        fertig: Funktion (r) {
            übergeordnete Ebene.msg(r.msg);
            übergeordnetes Element.reLoad();
            var index = parent.layer.getFrameIndex(window.name); // Fensterindex abrufen parent.layer.close(index);
        },
        Fehler: Funktion (r) {
            Schicht.msg(r.msg);
        }
    });
});