Bei der Entwicklung von Webanwendungen ist es ausnahmslos erforderlich, auf die Datenbank zuzugreifen, um Vorgänge wie das Abfragen, Einfügen, Aktualisieren und Löschen von Daten durchzuführen. Abhängig von der Anwendungslogik ist es manchmal erforderlich, mehrere Datenbankbetriebsanweisungen zu einer Arbeitseinheit (Transaktion) zusammenzufassen. In einer Datenbank bezieht sich eine Transaktion auf eine Reihe logischer Betriebseinheiten, die Daten von einem Zustand in einen anderen umwandeln. Um die Konsistenz der Daten in der Datenbank sicherzustellen, sollten die Daten in diskreten Gruppen logischer Einheiten bearbeitet werden: Wenn alles abgeschlossen ist, kann die Konsistenz der Daten aufrechterhalten werden, aber wenn ein Teil der Operation in der Einheit fehlschlägt, kann die gesamte Operation fehlschlagen Die Transaktion wird ignoriert, alle Vorgänge ab dem Startpunkt werden in den Startzustand zurückversetzt.
Tatsächlich ist jede Operation in der Datenbank standardmäßig implizit transaktional. In diesem Artikel werden anhand eines typischen Benutzerregistrierungsprogramms drei Methoden zur Verwendung von ASP zur Implementierung der Transaktionsverarbeitung vorgestellt: eine Lösung basierend auf ASP-Datenbankkomponenten, eine Lösung basierend auf dem Transaktionsverarbeitungsmechanismus innerhalb der Datenbank und eine Lösung basierend auf MTS-Komponenten .
Programmfunktionen
Erstellen Sie zwei Tabellen in der SQL Server-Datenbank: USER-Tabelle und USERDOC-Tabelle. In der USER-Tabelle werden der Benutzername und das Kennwort des registrierten Benutzers gespeichert, und in der USERDOC-Tabelle werden die persönlichen Informationen des registrierten Benutzers gespeichert, indexiert nach dem Benutzernamen. Im Folgenden finden Sie die Definition der Tabellen USER und USERDOC:
Tabelle erstellen USER(userName varchar(30),userPasswd varchar(30))
Tabelle erstellen USERDOC(userName varchar(30),Age int,Sex int,PhoneNumber varchar(20),Address varchar(50))
Wenn der Benutzer eine Registrierung anfordert, fügt das ASP-Skript zuerst den Benutzernamen und das Passwort in die USER-Tabelle ein und dann Geben Sie im USERDOC die persönlichen Daten des Benutzers (Alter, Geschlecht, Kontaktnummer, Privatadresse usw.) in die Tabelle ein. Gleichzeitig muss die Anwendung auch sicherstellen, dass jeder Datensatz in der USER-Tabelle über einen entsprechenden Datensatz in der USERDOC-Tabelle verfügt.
Methode 1 verwendet das Connection-Objekt in der in ASP integrierten ADO-Komponente, um die Transaktionsverarbeitung von Datenbankvorgängen zu implementieren. Einige Methoden des Connection-Objekts sind wie folgt:
●Connection.BeginTrans-Methode: Eine Transaktion starten;
●Connection.CommitTrans-Methode: Eine Transaktion abschließen/übermitteln;
●Connection.RollBackTrans-Methode: Eine Transaktion rückgängig machen/abbrechen.
//Eine Transaktionsoperation starten
<%Conn.BeginTrans%>
<% sqlText="Einfügen in USER(userName,userPasswd)-Werte('" %>
<% sqlText=sqlText & request("usrName") & "','"&request("usrPasswd")&"') " %>
<% conn.execute(sqlText) %>
<% wenn conn.Errors.Count>0 dann %>
<% conn.Errors.Clear %>
//Wenn der Vorgang zum Einfügen von Daten fehlschlägt, wird die Transaktion rückwärts ausgeführt
<% conn.RollBackTrans %>
<% Response.Redirect RegisterFail.html %>
<% end if %>
<% sqlText="Einfügen in USERDOC(userName,Age,Sex,PhoneNumber,Address) "%>
<% sqlText=sqlText & "values('"& request ("usrName") & "', " & request("Age") %>
<% sqlText=sqlText & ","'" & request ("PhoneNum") & "','" %>
<% sqlText=sqlText & request("Address") & "') " %>
//Führen Sie die zweite Einfügeanweisung in der Transaktionseinheit aus
<% conn.execute(sqlText) %>
<% wenn conn.Errors.Count>0 dann %>
<% conn.Errors.Clear %>
//Wenn der Vorgang fehlschlägt, wird die Transaktion rückgängig gemacht
<% conn.RollBackTrans %>
<% Response.Redirect RegisterFail.html %>
<% end if %>
//Wenn der gesamte Transaktionsvorgang korrekt ausgeführt wird, wird die Transaktion festgeschrieben
<% Conn.CommitTrans %>
//Gehen Sie zur Seite zur erfolgreichen Registrierungsverarbeitung
<% Response.Redirect RegisterOk.html %>
Methode 2 kann den Transaktionsverarbeitungsmechanismus innerhalb des Datenbanksystems verwenden, um die Transaktionsverarbeitung von Datenvorgängen abzuschließen, indem gespeicherte Prozeduren, die Transaktionen enthalten, in den Datenbankserver geschrieben werden. Gleichzeitig können Sie durch die Verwendung der ADO-Komponente zum Aufrufen der gespeicherten Prozedur auch anhand des Rückgabecodes der gespeicherten Prozedur feststellen, ob die Transaktion erfolgreich ausgeführt wurde.
In einem Datenbanksystem ist jede SQL-Anweisung eine Transaktion. Daher ist garantiert, dass jede Anweisung entweder abgeschlossen wird oder zum Anfang zurückkehrt. Wenn Sie jedoch möchten, dass die Vorgänge einer Reihe von SQL-Anweisungen entweder alle abgeschlossen oder alle ungültig sind, müssen Sie dazu den Transaktionsverarbeitungsmechanismus der Datenbank verwenden.
Der Hauptcode zum Generieren der gespeicherten Prozedur in der Datenbank lautet wie folgt:
Erstellen Sie proc RegisterUser (@usrName varchar(30), @usrPasswd varchar(30),@age int, @PhoneNum varchar(20), @Address varchar(50) ) als Anfang
//Definition anzeigen und eine Transaktion starten
Tran. beginnen
in USER(userName,userPasswd)-Werte einfügen(@usrName,@usrPasswd)
wenn @@error<>0
beginnen
//Wenn der Vorgang fehlschlägt, wird die Transaktion zurückgesetzt
Rollback-Trans
//Kehre zur gespeicherten Prozedur zurück und setze den Rückkehrcode auf einen Transaktionsvorgangsfehler
Rückgabe -1
Ende
in USERDOC einfügen (Benutzername, Alter, Geschlecht, Telefonnummer, Adresse)
Werte(@Benutzername,@Alter,@Telefonnummer,@Adresse)
wenn @@error<>0
beginnen
//Wenn der Vorgang fehlschlägt, wird die Transaktion zurückgesetzt
Rollback-Trans
Rückgabe -1
Ende
//Wenn die Operation korrekt ausgeführt wird, wird die Transaktion festgeschrieben
begehen tran
0 zurückgeben
Ende
Der Hauptcode zum Aufrufen der gespeicherten Datenbankprozedur im ASP-Skript lautet wie folgt:
<% Set Comm=server.CreateObject
("ADODB.Command") %>
<% Set Comm.ActiveConnection=conn %>
<% Comm.CommandType=adCmdStoredProc %>
<% Comm.CommandText="RegisterUser" %>
//Gespeicherte Prozedur erstellen, um Parameterobjekt zurückzugeben
<% Set RetCode=Comm.CreateParameter
("RetCode",adInteger,adParamReturnValue) %>
//Eingabeparameterobjekt für gespeicherte Prozeduren erstellen
<% Set usrName=Comm.CreateParameter ("usrName",adVarchar,adParamInput,30) %>
<% Set usrPwd=Comm.CreateParameter
("usrPasswd",adVarchar,adParamInput,30) %>
<% Set age=Comm.CreateParameter("age",adInteger,adParamInput) %>
<% Set PhoneNum=Comm.CreateParameter
("PhoneNum",adVarchar,adParamInput, 20) %>
<% Set Address=Comm.CreateParameter("Address",adVarchar,adParamInput,50) %>
<% Comm.Parameters.Append usrName %>
<% Comm.Parameters.Append usrPwd %>
<% Comm.Parameters.Append age %>
<% Comm.Parameters.Append PhoneNum %>
<% Comm.Parameters.Append Address %>
<% Comm.Parameters("usrName")=request("usrName") %>
<% Comm.Parameters("usrPasswd")=request("usrPasswd") %>
<% Comm.Parameters("age")=request("age") %>
<% Comm.Parameters("PhoneNum")=request("PhoneNum") %>
<% Comm.Parameters("Address")=request("Address") %>
<% Comm.Execute %>
<% RetValue=Cint(Comm("RetCode")) %>
//Bestimmen Sie anhand des Rückgabecodes der gespeicherten Datenbankprozedur, ob die Registrierung erfolgreich ist
<% wenn RetValue< 0 dann %>
<% Response.Redirect RegisterFail.html %>
<% sonst %>
<% Response.Redirect RegisterOk.html %>
<% end if %>
Methode 3: Bei Verwendung des Transaktionsverarbeitungsmechanismus der MTS-Komponente (Microsoft Transaction Server) zur Implementierung der Transaktionsverarbeitung sollte besonders darauf geachtet werden, dass Transaktionen unter diesem Mechanismus nicht mehrere ASP-Seiten umfassen können, wenn eine Transaktion Objekte von mehreren Komponenten erfordert , Sie müssen die Operationen für diese Objekte in einer ASP-Seite kombinieren.
Zuerst müssen Sie die @TRANSACTION-Direktive oben auf der Seite hinzufügen, um eine ASP-Seite als transaktional zu deklarieren.
Die @TRANSACTION-Direktive muss in der ersten Zeile einer Seite stehen, andernfalls wird ein Fehler generiert. Wenn die ASP-Skriptverarbeitung auf der Seite endet, endet die aktuelle Transaktion.
<%@ TRANSACTION=Erforderliche Sprache=
VBScript%>
//Ereignis wurde durch Transaktionsausführung erfolgreich ausgelöst
<% Sub OnTransactionCommit() %>
<% Response.Redirect RegisterOk.html %>
<% End Sub %>
//Ereignis wird ausgelöst, wenn die Ausführung fehlschlägt
<% Sub OnTransactionAbort() %>
<% Response.Redirect RegisterFail.html %>
<% End Sub %>
<% sqlText="Einfügen in USER(userName,userPasswd)-Werte('" %>
<% sqlText=sqlText & request("usrName") & "','" &request("usrPasswd")&"') " %>
<% conn.execute(sqlText) %>
<% wenn conn.Errors.Count>0 dann %>
<% conn.Errors.Clear %>
<% ObjectContext.SetAbort %>
<% end if %>
<% sqlText="Einfügen in USERDOC(userName,Age,Sex,PhoneNumber,Address) "%>
<% sqlText=sqlText & "values('" & request("usrName")& "', " & request("Age") %>
<% sqlText=sqlText & ","'" & request("PhoneNum") & "','" %>
<% sqlText=sqlText & request("Address") & "') " %>
<% conn.execute(sqlText) %>
<% wenn conn.Errors.Count>0 dann %>
<% conn.Errors.Clear %>
<% ObjectContext.SetAbort %>
<% end if %>
<% ObjectContext.SetComplete %>
Die Lösung ist flexibler. Die Verwendung von ASP-Datenbankkomponenten bietet bestimmte Vorteile: Sie können ADO-Datenbankkomponenten verwenden, um die Transaktionsverarbeitung abzuschließen, und Sie können auch Ihre eigenen Datenbankkomponenten entsprechend den tatsächlichen Anforderungen anpassen (sofern sie der ASP-Komponente entsprechen). Schreiben von Spezifikationen) Kann). Wenn Sie die Zuverlässigkeit der Datenbanktransaktionsverarbeitung berücksichtigen, ist es besser, die in der Datenbank gespeicherte Transaktionsverarbeitungsprozedur zu verwenden. Auf diese Weise kann der Datenbanktransaktionsmechanismus direkt verwendet werden, um die logische Transaktionsverarbeitung der Anwendung abzuschließen, was sicher und zuverlässig ist und die Dateninteraktion zwischen dem Webserver und dem Datenbankserver reduziert. Dies ist besonders wichtig für verteilte Datenbanksysteme. Der Vorteil der Transaktionsverarbeitungsmethode unter Verwendung von MTS-Komponenten besteht darin, dass der MTS-Server den Abschluss und das Rückgängigmachen von Komponentenvorgängen (in MTS registrierten Komponenten) direkt steuert und verwaltet. Er verfügt über gute Erweiterungsraum- und Anwendungsaussichten und kann die technischen Möglichkeiten voll ausschöpfen Vorteile von MTS. Verbessern Sie die Fehlertoleranzleistung von Netzwerkanwendungen und verbessern Sie die dynamische Leistung von IIS-Webservern.