JBuilder2005 tatsächliche JSP-Umschaltsteuerung (3)

Autor：Eve Cole Aktualisierungszeit：2009-07-02 17:10:13

Da switch.jsp über das Aktionsattribut im login.jsp-Formular als Antwort-JSP-Datei angegeben wird, sendet der Client eine HTTP-Anfrage an, wenn der Benutzer den Anmeldebenutzer in login.jsp auswählt und das Kennwort zum Senden des Formulars eingibt Der Server und der Server rufen also switch.jsp auf, um auf diese Anfrage zu antworten.

Die Daten der Benutzernamen- und Passwortkomponenten im Formular werden über eine HTTP-Anfrage an switch.jsp des Servers übergeben. Der Server kapselt diese Informationen im Anforderungsobjekt und übergibt sie an switch.jsp, damit switch.jsp abgerufen werden kann durch request.getParameter(String paraName) Holen Sie sich diese beiden Werte.

String userId = request.getParameter("userId");
Stringpasswort = request.getParameter("password");

Stellen Sie sich vor, wenn die Form von login.jsp mehr als 10 Datenkomponenten enthält, muss ihr Wert über die entsprechende Anzahl von request.getParameter()-Methoden in switch.jsp abgerufen werden. Wenn es sich bei den Daten außerdem nicht um einen Feldzeichenfolgentyp, sondern um eine Ganzzahl oder eine Gleitkommazahl handelt, muss die Typkonvertierung nicht nur durchgeführt werden, da es sich bei den von der Methode request.getParameter () zurückgegebenen Werten ausschließlich um Zeichenfolgen handelt mühsam, aber auch fehleranfällig.

Mit JSP können Sie Webformulardaten über Bean auf Mapping-Weise empfangen. Bean ordnet Formulardaten gemäß dieser Regel zu: Bean-Attributname = Name der Formulardatenkomponente, d. h. alle Formulardatenfelder mit demselben Bean-Attributnamen werden automatisch ausgefüllt die Bean und schließen Sie die Datentypkonvertierung ab. Beispielsweise gibt es im login.jsp-Formular zwei Datenkomponenten, eine mit dem Namen „userId“ und die andere mit dem Namen „password“. Definieren Sie eine User.java-Bean mit den gleichen Namensattributen „userId“ und „password“. im Formular Datenkomponentenwert.

Schreiben Sie User.java

Schreiben wir zunächst die User.java-Bean und erstellen User.java im Projekt. Der Code lautet wie folgt:

Codeauflistung 7 User.java

1. Paketbuchhandlung;
2.
3. Benutzer der öffentlichen Klasse
4. {
5. privater String userId;//userId
6. privater String passwort;//passwort
7. privater String userName;//username
8. öffentlicher String getPassword() {
9. Passwort zurückgeben;
10. }
11. öffentlicher String getUserId() {
12. Benutzer-ID zurückgeben;
13. }
14. öffentlicher String getUserName() {
15. Benutzername zurückgeben;
16. }
17. public void setPassword(String password) {
18. this.password = Passwort;
19. }
20. public void setUserId(String userId) {
21. this.userId = userId;
zweiundzwanzig.}
23. public void setUserName(String userName) {
24. this.userName = userName;
25. }
26. }

Zusätzlich zu den beiden Attributnamen „userId“ und „password“ gibt es auch ein Benutzernamenattribut „userName“. Der Wert dieses Attributs wird nicht aus dem login.jsp-Formular empfangen. Wenn der Benutzername und das Passwort korrekt überprüft werden, wird der Benutzername aus den Daten ermittelt Die T_USER-Tabelle wird in der Tabelle T_USER gespeichert und in diesen Eigenschaften gespeichert, sodass an anderer Stelle darauf verwiesen werden kann. Speichern und kompilieren Sie diese Klasse.

Hinweis:

Sie können User.java-Code schnell mit dem Bean Express-Tool erstellen. Unter normalen Umständen sollten Sie Bean-Eigenschaften automatisch generieren, sondern auch die Namenskonventionen für Beans sicherstellen.

Seitenprogramm schreiben

Nachdem wir das Bean von User.java erstellt haben, fahren wir mit der Erstellung von switch.jsp fort und verweisen auf dieses Bean in switch.jsp.

Starten Sie den Assistenten zum Erstellen von JSPs über Datei -> Neu -> Web -> Doppelklicken Sie auf das JSP-Symbol.

1. Geben Sie den Namen switch.jsp an

Abbildung 10 Geben Sie den Namen von switch.jsp an

Drücken Sie weiterhin auf „Weiter“, um zu Schritt 3 des Assistenten zu gelangen.

2. Referenz User.java Bean

Abbildung 11 Geben Sie die Bean an, auf die in JSP verwiesen wird

Klicken Sie auf die Schaltfläche „Bean hinzufügen...“, um das Dialogfeld „Klasse auswählen“ aufzurufen. Wählen Sie im Dialogfeld die Klasse „bookstore.User“ aus, wie in der folgenden Abbildung dargestellt:

Abbildung 12 Wählen Sie die Klasse „Bean“ aus

Nachdem Sie auf „OK“ geklickt haben, kehren Sie zum Dialogfeld in Schritt 3 des Assistenten zurück. Zu diesem Zeitpunkt gibt es eine zusätzliche Zeile mit Datensätzen in der Bean-Liste des Dialogfelds. Sie können einen Namen für das Bean in der Spalte „ID“ angeben Der Umfang der Bean im Bereich, wie in der folgenden Abbildung gezeigt:

Abbildung 13 Referenz auf eine Bean

Wir haben das User's Bean userBean genannt und seinen Geltungsbereich auf die Seitendomäne festgelegt. Die Seitendomäne ist der Seitenbereich und im Bereich der aktuellen Seite verfügbar. Wenn die JSP eine Antwort zurückgibt oder die Anforderung an andere JSP-Seiten übertragen wird, ist sie nicht mehr verfügbar.

·Anforderungsbereich: Wenn eine Anforderung generiert wird, ist sie innerhalb des Bereichs gültig, bis die Antwort zurückgegeben wird. Beispielsweise wird eine Bean in a.jsp als Anforderungsbereich deklariert, wenn a.jsp die Anforderung an die b.jsp-Seite weiterleitet Es ist noch Mitte des Jahres verfügbar.

·Sitzungsumfang: Er ist innerhalb des Zyklus der Benutzersitzung verfügbar. Der Sitzungszyklus erstreckt sich von der Anmeldung des Benutzers am System bis zu seiner Abmeldung vom System.

·Anwendungsbereich: Dieser Bereich ist der längste und zeigt an, dass der Webcontainer gültig ist, bis er gestartet und geschlossen wird.

Drücken Sie Weiter, um zum nächsten Schritt zu gelangen.

3． Legen Sie laufende Konfigurationselemente fest

Im letzten Schritt des Assistenten können Sie ein Laufzeitkonfigurationselement für die erstellte JSP generieren. Obwohl der Assistent die Erstellung eines Laufzeitkonfigurationselements als Standardoption festlegt, ist dies meiner Meinung nach kein sinnvoller Standardwert Erstellen Sie ein Laufzeitkonfigurationselement, erstellen Sie kein JSP-Ausführungskonfigurationselement, wie in der folgenden Abbildung dargestellt:

Klicken Sie auf die Schaltfläche „Fertig stellen“, um die Datei „switch.jsp“ mit dem folgenden Code zu erstellen:

Codeauflistung 8 switch.jsp, erstellt vom Assistenten

1. ＜%@ page contentType="text/html; charset=GBK" %＞
2. ＜html＞
3. ＜Kopf＞
4. ＜Titel＞
5.Schalter
6. ＜/Titel＞
7. ＜/Kopf＞
8. ＜jsp:useBean id="userBean" Scope="page" class="bookstore.User" /＞
9. ＜jsp:setProperty name="userBean" property="*" /＞
10. ＜body bgcolor="#ffffff"＞
11. 12. Von JBuilder generierte JSP
13. ＜/h1＞
14. ＜/Körper＞
15. ＜/html＞

Zeile 8 ist das JSP-Tag, das auf die Bean verweist. Zeile 9 füllt die Attributwerte der Bean mit den Formulardaten, dh füllt die Anforderungsparameter durch Namensübereinstimmung in die Attribute der Bean und schließt gleichzeitig die Typkonvertierung ab grundlegende Datentypen oder Die Konvertierung kann nur abgeschlossen werden, wenn der Konstruktor dies unterstützt). Nach der Ausführung von Zeile 9 werden die Attribute „userId“ und „password“ in userBean auf die Werte des Benutzernamens und des Passworts gesetzt, die auf der Seite login.jsp gesendet wurden.

Da switch.jsp nur zur Steuerung verwendet wird und dem Client keinen Inhalt anzeigen muss, entfernen wir den HTML-Code in switch.jsp und passen switch.jsp wie folgt an:

Codeauflistung 9 switch.jsp nach dem Entfernen des statischen HTML-Codes

1. ＜%@ page contentType="text/html; charset=GBK" %＞
2. ＜jsp:useBean id="userBean" Scope="page" class="bookstore.User" /＞
3. ＜jsp:setProperty name="userBean" property="*" /＞

Stellen Sie in switch.jsp ein Scriptlet bereit, um die Benutzer-ID und das Kennwort an die Datenbank zu senden und sie mit den Benutzern in der T_USER-Tabelle zu vergleichen, um festzustellen, ob es sich um legitime Benutzer handelt, und um basierend auf den Überprüfungsergebnissen auf andere Seiten umzuleiten. Der endgültige Code von switch.jsp sieht folgendermaßen aus:

Codeauflistung 10 Final switch.jsp

1. ＜%@page contentType="text/html; charset=GBK"%＞
2. ＜%@page import="bookstore.*"%＞
3. ＜%@page import="java.sql.*"%＞
4. ＜jsp:useBean id="userBean" Scope="session" class="bookstore.User"/＞
5. ＜jsp:setProperty name="userBean" property="*"/＞
6,＜%
7. Verbindung conn = null;
8. Versuchen Sie es mit {
9. conn = DBConnection.getConnection();
10. PreparedStatement pStat = conn.prepareStatement(
11. „wählen Sie USER_NAME aus T_USER aus, wobei USER_ID=? und Passwort = ?“);
12. pStat.setString(1, userBean.getUserId());
13. pStat.setString(2, userBean.getPassword());
14. ResultSet rs = pStat.executeQuery();
15. if (rs.next()) { //Passwort ist korrekt
16. userBean.setUserName(rs.getString(1));//Benutzernamen festlegen
17. session.setAttribute("ses_userBean", userBean);//UserBean in das Session-Objekt einfügen
18. %＞＜jsp:forward page=" willkommen.jsp "＞＜/jsp:forward＞
19. ＜%} else { //Falsches Passwort%＞
20. ＜jsp:forward page="fail.jsp"＞＜/jsp:forward＞
21,＜%
22. }} endlich {
23. if(conn != null) conn.close();
vierundzwanzig.}
25. %＞

·Führen Sie in den Zeilen 2 bis 3 die im Scriptlet-Code benötigten Klassen ein.

·Zeilen 7 bis 14 des Codes senden Abfrage-SQL-Anweisungen an die Datenbank und geben die Ergebnisse zurück.

·Zeile 15 bestimmt indirekt, ob das Benutzerkennwort korrekt ist, indem sie die Anzahl der Datensätze im Ergebnissatz überprüft.

· Die Zeilen 16 bis 18 sind die Antwortcodes für korrekte Benutzerkennwörter. Füllen Sie zunächst den Attributwert „userName“ der UserBean mit dem Attribut „USER_NAME“ der Ergebnismenge, fügen Sie dann das UserBean-Objekt in die Sitzung ein und wechseln Sie schließlich zur Seite „Welcome.jsp“.

·Wenn der Benutzer ein falsches Passwort eingibt, gibt es keinen Datensatz in der Ergebnismenge. Zu diesem Zeitpunkt gibt rs.next() „false“ zurück und das Programm wechselt zu Zeile 20. Der Code in Zeile 20 leitet die Seite auf die falsche Seite um Seite zur Verarbeitung der Passworteingabe fail.jsp.

·Der Code in den Zeilen 22 bis 24 dient zum Schließen der Datenbankverbindung.

Vielleicht haben Sie festgestellt, dass die Zeilen 9 bis 21 zwar eine SQLException auslösen, wir jedoch keinen entsprechenden Ausnahmeabfangblock haben. In einem Standard-Java-Programm führt dies jedoch zu einem Fehler bei der Kompilierung. In JSP kann dies jedoch sequentiell kompiliert werden Dies liegt daran, dass die JSP-Seite selbst alle auf der Seite ausgelösten Ausnahmen abfängt.

Gehen Sie davon aus, dass in der SQL-Abfrageanweisung in Zeile 11 ein Fehler vorliegt, z. B. wenn der Name der Benutzertabelle fälschlicherweise als Benutzer (korrekterweise T_USER) geschrieben wird. Wenn switch.jsp aufgerufen wird, wird in Zeile 14 eine SQLException ausgelöst und switch. jsp zeigt die Tracking-Informationsseite des Ausnahme-Stack-Trace wie folgt an:

Abbildung 14: Die Seite zur schrecklichen Fehlerbehandlung

Die im Bild oben gezeigte Fehlerbehandlungsseite kann als grün, wild und sehr unfreundlich beschrieben werden. Diese Art von Fehlerberichtsseite mag für Entwickler geeignet sein, da sie viele Informationen zur Fehlerverfolgung bereitstellt, aber das ist unmöglich Benutzer akzeptieren diese Art von Fehlerseite. Eine unhöfliche Fehlerseite. Mit JSP können Sie über <%@ page errorPage%> eine JSP-Seite speziell für die Fehlerbehandlung angeben, sodass Fehler in einer benutzerfreundlichen und intuitiven Form angezeigt werden können. Im nächsten Abschnitt erstellen wir eine JSP-Seite zur Fehlerbehandlung. Nach der Erstellung geben wir die JSP-Seite zur Fehlerbehandlung für switch.jsp an.