English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

  1. Location
  2. Home page
  3. Experience notes
  4. Main text

Analyse der Gründe, warum der Inhalt nicht gefunden werden kann, wenn JavaWeb dbutils SQL-Befehle ausführt und das Ergebnisset durchsucht

The reason why you can't find the content when executing SQL commands and traversing the result set with JAVAWEB dbutils, and the solution is as follows:

When traversing the result set, only bean objects are traversed to output the first line content (the first line is the output of an instance of the UserEntity class), so re.getRepoTableName() is needed here to call the corresponding content through the object

Auf diese Weise kann der Wert abgerufen werden

PS: Eine detaillierte Erklärung von JavaWeb_DBUtils wie folgt:

Eins: Was ist DBUtils und welche Funktion hat es

　　DBUtils wurde von der Apache Company geschrieben. DBUtils ist ein praktisches Werkzeug für Datenbankoperationen in Java-Programmierung, klein und einfach zu bedienen.

　　DBUtils verpackt die JDBC-Operationen und vereinfacht die JDBC-Operationen. Man kann weniger Code schreiben.

　　1.Für die Leseoperationen auf Datenbanktabellen kann er die Ergebnisse in List, Array, Set und andere Java-Kollektionen umwandeln, was die Programmierung erleichtert;

　　2.Für die Schreiboperationen auf Datenbanktabellen wird es sehr einfach (es reicht aus, sql-Anweisungen zu schreiben)

　　3.Man kann Datenquellen, JNDI, Datenbankverbindungspools und andere Technologien verwenden, um die Leistung zu optimieren--Wiederverwendung bereits erstellter Datenbankverbindung

Zwei: Die drei Kernobjekte von DBUtils

　　2.1、QueryRunner-Klasse

　　　　QueryRunner bietet API für die sql-Anweisung Operation. Es gibt hauptsächlich drei Methoden: query() zum Ausführen von select, update() zum Ausführen von insert update delete, batch() Batch-Verarbeitung. Im Folgenden werde ich detailliert die Verwendung dieser Methoden erläutern.

　　2.2、ResultSetHandler-Schnittstelle

　　　　Wird verwendet, um zu definieren, wie Result-Sets nach der select-Operation verpackt werden. Es gibt insgesamt9eine häufig verwendete Implementierungsklasse, ich werde Ihnen detailliert erläutern, wie man sie verwendet.

　　2.3、DbUtils-Klasse

　　　　Es ist ein Werkzeugklasse, die Methoden zur Schließung von Ressourcen und Transaktionsverarbeitung definiert

Drei: Wie verwendet man das DBUtils-Framework

　　3.1、Verwendungsschritte

　　　　Importieren Sie die entsprechenden jar-Pakete

　　　　Erstellen Sie ein QueryRunner-Objekt

　　　　　 Verwenden Sie den query-Methoden, um select-Anweisungen auszuführen

　　　　　 Verwenden Sie ResultSetHandler, um Result-Sets zu verpacken

　　　　　 Verwenden Sie die Klasse DbUtils, um Ressourcen freizugeben

　　3.2、实例

　　　　Anmerkung: Ich verwende C3P0-Verbindungspool

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.junit.Test;
import com.jxlg.domain.User;
public class TestSelect {
 @Test
 public void testSelect(){
 //Erstellen Sie ein QueryRunner-Objekt
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 try {
  // new ResultSetHandler<List<User>> zeigt uns, wie man Result-Sets verpackt
  List<User> list = qr.query("select * from user", new ResultSetHandler<List<User>>(){
  @Override
  //Nachdem ein query-Statement ein select-Statement ausgeführt hat, wird das Ergebnis in Form eines Rückgabewerts übermittelt
  public List<User> handle(ResultSet rs) throws SQLException {
   List<User> list = new ArrayList<User>();
   while(rs.next()){
   User u = new User();
   u.setId(rs.getInt(1));
   u.setUsername(rs.getString(2));
   u.setPassword(rs.getString(3));
   u.setEmail(rs.getString(4));
   u.setBirthday(rs.getDate(5));
   list.add(u);
   }
   return list;
  }
  });
  for (User user : list) {
  System.out.println(user);
  }
 } catch (SQLException e) {
  e.printStackTrace();
 }
}
 @Test
 public void testSelect2(){
 //Erstellen Sie ein QueryRunner-Objekt
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 try {
  //Führt ein SQL-Statement aus und gibt das Ergebnis zurück
  List<User> list = qr.query("select * from user where id=? und username=?, new BeanListHandler<User>(User.class),1,"tom");
  for (User user : list) {
  System.out.println(user);
  }
 } catch (SQLException e) {
  e.printStackTrace();
 }
 }
}

Viertel: Detaillierte Erklärung der drei Kernobjekte von DBUtils

　　4.1、QueryRunner-Objekt

　　　　4.1.1、Konstruktor

　　　　　　　　 new QueryRunner(); Seine Transaktionen können manuell kontrolliert werden.　　　　　　　　　　　　　　　　　　　　

Das bedeutet, dass der auf diesen Objekt aufgerufene Methoden (z.B. query, update, batch) ein Connection-Objekt im Parameter benötigen.

　　　　　　　　　　 new QueryRunner(DataSource ds); Seine Transaktionen werden automatisch kontrolliert. Eine SQL-Anweisung, eine Transaktion.　　　　 　　　　　　　　　　　　　　　　　　　　　　

Der auf diesen Objekt aufgerufene Methoden (z.B. query, update, batch) benötigen kein Connection-Objekt.

　　　　4.1.2、gebräuchliche Methoden　

　　

　　　　　　　　

　　　　　　　　

　　　　　　　　

　　4.2、ResultSetHandler-Schnittstelle

　　　　4.2.1、es hat9Ein Ergebnisverarbeitungsmodul

　　　　　　ArrayHandler: Suitable for1record. Each column value of the record is encapsulated into an array of Object[]
　　　　　　ArrayListHandler: Suitable for retrieving multiple records. Each record's column values are encapsulated into an array of Object[], and the array is encapsulated into a List
　　　　　　ColumnListHandler: Ermittelt die Daten einer bestimmten Spalte. Verpackt in eine Liste.
　　　　　　KeyedHandler: Ermittelt mehrere Zeilen, jede Zeile wird in einen Map verpackt und dieser Map wird wiederum in eine andere Map verpackt, der Schlüssel ist der Wert des angegebenen Felds.
　　　　　　MapHandler: Geeignet für das Abrufen1Zeilen. Die Spaltennamen und -werte des aktuellen Zeilens werden in einen Map gelegt
　　　　　　MapListHandler: Geeignet für das Abrufen mehrerer Zeilen. Jede Zeile wird in einen Map verpackt und dieser Map wird in eine Liste verpackt
　　　　　　ScalarHandler: Geeignet für das Abrufen von Einzeldaten einer Einheit
　　　　　　BeanHandler
　　　　　　BeanListHandler

　　　　4.2.2、实例　　　　　　　

import static org.junit.Assert.*;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayHandler;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.ColumnListHandler;
import org.apache.commons.dbutils.handlers.KeyedHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.junit.Test;
import com.jxlg.domain.User;
public class TestResultSetHandler {
 @Test
 public void test1() {
 //ArrayHandler: Suitable for1record. Each column value of the record is encapsulated into an array of Object[]
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 try {
  Object[] o = qr.query("select * from user where id=?", new ArrayHandler(),5);
  for (Object object : o) {
  System.out.println(object);
  }
 } catch (SQLException e) {
  e.printStackTrace();
 }
 }
 @Test
 public void test2() throws SQLException {
 //ArrayListHandler: Suitable for retrieving multiple records. Each record's column values are encapsulated into an array of Object[], and the array is encapsulated into a List
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 List<Object[]> list = qr.query("select * from user", new ArrayListHandler());
 for (Object[] objects : list) {
  for (Object object : objects) {
  System.out.println(object);
  }
  System.out.println("----------------------");
 }
 }
 @Test
 public void test3() throws SQLException {
 //ColumnListHandler: Geeignet für das Abrufen eines bestimmten Spaltenwerts. Verpackt in eine Liste.
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 List<Object> list = qr.query("select username,password from user ", new ColumnListHandler(1));
 for (Object object : list) {
  System.out.println(object);
 } 
 }
 @Test
 public void test4() throws SQLException {
 //KeyedHandler: Geeignet für das Abrufen mehrerer Zeilen, jede Zeile wird in einen Map verpackt,
 //Legen Sie diesen Map dann in einen anderen Map ein, deren Schlüssel der Wert des angegebenen Felds ist.
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 //Der Schlüssel des großen Maps ist ein Spaltenwert der Tabelle, der Schlüssel des kleinen Maps ist der Spaltenname der Tabelle. Daher wird der Schlüssel des großen Maps als Object-Typ und der des kleinen Maps als String verwendet.
 Map<Object, Map<String, Object>> map = qr.query("select * from user", new KeyedHandler(1));
 for (Map.Entry<Object, Map<String, Object>> m : map.entrySet()) {
  System.out.println(m);//bedeutet id, da "1”.
  for (Map.Entry<String, Object> mm : m.getValue().entrySet()) {
  System.out.println(mm);//Abholen der Keys und Values aus dem kleinen Map
  }
  System.out.println("--------------------");
 }
 }
 @Test
 public void test5() throws SQLException {
 //MapHandler: Geeignet für das Abrufen1Zeilen. Die Spaltennamen und -werte des aktuellen Zeilens werden in einen Map gelegt
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 Map<String, Object> map = qr.query("select * from user", new MapHandler());
 for (Map.Entry<String, Object> m : map.entrySet()) {
  System.out.println(m.getKey())+"\t"+m.getValue());
  //Standardmäßig werden die Daten der ersten Zeile abgerufen, um andere Zeilen mit WHERE-Bedingungen zu filtern
 }
 }
 @Test
 public void test6() throws SQLException {
 //MapListHandler: Geeignet für das Abrufen mehrerer Zeilen. Jede Zeile wird in einen Map verpackt und dieser Map wird in eine Liste verpackt
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 List<Map<String, Object>> list = qr.query("select * from user", new MapListHandler());
 for (Map<String, Object> map : list) {
  for (Map.Entry<String, Object> m : map.entrySet()) {
  System.out.println(m); 
  }
  System.out.println("-----------");
 }
 }
 @Test
 public void test7() throws SQLException {
 //ScalarHandler: Geeignet für das Abrufen von Einzeldaten einer Einheit
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 Object o = qr.query("select * from user", new ScalarHandler(2));
 System.out.println(o);
 } 
 @Test
 public void test8() throws SQLException {
 //BeanHandler: Geeignet für das Abrufen von Einzeldaten einer Einheit
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 User user = qr.query("select * from user", new BeanHandler<User>(User.class));
 System.out.println(user);
 } 
}

Fünf, ein Beispiel für ein Hinzufügen, Löschen, Ändern und Suchen mit DBUtils　　

import static org.junit.Assert.*;
import java.sql.SQLException;
import java.util.Date;
import javax.crypto.spec.OAEPParameterSpec;
import org.apache.commons.dbutils.QueryRunner;
import org.junit.Test;
public class TestInCURD {
 @Test
 public void testInsert() {
 //Erstellen Sie ein QueryRunner-Objekt
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 try {
  qr.update("insert into user (username,password,email,birthday)values(",63;,?,?,?)", "guapi", "4646","[email protected]",new Date());
 } catch (SQLException e) {
  e.printStackTrace();
 }
 }
 @Test
 public void testUpdate() {
 //Erstellen Sie ein QueryRunner-Objekt
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 try {
  qr.update("update user set username=",63;,password=",63; where id=4 ", "meizimeizi", "520520");
 } catch (SQLException e) {
  e.printStackTrace();
 }
 }
 @Test
 public void testDelete() {
 //Erstellen Sie ein QueryRunner-Objekt
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 try {
  qr.update("delete from user where id=",63; ",}}4);
 } catch (SQLException e) {
  e.printStackTrace();
 }
 }
 @Test
 public void testBatch() {
 //Erstellen Sie ein QueryRunner-Objekt
 QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
 try {
  Object[][] params = new Object[10]]; //hochdimensionale Variable bedeutet, wie oft ein SQL-Befehl ausgeführt wird
  for(int i =0;i<params.length;i++){
  params[i] =new Object[]{"guapi"+i,"4646","[email protected]",new Date()}); 
  }
  qr.batch("insert into user (username,password,email,birthday)values(?,?,?,?)", params );
 } catch (SQLException e) {
  e.printStackTrace();
 }
 }
}

Zusammenfassung

Die oben genannten sind die von mir vorgestellten Gründe für die Analyse, warum der JavaWeb dbutils-SQL-Befehl und das Durchsuchen des Ergebnissatzes nicht auf Inhalte zugreifen kann. Ich hoffe, dass dies für alle von Nutzen ist. Wenn Sie Fragen haben, hinterlassen Sie bitte eine Nachricht, ich werde rechtzeitig antworten. Ich danke auch sehr für die Unterstützung der Anleitung!

Erklärung: Der Inhalt dieses Artikels wurde aus dem Internet übernommen und gehört dem Urheberrecht des Urhebers. Der Inhalt wurde von Internetbenutzern freiwillig bereitgestellt und hochgeladen. Diese Website besitzt keine Eigentumsrechte und hat den Inhalt nicht manuell bearbeitet. Sie übernimmt auch keine rechtlichen Verantwortlichkeiten. Wenn Sie Inhalte finden, die möglicherweise urheberrechtlich geschützt sind, sind Sie herzlich eingeladen, eine E-Mail an notice#w zu senden.3codebox.com (Bitte ersetzen Sie # durch @, wenn Sie eine E-Mail senden, und geben Sie bitte relevante Beweise an. Sobald nachgewiesen wird, dass Inhalte urheberrechtlich geschützt sind, wird diese Website die betreffenden Inhalte sofort löschen.)

Grund教程
Gefällt mir