Zusammenfassung
In diesem Artikel wird die Oracle-Datenbank als Beispiel verwendet, um eine einfache und universelle Methode zur Speicherung und Verarbeitung von Formulardaten bei der Entwicklung von WEB-Anwendungen mithilfe der JSP-Technologie vorzustellen, um den Entwicklungsaufwand zu reduzieren und den Hauptprogrammcode bereitzustellen.
Einführung
Die J2EE-Technologie (Java 2 Enterprise Edition) ist in der Webanwendungsentwicklung weit verbreitet. Die JavaBean- und Servlet-Technologien bieten Entwicklern eine klarere Entwicklungsumgebung, und die Servlet-Technologie wird zum Vervollständigen einer großen Anzahl von Seiten verwendet Geschäftsprozesse, Verwendung von Beans zum Speichern von Daten und einigen Geschäftsverarbeitungen. In WEB-Anwendungen ist die Verarbeitung von Geschäftsdaten in der Datenbank oft sehr mühsam. Eines der Hauptformulare ist das Speichern von Formulardaten in der Datenbank. Der gesamte Anwendungsverarbeitungsprozess umfasst eine große Anzahl solcher Datenspeichervorgänge Das Formular muss verarbeitet werden. Es kostet Entwickler viel Zeit und Energie, das entsprechende Datenspeicherprogramm separat zu schreiben. Es lohnt sich, die Frage zu untersuchen, mit welchen Methoden der Entwicklungsaufwand für die Formulardatenspeicherung verringert werden kann.
Zwei gängige Methoden zur Speicherung und Verarbeitung von Formulardaten:
1. Schreiben Sie den entsprechenden Programmcode für jedes Formular
in die JSP-Seite oder in JavaBean oder Servlet. Verwenden Sie die Funktion request.getparameter(), um die vom Formular übermittelten Daten einzeln zu extrahieren, oder schreiben Sie die Verwenden Sie die setProperty-Methode, um die Daten automatisch in die JavaBean abzurufen, generieren Sie dann SQL-Anweisungen (Einfügen, Aktualisieren, Löschen) und führen Sie schließlich die Funktion „executeupdate()“ aus, um die Datentabellenspeicherung abzuschließen.
2. Generieren Sie automatisch einen JavaBean-Programmcode für jede Datentabelle.
Das Datenbanksystem muss Benutzer dabei unterstützen, die Tabellenstruktur zu lesen und Schlüsselfelder zu identifizieren. Verwenden Sie objektorientierte Schnellentwicklungstools wie PowerBuilder, Delphi usw., um ein Programm zur automatischen Generierung von Java-Code zu entwickeln. In diesem Programm wird die Struktur der Datenbanktabelle gelesen: Feldname, Datentyp, Datenlänge und automatisch ein JavaBean-Code generiert. Definieren Sie in diesem Code Variablen mit denselben Namen, die den Feldern in der Tabelle entsprechen, richten Sie die Methoden setValue und getValue für alle Variablen ein und richten Sie Einfüge-, Aktualisierungs- und Löschfunktionen ein, um die Generierung und Ausführung von SQL-Anweisungen zum Einfügen, Aktualisieren, bzw. löschen.
Schreiben Sie auf der vom Formular übermittelten Datenverarbeitungsseite den folgenden Code, um die Formulardaten in JavaBean zu speichern:
<jsp: useBean id="table" class="table1_bean" /＞
＜jsp:setProperty name="table" property="*" /＞
(Hinweis: table1_bean ist das automatisch generierte JavaBean, das einer bestimmten oben genannten Tabelle entspricht.)
Rufen Sie dann die Funktionen zum Einfügen, Aktualisieren und Löschen in table1_bean auf, um die Speicherung der Datentabelle abzuschließen und die Ausführungsergebnisse zurückzugeben. wie:
<%boolean success =table.insert(); %>
Die erste Methode ist einfach und intuitiv, aber Sie müssen für jedes Formular ein entsprechendes Datenverarbeitungsprogramm schreiben. Bei etwas größeren Anwendungen kann die Anzahl der Formulare groß sein, was zu einem hohen Entwicklungsaufwand und einer geringen Entwicklungseffizienz führt. Wenn sich die Tabellenstruktur ändert, beispielsweise das Hinzufügen oder Entfernen von Feldern, muss das entsprechende Datenverarbeitungsprogramm geändert werden.
Die zweite Methode ist viel einfacher als die erste. Die Datenverarbeitung jeder Datentabelle wird automatisch generiert und muss nicht neu geschrieben werden JavaBean und überschreiben Sie es nach dem Kompilieren mit Java. Die ursprüngliche Java-Klasse kann verwendet werden. Diese Methode erfordert jedoch die Entwicklung eines automatischen JavaBean-Generierungsprogramms, und JavaBeans müssen neu generiert und kompiliert werden, wenn sich die Tabellenstruktur ändert.
Einführung einer einfachen und universellen Methode zum Speichern von Formulardaten
bei der Entwicklung von WEB-Anwendungen. Viele Formulare werden nach einer einfachen Datenüberprüfung im Front-End-Browser an den Backend-Server übermittelt. Der Server führt keine Verarbeitung der Daten durch und speichert die Daten direkt darin eine Datenbank. In diesem Fall können wir einfach ein Programm schreiben, um diese Formulare einheitlich zu verarbeiten und die Daten in einer entsprechenden Datentabelle zu speichern. Diese Methode erfordert außerdem, dass das Datenbanksystem das Lesen der Tabellenstruktur und die Identifizierung von Schlüsselfeldern unterstützt. Wir verwenden JSP-Technologie, um dieses Programm zu schreiben, und die Programmdatei heißt DbdataStore.jsp.
1. Aufrufformat
Die Aktionsaufrufmethode des Formulars auf der Webseite lautet wie folgt:
<Form Name=Frm1 Method=Post Action="DBdataStore.jsp? tablename=table1&OperType=…">
table1 ist der Tabellenname der Datenbanktabelle wo die Daten gespeichert werden und die OperType-Operation Es gibt drei Typen: Einfügen, Aktualisieren und Löschen.
Die Namenswerte in <input type=text name=…>, <textarea name=…><select name=…> im Formular sollten mit den Feldnamen der Datentabelle übereinstimmen Formulare werden einzeln in DBdataStore.jsp extrahiert. Wenn im Formular keine Eingabe definiert ist und der resultierende Wert ein Nullwert ist, wird das Feld nicht verarbeitet.
2. Ansichtsdefinition am Beispiel von Oracle
1) Erstellen Sie eine Datentypansicht für jede Spalte der Tabelle.
CREATE OR REPLACE VIEW v_dbstru AS SELECT table_name, columns_name, data_type, data_length, data_precision, data_scale, columns_id
FROM all_tab_columns WHEREowner='user1'; //user1 ist der Besitzer der Datentabelle.
2) Erstellen Sie die Schlüsselspaltenansicht der Tabelle
CREATE OR REPLACE VIEW v_pkey_column AS
SELECT b.table_name, b.column_name, b.position
VON all_constraints a, all_cons_columns b
WHERE a.owner=b.owner AND a.constraint_name=b.constraint_name AND a.owner='user1' AND a.constraint_type='P';
3. Hauptprogrammcode
1) Programminitialisierung
String tablename=request.getParameter(" tablename"); //Tabellennamen extrahieren
String OperType=request.getParameter("OperType"); //Operationstyp extrahieren
String sFieldValue="";//Speichert den vom Formular übermittelten Felddatenwert
String fieldname="", Datatype="" //Speicherfeldname, Felddatentyp
int iFieldvalue=0;
String updateSql="", whereSql=" where ", insSql1="", insSql2="", opSql="", strSql="";
ResultSet rs1=null, rs2=null;
insSql1="insert into "+tablename+" (";
insSql2="values(";
2) Generieren Sie den Schlüsselfeldteil der SQL-Anweisung
und den Schlüsselfeldteil der Einfügeanweisung, z. B.: insert into table1(id and changes(100))
; Generieren Sie die Aktualisierungs- und Löschanweisung mit Teilen, z. B.: wobei id=100 ist;
wenn der Vorgangstyp „aktualisieren“ ist, werden die Daten der Schlüsselfelder im Webformular nicht geändert.
rs1=Stmt.executeQuery("SELECT columns_name FROM v_pkey_column WHERE table_name='"+tablename+"'");
while(rs1.next()){
fieldname=rs1.getString("column_name");
rs2=Stmt.executeQuery("SELECT data_type FROM v_dbstru WHERE table_name='"+tablename+"' AND columns_name='"+fieldname+"'"); //Den Schlüsselfelddatentyp abrufen if(rs2.next()){
Datentyp=rs2.getString("data_type");
sFieldValue=request.getParameter(fieldname.toLowerCase());
//Generieren Sie den Schlüsselfeldteil der Einfügeanweisung if(OperType.equals("insert")){
insSql1+=fieldname+",";
if((sFieldValue==null) ){
//Wenn der Datenwert des Schlüsselfelds nicht im Formular übermittelt wird, wird er in diesem Artikel nur als numerischer Typ verarbeitet und der Datenwert wird anhand der Seriennummer berechnet.
rs2= Stmt.executeQuery("SELECT max("+fieldname+")+1 FROM "+tablename();next(); ; }else if(Datatype.equals("DATE")){
insSql2+= "To_Date('" + sFieldValue + "','YYYY-MM-DD'),";
}else if(Datatype.equals("VARCHAR2") || Datatype.equals("CHAR")){
insSql2+="'" + sFieldValue+"',";}
else /*NUMBER, FLOAT */ insSql2+=sFieldValue+","}
//Aktualisierungs- und Löschanweisung generieren, wobei Teil: wobei Feldname=... UND
if(OperType.equals("update") || OperType.equals("delete")){
if(Datatype.equals("DATE")){
whereSql+=fieldname+"=To_Date('" + sFieldValue + "','YYYY-MM-DD') AND ";
}else if(Datatype.equals("VARCHAR2") || Datatype.equals("CHAR")){
whereSql+=fieldname+"='" + sFieldValue+"' AND ";}
else /*NUMBER, FLOAT */ whereSql+=fieldname+"="+ sFieldValue+" AND ";}
}
}
whereSql=whereSql.substring(0, whereSql.length()-4);
3) Die SQL-Anweisung des Nicht-Schlüsselfeldteils generiert
eine Aktualisierungsanweisung, wie zum Beispiel: update table1 set columns1=value1,... where id= 100
Einfügeanweisung, wie zum Beispiel: insert into table1(id, columns1,…)values(100, value1,…)
updateSql="update "+tablename+" set ";
strSql="SELECT columns_name, data_type, data_length, data_precision, data_scale FROM v_dbstru a "+"where table_name='"+tablename+"' AND a.column_name not in (SELECT b.column_name FROM v_pkey_column b where b.table_name=a.table_name )";
rs1=Stmt.executeQuery(strSql); // Feldnamen und Datentyp von Nicht-Schlüsselfeldern abrufen
while(rs1.next()){
fieldname=rs1.getString("column_name"); Datatype=rs1.getString("data_type"); sFieldValue=request.getParameter(fieldname.toLowerCase()); //Wenn das Formular den Wert des Feldes nicht übermittelt, ignorieren das Feld Processing if((sFieldValue!=null)){
//Einfügeanweisung generieren =insSql1+insSql2, also in Tabellenname(… und Werte(…) einfügen
if(OperType.equals("insert")){ insSql1+=fieldname+",";
if(Datatype.equals("DATE")){
insSql2+= "To_Date('" + sFieldValue + "','YYYY-MM-DD'),";
} else if(Datatype.equals("VARCHAR2") || Datatype.equals("CHAR")){
insSql2+="'" + sFieldValue+"',";}else /*NUMBER,FLOAT*/ insSql2+= sFieldValue+",";}
//Update-Anweisung generieren=updateSql+whereSql, also Tabellennamensatz aktualisieren... wobei Feldname=... if(OperType.equals("update")){
if(Datatype.equals("DATE")){
updateSql+=fieldname+"=To_Date('" + sFieldValue + "','YYYY-MM-DD'),";
}else if(Datatype.equals("VARCHAR2") || Datatype.equals("CHAR")){
updateSql+=fieldname+"='" + sFieldValue,1}+"',";}else /*NUMBER,FLOAT*/ updateSql+=fieldname+"="+sFieldValue+",";}))
rs1.close();
4) Generieren Sie eine vollständige SQL-Anweisung und führen Sie
if(OperType.equals("insert"))
aus
opSql=insSql1.substring(0, insSql1.length()-1)+")"+insSql2.substring(0, insSql2.length()-1)+"";
if(OperType.equals("update"))
opSql=updateSql.substring(0, updateSql.length()-1)+" "+whereSql; if(OperType.equals("delete"))
opSql="delete FROM "+tablename+" "+whereSql;
//Die vollständige SQL-Anweisung opSql wurde generiert
try{sqlnrows=Stmt.executeUpdate(opSql);}
Catch(SQLException e){out.println("SQLException:"+opSql);}
4. Funktionen
Diese Methode verwendet dieses Programm einheitlich für alle solchen direkt gespeicherten Formulare. Sie ist universell und muss nicht für jedes Formular oder jedes verwendet werden Das entsprechende Programm wird unabhängig für die Datentabelle entwickelt. Der Entwicklungsaufwand ist sehr gering und der Aufruf ist sehr einfach. Wenn sich gleichzeitig die Tabellenstruktur ändert, muss das Programm DBdataStore.jsp nicht geändert werden. Dieses Programm kann auch als Servelet umgeschrieben werden und das Aufrufformat ist <Form Name=Frm1 Method=Post Action="DBdataStoreServelet?tablename=table1&OperType=…">.
Fazit
Wenn in einer Webanwendung die Formulardaten nach der Übermittlung eine weitere Datenüberprüfung oder -verarbeitung im Serverhintergrund erfordern, muss die zweite Methode verwendet werden. In vielen Fällen geben Benutzer jedoch Daten in das Formular ein oder ändern sie, verwenden JavaScript, um die Daten einfach im Front-End-Browser zu überprüfen oder zu verarbeiten, und übermitteln sie dann. Es erfolgt keine Verarbeitung auf dem Back-End-Server und die übermittelten Daten durch das Formular wird direkt in der Datenbank in einer Tabelle gespeichert. Derzeit ist die Verwendung der dritten Methode sehr einfach und kann die Arbeitsbelastung des Entwicklers erheblich reduzieren.