ASP (Active Server Page) ist ein Produkt von Microsoft, da es einfach zu programmieren ist und schnell dynamische Websites mit leistungsstarken Funktionen entwickeln kann. Viele Websites (insbesondere Intranet-/Extranet-Intranets) übernehmen jetzt das NT+IIS+ASP-Modell, was ASP zum aktuell Die beliebtere Skriptsprache für die Website-Entwicklung. In WEB-Diensten ist der Datei-Upload-Dienst eine sehr häufige Funktion, aber PWS unter WIN9X stellt keine entsprechenden Komponenten bereit; IIS unter NT stellt einen Beitrag bereit Akzeptable Komponente, die jedoch nicht einfach zu verwenden ist, da sie die WWW-Zugriffsrechte des Benutzers überprüft. Sie können verwandte Komponenten auch aus dem Internet herunterladen. Bei den meisten davon handelt es sich jedoch um kommerzielle Komponenten, bei denen es sich um Testversionen handelt Zeit- oder Funktionseinschränkungen vorliegen. Da ASP Standard-OLE/COM-Komponenten aufrufen kann, können wir erweiterte Programmiertools wie VB/VC/DELPHI verwenden, um unsere eigenen ASP-Datei-Upload-Komponenten entsprechend unseren eigenen Anforderungen anzupassen, um die Anforderungen unseres eigenen Anwendungssystems zu erfüllen.
Im Folgenden werden das Prinzip und der spezifische Implementierungsprozess der Verwendung von DELPHI zur Entwicklung von Datei-Upload-Komponenten für ASP erläutert.
1. Implementierungsprinzip des Datei-Uploads
Der webbasierte Daten-Upload muss dem RFC1867-Standard entsprechen, und hochgeladene Dateidaten bilden da keine Ausnahme. Verwenden Sie beispielsweise die folgende HTML-Seitendatei (delphiup.htm), um die Upload-Datei auszuwählen:
<!-- DelphiUp.htm: Datei-Upload-Schnittstelle -->
<html><head><title>Datei hochladen</title></head><body>
Implementieren Sie den Datei-Upload mit der in DELPHI geschriebenen Datei-Upload-Komponente
<form NAME="UploadForm" ACTION="delphiup.asp" METHOD="POST" ENCTYPE="multipart/form-data">
<p>Datei speichern unter: <input TYPE=text NAME="SaveAs">
<p>Bitte wählen Sie die hochzuladende Datei aus: <input TYPE=file NAME="FileData">
<input type="submit" name="b1" value="Upload bestätigen"> </p>
</form>
</body></html>
Wenn der Client eine Datei auswählt (z. B. Test.TXT, deren Inhalt „Hier ist der Inhalt einer Datei zum Hochladen“ lautet) und drückt
Nachdem die Schaltfläche „Upload bestätigen“ die Daten übermittelt hat, haben die vom serverseitigen Programm empfangenen Daten das folgende Format:
-------------------------7cf1d6c47c#13#10
Inhaltsdisposition: form-data; name="SaveAs"#13#10#13#10
NeuerDateiname#13#10
-------------------------7cf1d6c47c#13#10
Inhaltsdisposition: form-data; name="FileData"; filename="D: est.txt"
Inhaltstyp: Text/Plain#13#10#13#10
Hier ist der Inhalt einer Datei zum Hochladen. #13#10
-------------------------7cf1d6c47c#13#10
Inhaltsdisposition: form-data; name="b1"#13#10#13#10
Bestätigen Sie den Upload#13#10
-------------------------7cf1d6c47c--
Unter diesen ist „--------------------------------7cf1d6c47c“ das Trennzeichen, das zum Trennen der einzelnen Felder im Formular verwendet wird ( Bilden);
#13#10 ist die DELPHI-Darstellung von Wagenrücklauf- und Zeilenvorschubzeichen. Wir können es uns so vorstellen: Die Informationsbeschreibung jedes Formularfelds beginnt mit einem Trennzeichen plus einem Paar Wagenrückläufen und Zeilenvorschüben #13#10; der Formulardomänenname beginnt mit „name="“ und endet mit „"" ; das Formularfeld Der Wert beginnt mit zwei Paaren von Wagenrücklauf- und Zeilenvorschubzeichen #13#10#13#10 und endet mit einem Paar Wagenrücklauf- und Zeilenvorschubzeichen #13#10# plus einem Trennzeichen; beginnt mit „filename="“ und endet mit „"“ für das Ende. Mit diesen Flags können wir den Namen und Wert des Formularfelds sowie den Namen der hochzuladenden Datei abrufen, damit die Dateidaten gelesen und gespeichert werden können.
2. Implementierungsprozess des Datei-Uploads
Nachdem wir das oben erwähnte Datenformat verstanden haben, ist es für uns nicht mehr schwierig, selbst eine Datei-Upload-Komponente zu schreiben.
(1) Starten Sie ein Projekt zum Erstellen einer ASP-Komponente
Wenn Sie mit den Schritten zur Verwendung von DELPHI zur Entwicklung eines OLE-Automatisierungsservers nicht vertraut sind, lesen Sie bitte den Artikel „Using DELPHI to development OLE Automation Server for ASP“ in „Electronics and Computers“, Ausgabe 06, 1999.
Hier stellen wir die Schritte nur kurz vor.
1. Erstellen Sie ein ActiveX-Bibliotheksprojekt
Wählen Sie in DELPHI das Menü Datei = „Neu ...“ und wählen Sie „ActiveX-Bibliothek“ auf der Registerkarte „ActiveX“ des Dialogfelds „Neues Element“. DELPHI erstellt dann automatisch ein DLL-Projekt PRoject1.
2. Erstellen Sie Automatisierungskomponenten
Wählen Sie in DELPHI das Menü „Datei="Neu...", wählen Sie „Automatisierungsobjekt“ auf der Registerkarte „ActiveX“ des Dialogfelds „Neues Element“ und geben Sie dann den Klassennamen (z. B. „UploadFile“) in den „Automatisierungsobjekt-Assistenten“ ein "Dialogfeld, Instanzierung wählen Sie „Mehrere Instanz". Nachdem Sie auf „OK“ geklickt haben, erstellt DELPHI automatisch eine TLB-Datei (Type Library) Project1_TLB.PAS und eine PAS-Datei (Unit) Unit1.PAS. Benennen Sie im Designfenster der Typbibliothek Project1 in MyUpload um. Der OLE-Registrierungscode der Datei-Upload-Komponente lautet dann „MyUpload.UploadFile“.
3. Einführung der ASP-Typbibliothek
Um die fünf integrierten Objekte von ASP (Anfrage, Antwort, Server, Anwendung, Sitzung) verwenden zu können, muss die ASP-Typbibliothek eingeführt werden. Wir verwenden das Request-Objekt hauptsächlich zum Lesen der vom Client an den Server übergebenen Daten.
Wählen Sie „Typbibliothek importieren“ im Projektmenü und wählen Sie „Microsoft Active Server Pages-Objektbibliothek (Version)“ in der Liste „Typbibliotheken“ des Dialogfelds „Typbibliothek importieren“. 2.0)“ (Wenn diese Option nicht verfügbar ist, stellen Sie bitte sicher, dass IIS3 oder höher oder PWS4 oder höher auf Ihrem Computer installiert ist und ASP.DLL korrekt registriert wurde), D ELPHI erstellt automatisch eine TLB-Datei ASPTypeLibrary_TLB.PAS, die die von uns benötigte ASP-Objekttypdeklaration enthält.
4. Definieren Sie die Prozesse OnStartPage und OnEndPage
Wenn Sie Server.CreateObject verwenden, um eine OLE-Objektinstanz auf einer ASP-Seite zu erstellen, ruft der WEB-Server seine Methode OnStartPage auf und übergibt die ASP-Anwendungsumgebungsinformationen an das Objekt. , können wir während dieses Prozesses die Client-Informationen abrufen; wenn eine OLE-Objektinstanz auf der ASP-Seite freigegeben wird, ruft der WEB-Server seine Methode OnEndPage auf und wir können während dieses Prozesses Endoperationen wie die Freigabe von Speicher durchführen. In unserer Komponente müssen wir ihre OnStartPage-Methode verwenden.
Die OnStartPage-Methode sollte in Unit1.PAS definiert werden. Der Funktionsprototyp von OnStartPage ist:
procedure OnStartPage(AScriptingContext: IUnknown);
Der Parameter AScriptingContext ist eine Variable vom Typ IScriptingContext, die fünf Attribute (Anfrage, Antwort, Server, Anwendung, Sitzung) enthält, die fünf integrierten Objekten mit demselben Namen in ASP entsprechen.
Wir müssen die Methode OnStartPage zu IUploadFile im TLB-Definitionsfenster (View="Type Library) hinzufügen, und ihre Deklarationsanweisung lautet „procedure OnStartPage(AScriptingContext: IUnknown);".
(2) Extrahieren Sie die vom Kunden hochgeladenen Daten
Diese Arbeit kann im OnStartPage-Prozess durchgeführt werden.
Mithilfe der Eigenschaft TotalBytes (Inhaltslänge der Anforderungsinformationen) und der Methode BinaryRead in der Eigenschaft Request (Typ IRequest) von AScriptingContext können die vom Client hochgeladenen Anforderungsinformationsdaten in ein Array vom Typ Byte und dann in das durch RFC1867 definierte Datenformat eingelesen werden Standard zum Analysieren und Extrahieren von Daten.
1. Definieren Sie zunächst mehrere private Variablen von TUploadFile
Fügen Sie einen Verweis auf ASPTypeLibrary_TLB.PAS (Uses) in der Unit-Datei UP01.PAS (gespeichert von Unit1.PAS) hinzu.
dann mach mit
Privat
FContentLength: LongInt; // Länge des Informationsinhalts anfordern
FContentData: Variant;// Inhaltsdaten, speichert den Inhalt der Anforderungsinformationen in Form eines Arrays
FFileName, //Der Name der hochzuladenden Datei
FDelimeter: string; //Formularfeldbegrenzer
FScriptingContext: IScriptingContext;//ASP verarbeitet Kontextinhalte
FFileDataStart, //Startposition der Dateidaten
FFileDataEnd: LongInt; //Endposition der Dateidaten
2. Extrahieren Sie die vom Kunden hochgeladenen Anforderungsinformationsdaten
//Im OnStartPage-Ereignis die ASP-Kontextinformationen, den Inhalt der Anforderungsinformationen, Formularfeldtrennzeichen und Dateidaten abrufen
procedure TUploadFile.OnStartPage(AScriptingContext: IUnknown);
var
ARequest: IRequest; //WWW-Anforderungsobjekt
AOleVariant: OleVariant; //Zeichnet die Länge des Anforderungsinformationsinhalts auf
intDelimterLength: integer;//Trennzeichenlänge
longIndex,ALongInt,longPos : LongInt;
ContentData: AnsiString;//String-Darstellung des Inhalts der Anforderungsinformationen
strTemp: string;
FindEndOfFileData: boolean;// Ob die Endposition der Dateidaten gefunden wird
beginnen
// Extrahieren Sie die vom Client hochgeladenen Anforderungsinformationsdaten
FScriptingContext := AScriptingContext as IScriptingContext;//ASP-Kontextinformationen abrufen
ARequest := FScriptingContext.Request;// WWW-Anfrageinformationen abrufen
FContentLength := ARequest.TotalBytes;//Länge des Informationsinhalts anfordern
// Erstellen Sie ein dynamisches Array, um den Inhalt der Anforderungsinformationen in Form eines Arrays zu speichern
FContentData := VarArrayCreate( [0,FContentLength], varByte );
//Speichern Sie den Inhalt der Anforderungsinformationen im Array
AOleVariant := FContentLength;
FContentData := ARequest.BinaryRead(AOleVariant);//Lesen Sie den Inhalt der Anforderungsinformationen
//Konvertieren Sie den Inhalt der Anforderungsinformationen zur einfachen Positionierung in eine Zeichenfolge
ContentData := ';
für longIndex := 0 bis FContentLength - 1 do
beginnen
ContentData := ContentData + chr( Byte( FContentData[ longIndex ] ));
if FContentData[ longIndex ] = 0 then break;//0 zeigt das Ende des Inhalts an
Ende;
3. Trennzeichen abrufen und Dateinamen hochladen
//Das Trennzeichen des Formularfelds abrufen
longPos := pos( #13#10,ContentData );//Die Position des Wagenrücklauf- und Zeilenvorschubzeichens
FDelimeter := Copy( ContentData,1,longPos-1);//Der Inhalt vor dieser Position ist das Trennzeichen
//Den Dateinamen mit Quellpfad abrufen. Im Inhalt der Anforderungsinformationen beginnt der Dateiname mit
//Speicher in der Form filename="path/filename"
strTemp := 'filename="';//Der Dateiname steht nach "filename=""
longPos := pos( strTemp, ContentData );//Holen Sie sich die Position „filename="“.
wenn longPos <= 0 dann
beginnen
FFileName := ';
FFileDataStart := -1;
FFileDataEnd := -2;
Ausfahrt;
Ende;
//Den Inhalt vor dem nächsten doppelten Anführungszeichen „“ abrufen, also den Dateinamen mit dem Quellpfad
longPos := longPos + length( strTemp );
strTemp := ';
für longIndex := longPos to FContentLength - 1 do
if ContentData[ longIndex ] <> '"' dann
strTemp := strTemp + ContentData[ longIndex ]
sonst brechen;
FFileName := strTemp;
4. Ermitteln Sie die Start- und Endpositionen der Dateidaten im Anforderungsinformationsinhalt
//Die Startposition der Dateidaten liegt nach dem ersten #13#10#13#10 nach dem Dateinamen
delete( ContentData, 1, longIndex );
strTemp := #13#10#13#10;
FFileDataStart := longIndex + pos(strTemp, ContentData) + length(strTemp) - 1;
//Die Endposition der Dateidaten liegt vor dem nächsten #13#10 und dem Trennzeichen
//Da die Dateidaten möglicherweise illegale Zeichen enthalten, kann die String-Positionierungsfunktion POS nicht mehr verwendet werden.
//Finde die Position des nächsten Trennzeichens
FFileDataEnd := FFileDataStart;
intDelimterLength := length( FDelimeter );
FindEndOfFileData := false;
while FFileDataEnd <= FContentLength - intDelimterLength do
beginnen
FindEndOfFileData := true;
für ALongInt := 0 bis intDelimterLength - 1 tun
if Byte( FDelimeter[ ALongInt + 1 ] ) <>
FContentData[FFileDataEnd + ALongInt] dann
beginnen
FindEndOfFileData := false;
brechen;
Ende;
if FindEndOfFileData then break;
FFileDataEnd := FFileDataEnd + 1;
Ende;
Wenn nicht FindEndOfFileData, dann FFileDataEnd := FFileDataStart - 1//Kein Trennzeichen gefunden
else FFileDataEnd := FFileDataEnd - 3;//Trennzeichen, vorwärts springen #13#10
Ende;
(3) Informationen an das ASP-Programm übertragen
Nach der Durchführung der Operation (2) kann unsere Upload-Komponente entsprechend ihren Anforderungen Daten an das ASP-Programm übergeben. Zu den derzeit verfügbaren Daten gehören: Name der Client-Quelldatei (FFileName, einschließlich Pfad), Dateigröße (FFileDataEnd-FFileDataStart+1).
Zunächst sollten die folgenden beiden Methoden GetFileName und GetFileSize im TLB-Designfenster deklariert werden.
1. Geben Sie den Namen der Client-Quelldatei (einschließlich Pfad) zurück.
//Name der Client-Quelldatei zurückgeben (einschließlich Pfad)
Funktion TUploadFile.GetFileName: OleVariant;
beginnen
result := FFileName;//Name der Client-Quelldatei (einschließlich Pfad)
Ende;
2. Dateigröße zurückgeben
//Dateigröße zurückgeben (Bytes)
Funktion TUploadFile.GetFileSize: OleVariant;
beginnen
Ergebnis := FFileDataEnd - FFileDataStart + 1;
Ende;
(4) Dateien speichern
Nach Ausführung des Vorgangs (2) kann unsere Upload-Komponente die Datei gemäß den Anforderungen des ASP-Programms speichern. Zuerst sollte es drin sein
Die folgenden beiden Methoden, SaveFileAs und SaveFile, werden im TLB-Designfenster deklariert.
1. Speichern Sie die Datei unter dem angegebenen Dateinamen
//Speichern Sie die Datei gemäß dem angegebenen Dateinamen. Der Parameter FileName ist der angegebene Dateiname. Der Rückgabewert True zeigt an, dass die Datei erfolgreich gespeichert wurde.
function TUploadFile.SaveFileAs(FileName: OleVariant): OleVariant;
var
longIndex : LongInt;
AFile: Byte-Datei;//Speichern Sie die Datei in binärer Form
byteData : Byte;
beginnen
Ergebnis := wahr;
versuchen
zuweisen(AFile, FileName);
rewrite(AFile);
for longIndex := FFileDataStart to FFileDataEnd do
beginnen
byteData := Byte( FContentData[ longIndex ] );
Write(AFile, byteData);
Ende;
CloseFile( AFile );
außer
Ergebnis := false;
Ende;
Ende;
2. Speichern Sie die Datei unter dem Standarddateinamen
//Speichern Sie die Datei gemäß dem Standarddateinamen und speichern Sie die Datei mit demselben Namen in dem Verzeichnis, in dem sich die aufrufende Seite befindet
Funktion TUploadFile.SaveFile: OleVariant;
var
CurrentFilePath: string;
beginnen
// Rufen Sie das Verzeichnis ab, in dem sich die aufrufende Seite befindet
CurrentFilePath := FScriptingContext.Request.ServerVariables['PATH_TRANSLATED'];
CurrentFilePath := ExtractFilePath( CurrentFilePath );
//Datei speichern
Ergebnis := SaveFileAs( CurrentFilePath + ExtractFileName( FFileName ));
Ende;
3. Anwendungsbeispiele für Upload-Komponenten
In unserem Beispiel ist DelphiUp.HTM die Datei-Upload-Schnittstelle und DelphiUp.ASP wird zum Ausführen von Datei-Upload-Vorgängen verwendet.
Der Code von DelphiUp.ASP lautet wie folgt:
<!--DelphiUp.ASP: Seite zur Verarbeitung des Datei-Uploads-->
<html><head><title>Datei hochladen</title></head><body>
<% dim Upload, Dateiname
set Upload = Server.CreateObject("MyUpload.UploadFile")
FileName = Upload.GetFileName
Response.Write „<br>Speichere die Datei „“&FileName&““…“
wenn Upload.SaveFile dann
Response.Write „<br>Die Datei „&FileName&“ wurde erfolgreich hochgeladen.“
Response.Write „<br>Die Dateigröße beträgt „&Upload.GetFileSize&“ Bytes.“
anders
Response.Write „<br>Datei „&FileName&“ konnte nicht hochgeladen werden.“
Ende wenn
set Upload=nothing %>
</body></html>
4. Einige Erklärungen
1. Die Größe der DLL-Datei, die aus dem von DELPHI automatisch generierten Quellcode kompiliert wurde, beträgt 215 KB
Löschen Sie im Abschnitt „Schnittstelle“ von ASPTypeLibrary_TLB.PAS alle Einheiten in „Uses“ außer ActiveX.
Durch das Löschen aller Einheiten in Uses in MyUpload_TLB.PAS kann die Größe der generierten DLL-Datei auf 61 KB reduziert werden.
2. Die obige Methode ist auch auf CGI-Programme anwendbar, es muss jedoch das TWebRequest-Objekt verwendet werden.
Das obige Programm wurde debuggt und unter PWIN98+Delphi3.0+PWS4.0 übergeben.