Zusammenfassung: In diesem Artikel werden zwei Methoden für JavaBean zum Implementieren mehrerer Datei-Uploads vorgestellt, wobei das http-Protokoll bzw. das FTP-Protokoll verwendet wird. Zunächst wird das grundlegende Format der Übertragung mehrerer Dateien über das HTTP-Protokoll und der detaillierte Vorgang des Hochladens beschrieben. Anschließend wird kurz die Verwendung der FTP-Client-Klasse zur Implementierung des FTP-Uploads vorgestellt und schließlich die beiden Methoden verglichen.
Schlüsselwörter: JavaBean, http, ftp, ftpclient
JavaBean ist eine Java-basierte Softwarekomponente. JSP bietet vollständige Unterstützung für die Integration von JavaBean-Komponenten in Webanwendungen. Diese Unterstützung verkürzt nicht nur die Entwicklungszeit (Sie können vorhandene getestete und vertrauenswürdige Komponenten direkt verwenden und vermeidet so wiederholte Entwicklungen), sondern sorgt auch für mehr Skalierbarkeit bei JSP-Anwendungen.
Die Datei-Upload-Funktion ist im B/S-basierten Entwicklungsmodell sehr verbreitet. Im Vergleich zu anderen Entwicklungstools ist die Unterstützung von JSP für das Hochladen von Dateien nicht perfekt. Es erfordert weder die Vervollständigung von Komponenten wie ASP, noch bietet es direkte Unterstützung für das Hochladen von Dateien wie PHP. Die Art und Weise, wie JSP das Hochladen von Dateien implementiert, ist wie folgt: Verwenden Sie die Methode getInputStream () der ServletRequest-Klasse, um einen vom Client an den Server gesendeten Datenstrom abzurufen, und verarbeiten Sie diesen Datenstrom dann, um die verschiedenen übergebenen Parameter und Parameter zu analysieren und abzurufen Laden Sie die Dateidaten beim Hochladen auf den Server herunter und speichern Sie sie dann als Datei oder fügen Sie sie in eine Datenbank ein. Normalerweise verarbeiten JSP-Seiten nicht die Funktion zum Hochladen von Dateien, sondern fügen diese Funktionen zur Implementierung in Servlets oder JavaBeans ein. Beispiele für die Verwendung von Servlet zum Abschließen von Datei-Uploads werden in einigen JSP-bezogenen Büchern vorgestellt. Hier werde ich vorstellen, wie JeanBean zum Abschließen von Datei-Uploads verwendet wird. Es gibt zwei Möglichkeiten, Dateien in JSP hochzuladen, nämlich das HTTP-Protokoll und das FTP-Protokoll. Zwischen beiden gibt es große Unterschiede in den Übertragungsprinzipien. Im Folgenden wird eine kurze Einführung in die Implementierung anhand des Quellcodes gegeben. Ich glaube, dass die Leser etwas davon haben werden. Das folgende Programm wurde debuggt und übergeben. Debugging-Umgebung: Windows 2000 Server+Apache +Tomcat4.0, JavaBean-Debugging-Umgebung: JDK1.4+Editplus.
Die Verwendung von JavaBean in JSP zur Implementierung der webbasierten Datei-Upload-Funktion erfordert im Allgemeinen die Kombination von drei Dateitypen. Bei diesen drei Dateien handelt es sich jeweils um die HTML-Seitendatei, die die Schnittstelle bereitstellt, die JSP-Datei, die den Aufruf zum Implementieren der Upload-Funktion von JavaBean abschließt, und die Java-Klassendatei, die JavaBean implementiert. Im Folgenden werde ich mich auf den JavaBean-Teil konzentrieren, der das HTTP-Protokoll und das FTP-Protokoll verwendet, um die Funktion zum Hochladen von Dateien zu implementieren.
1 Verwenden Sie das HTTP-Protokoll, um mehrere Dateien hochzuladen.
In der Vergangenheit konnten HTML-Formulare keine Dateien hochladen, was die Funktionen einiger Webseiten etwas einschränkte. Die RFC1867-Spezifikation (d. h. formularbasierter Datei-Upload in HTML) erweitert das Formular und fügt ein Formularelement <input type=file> hinzu. Durch die Verwendung dieses Elements generiert der Browser automatisch ein Eingabefeld und eine Schaltfläche. Das Eingabefeld ermöglicht es dem Benutzer, den lokalen Dateinamen und den Pfadnamen einzugeben, und die Schaltfläche ermöglicht es dem Browser, ein Dateiauswahlfeld für den Benutzer zu öffnen Wählen Sie eine Datei aus. Die spezifische Formularimplementierung lautet wie folgt:
<FORMMETHOD="POST" ACTION="*.jsp" ENCTYPE="multipart/form-data">
<INPUT TYPE="FILE" NAME="FILE1" SIZE="50"><BR>
<INPUT TYPE="SUBMIT" VALUE="Upload">
</FORM>
Wenn Sie die Datei einfügen möchten, geben Sie den absoluten Pfad der lokalen Datei direkt ein. Der Aktionsattributwert des Formulars ist *.jsp, was bedeutet, dass die Anfrage (einschließlich der hochgeladenen Datei) an gesendet wird *..jsp-Datei. Dabei wird tatsächlich der Datei-Upload über HTTP implementiert. Das Hochladen von Dateien vom Client zum Server wird durch das Common Gateway Interface (CGI) des HTTP-Protokolls unterstützt. Diese Upload-Methode erfordert, dass sowohl der Browser als auch der WEBServer Rfc1867 unterstützen. JavaBean ruft über die Methode getInputStream() der ServletRequest-Klasse einen vom Client an den Server gesendeten Datenstrom ab, analysiert das hochgeladene Dateiformat und gibt basierend auf den Analyseergebnissen nacheinander mehrere Dateien in die Zieldatei auf der Serverseite aus. Die Funktion von JavaBeande in diesem Beispiel wird speziell durch die testUpload-Klasse implementiert. Das Framework der TestUpload-Klasse lautet wie folgt:
öffentliche Klasse testUpload
{
öffentlicher testUpload(){……}
public final void initialize(ServletConfig config) löst eine ServletException aus
{ m_application = config.getServletContext();
public void upload() löst testUploadException, IOException, ServletException aus
{…………}
private void getDataSection(){………}
private void getDataHeader(){………}
public int save (String destPathName)
löst SmartUploadException, IOException, ServletException aus
{…………}
…
}
Initialisieren Sie die laufende Umgebung des Servlets mit der Methode initialize(). Verwenden Sie die Methode upload(), um den Eingabestream abzurufen, das Format der hochgeladenen Datei zu analysieren und die Attribute jeder hochgeladenen Datei mehreren Dateiklasseninstanzen zur Verarbeitung zuzuweisen. Diese Dateiklasseninstanzen werden von der Dateiklasse verwaltet. Die File-Klasse ruft ihre save()-Methode entsprechend den Attributen jeder Datei auf, um mehrere Dateien nacheinander in die Zieldatei auf der Serverseite auszugeben. Die Methode upload() ist der Schlüssel zur Analyse des Formats der vom http1.1-Protokoll übertragenen Dateien. Nach dem Testen erhalten wir das Format der Transportstream-Datei, das für das Verständnis der Methode upload() hilfreich ist. Laden Sie beispielsweise die Datei „Eigene Dateientt.txt“ hoch. Das Format ist wie folgt:
//Dateitrennzeichen
-------------------------7d226137250336
//Dateiinformationsheader
Inhaltsdisposition: form-data; name="FILE1"; filename="C:Dokumente und EinstellungenAdministrator.TIMBER-4O6B0ZZ0Meine Dateientt.sql"
Inhaltstyp: Text/einfach
//Inhalt der Quelldatei
Tabelleninfo erstellen(
Inhaltsbild null);
//Trennzeichen der nächsten Datei
-------------------------7d226137250336
Inhaltsdisposition: form-data; name="FILE2";
Inhaltstyp: Anwendung/Oktett-Stream
--------------------------------7d226137250336
Aus den obigen Dateien können wir ersehen, dass beim Hochladen mehrerer Dateien das HTTP-Protokoll All werden in den Eingabestream eingefügt und durch bestimmte Trennzeichen unterschieden. Tatsächlich besteht die Methode upload () darin, die obige Datei zu analysieren und den Inhalt des Trennzeichens, das Inhaltsformat jeder Datei, den vollständigen Pfadnamen der Datei sowie den Anfang und das Ende der tatsächlichen Daten der Datei zu bestimmen. Hierbei ist zu beachten, dass das Trennzeichen zufällig ist und alle Zeichen vor dem ersten Wagenrücklaufzeichen der Transportstromdatei umfasst.
Der Implementierungsprozess der Upload()-Methode ist: Geben Sie zunächst die Eingabestreamdatei in das Byte-Array m_binArray aus, das durch den folgenden Code implementiert wird.
m_totalBytes=1024; totalRead=0;
for(; totalRead < m_totalBytes; totalRead += readBytes)
versuchen
{ m_request.getInputStream();
readBytes = m_request.getInputStream().read(m_binArray, totalRead, m_totalBytes - totalRead);
}catch(Exception e){ throw new SmartUploadException("Upload nicht möglich.");}
Hier wird die Multibyte-Lesemethode in der Schleife verwendet. Die obige Schleife liest kontinuierlich Daten, bis das Array gefüllt ist. Wenn eine Datei vollständig abgerufen werden kann, können auch alle Bytes der Datei abgerufen werden. Da die Netzwerkgeschwindigkeit jedoch normalerweise viel langsamer ist als die CPU-Geschwindigkeit, kann das Programm den Netzwerkpuffer leicht löschen, bevor alle Daten eintreffen. Tatsächlich gibt die Multibyte-Lesemethode 0 zurück, wenn versucht wird, Daten aus einem vorübergehend leeren, aber offenen Netzwerkpuffer zu lesen, was bedeutet, dass keine Daten vorhanden sind, der Netzwerkstream jedoch nicht geschlossen wurde. In diesem Fall verhindert die Einzelbyte-Methode die Ausführung des laufenden Programms, sodass das Verhalten der Mehrbyte-Methode besser ist als das der Einzelbyte-Methode read(). Als nächstes wird das Byte-Array m_binArray analysiert. Suchen Sie zuerst das Trennzeichen; verwenden Sie die Methode getDataHeader(), um den Wert des Dateiinformationsheaders zurückzugeben, aus dem der vollständige Pfadname der Quelldatei, die Quelldateierweiterung und das Inhaltsformat der Quelldatei ermittelt werden. Methode zum Zurückgeben der Dateiinhaltsdaten und zum Aufzeichnen der Start- und Endpositionen der Dateidaten im Byte-Array. Generieren Sie dann eine Dateiklasseninstanz und geben Sie den vollständigen Pfadnamen der Datei, die Erweiterung der Quelldatei, das Inhaltsformat der Quelldatei sowie die Start- und Endpositionen der Inhaltsdaten der Datei in die Attribute der Dateiklasseninstanz ein. Suchen Sie das nächste Trennzeichen und wiederholen Sie den obigen Vorgang, bis die Analyse abgeschlossen ist.
2 Verwenden Sie das FTP-Protokoll, um mehrere Dateien hochzuladen.
Das FTP-Protokoll ist ein Protokoll zur Übertragung von Dateien im Internet. Es legt die Standards für die gegenseitige Übertragung von Dateien im Internet fest. Die Implementierung dieser Funktion in Java erfolgt mithilfe der FtpClient-Klasse. Spezifischer Implementierungsprozess: Stellen Sie zunächst eine Verbindung mit dem FTP-Server her. Initialisieren Sie die Dateiübertragungsmethode, einschließlich ASCII und BINARY. Lesen Sie die Daten im FileInputStream in ein Byte-Array Daten werden in den Ausgabestream TelnetOutputStream geschrieben (verwenden Sie die Schreibmethode, um die Daten auf eine Netzwerkverbindung zu schreiben). Auf diese Weise wird eine Datei mit demselben Namen wie die Quelldatei auf den Server kopiert. In diesem Beispiel schließt die JavaBean den Datei-Upload-Prozess über drei Methoden ab: connectServer(), upload() und closeConnect(). Die Hauptimplementierung lautet wie folgt:
öffentliche Klasse ftpUpload
{ String Dateiname;String Dateiname1;FtpClient ftpClient;
public void connectServer(string server,string user,string passwort,string path)
{
//Server: IP-Adresse des FTP-Servers; Benutzer: Benutzername zum Anmelden beim FTP-Server
//Passwort: das Passwort des Benutzernamens für die Anmeldung beim FTP-Server; Pfad: der Pfad auf dem FTP-Server
try{ ftpClient=new FtpClient();
ftpClient.openServer(server);
ftpClient.login(Benutzer, Passwort);
System.out.println("Anmeldung erfolgreich!");
if (path.length()!=0) ftpClient.cd(path);
ftpClient.binary(); }catch (IOException ex) {System.out.println(ex);}
}
public void closeConnect()
{try{ ftpClient.closeServer();
}catch (IOException ex) {System.out.println(ex);}
}
public void upload()
{ filename1=findFileName(filename);
// Analysieren Sie den Namen der Datei anhand des Dateinamens und verwenden Sie ihn als Namen der Zieldatei. Die spezifische Methode ist nicht angegeben.
versuchen {
TelnetOutputStream os=ftpClient.put(filename1);
java.io.File file_in=new java.io.File(filename);
FileInputStream is=new FileInputStream(file_in);
byte[] bytes=neues byte[1024];
int c;
while ((c=is.read(bytes))!=-1){ os.write(bytes,0,c }
is.close(); os.close();
} Catch (IOException ex) {System.out.println(ex);}
}
}
connectServer () schließt die Funktion des Herstellens einer Verbindung mit dem FTP-Server ab, verwendet die openServer-Methode (String-Server) von FtpClient, um den Remote-FTP-Server zu öffnen, und meldet sich dann mit der Login-Methode (Benutzer, Passwort) von FtpClient beim Server an. Es gibt zwei Möglichkeiten, sich beim Remote-FTP-Server anzumelden: Eine besteht darin, sich als registrierter Benutzer anzumelden, und die andere darin, sich anonym anzumelden. Ersteres erfordert, dass sich der Benutzer zunächst als Client des Servers registriert. Der Server gibt dem Benutzer ein Anmeldekonto und ein Kennwort und stellt anhand des Kontos und Kennworts eine Verbindung zum Server her. Letzteres erfordert, dass Benutzer die speziellen Benutzernamen „annoymous“ und „guest“ verwenden, ohne sich zu registrieren, um eingeschränkten Zugriff auf öffentliche Dateien auf Remote-Hosts zu haben. Viele Systeme erfordern jetzt, dass Benutzer ihre E-Mail-Adresse als Passwort verwenden. Aus Sicherheitsgründen gestatten die meisten anonymen FTP-Hosts Remote-Benutzern im Allgemeinen nur das Herunterladen von Dateien, nicht jedoch das Hochladen. Dies hängt von den Einstellungen des FTP-Servers ab. Benutzer können je nach den tatsächlichen Bedingungen zwischen zwei Methoden wählen. Verwenden Sie nach der Anmeldung die Methode „binary()“ von FtpClient, um den Übertragungsmodus auf den Bytemodus zu initialisieren. upload() schließt die Datei-Upload-Funktion ab. Erstellen Sie den Dateieingabestream FileInputStream der Quelldatei, schreiben Sie den Eingabestream in das Byte-Array und verwenden Sie die Schreibmethode von TelnetOutputStream, um die Daten im Byte-Array in eine Netzwerkverbindung zu schreiben. Da TelnetOutputStream eine Datei auf dem FTP-Server öffnet, werden die Daten in die Zieldatei geschrieben und somit der Datei-Upload abgeschlossen. closeConnect() erfordert eine Trennung vom Server.
Das Obige ist nur der Vorgang zum Hochladen einer einzelnen Datei. Wenn mehrere Dateien vorhanden sind, kann dieser Upload-Vorgang mehrmals aufgerufen werden. Anhand der beiden oben genannten Methoden können wir erkennen, dass die Verwendung des FTP-Protokolls zum Hochladen mehrerer Dateien relativ einfach und leicht zu implementieren ist. Die Verwendung des FTP-Protokolls zum Hochladen von Dateien ist im Allgemeinen ein clientseitiges Programm, und die serverseitigen Sicherheitseinstellungen sind komplizierter, während die Verwendung des HTTP-Protokolls zum Hochladen von Dateien eine serverseitige Anwendung ist und die Sicherheitseinstellungen relativ einfach sind . Und durch Tests wurde festgestellt, dass die FTP-Upload-Methode bei der Übertragung großer Dateien Dutzende oder sogar Hundertfache schneller ist als die HTTP-Upload-Methode, bei der Übertragung von Dateien kleiner als 1 MB jedoch etwas langsamer als die HTTP-Upload-Methode. Daher haben beide Übertragungsmethoden ihre eigenen Vorteile. Den Lesern wird empfohlen, entsprechend ihren eigenen Umständen zu handeln. Wenn Sie Fragen haben oder den Quellcode anderer Teile benötigen, kontaktieren Sie mich bitte!