Detaillierte Erläuterung der zugrunde liegenden Kapselung der Java-Verbindung zu MySQL

Paket com.dao.db;

importiere java.sql.Connection;
importiere java.sql.SQLException;

/**
 * Datenbankverbindungsschicht MYSQL
 * @author Administrator
 *
 */
öffentliche Klasse DBConnection {
 
 
 /**
  * Mit Datenbank verbinden * @return
  */
 öffentliche statische Verbindung getDBConnection()
 {
  // 1. Treiber registrieren try {
   Klasse.fürName("com.mysql.jdbc.Driver");
  } Fang (ClassNotFoundException e) {
   // TODO Automatisch generierter Catch-Block
   e.printStackTrace();
  }
  // Holen Sie sich die Datenbankverbindung try {
   Verbindung conn = java.sql.DriverManager.getConnection("jdbc:mysql://localhost/mysql?useUnicode=true&characterEncoding=utf-8", "root", "root");
   Rückverbindung;
  } Fang (SQLException e1) {
   e1.printStackTrace();
  }
  gibt null zurück;
 }
 
}

Paket com.dao.db;

importiere java.sql.Connection;
importiere java.sql.PreparedStatement;
importiere java.sql.ResultSet;
importiere java.sql.ResultSetMetaData;
importiere java.sql.SQLException;
importiere java.sql.Types;
importiere java.util.ArrayList;
importiere java.util.HashMap;

/**
 * MySQL-Datenbank zugrunde liegende Kapselung * @author Administrator
 *
 */
öffentliche Klasse DBManager {
 
 privates PreparedStatement pstmt;
 private Verbindung conn;
 privates Ergebnisset rs;
 

 /**
  *Öffne die Datenbank */
 öffentlicher DBManager() {
  conn = DBConnection.getDBConnection();
 }
 
 /**
  * Änderungs- und Additionsoperationen durchführen * @param coulmn
  * @param-Typ
  * @param sql
  * @zurückkehren
  * @throws SQLException
  */
 öffentliches boolean updateOrAdd(String[] coulmn, int[] type, String sql) löst SQLException aus
 {
  if(!setPstmtParam(Spalte, Typ, SQL))
   gibt false zurück;
  Boolesche Flagge = pstmt.executeUpdate()>0?true:false;
  DB schließen();
  Flagge zurückgeben;
 }
 /**
  * Abfrageergebnissatz abrufen * @param coulmn
  * @param-Typ
  * @param sql
  * @throws SQLException
  */
 öffentliche DataTable getResultData(String[] coulmn, int[] type, String sql) löst SQLException aus
 {
  Datentabelle dt = neue Datentabelle();
  
  ArrayList<HashMap<String, String>>Liste = neue ArrayList<HashMap<String, String>>();
  
  if(!setPstmtParam(Spalte, Typ, SQL))
   gibt null zurück;
  rs = pstmt.executeQuery();
  ResultSetMetaData rsmd = rs.getMetaData(); //Spaltennamen der Datenbank abrufen int numberOfColumns = rsmd.getColumnCount();
  während(rs.next())
  {
   HashMap<String, String> rsTree = neue HashMap<String, String>(); 
   für (int r = 1; r <AnzahlSpalten + 1; r++)
    {
    rsTree.put(rsmd.getColumnName(r),rs.getObject(r).toString());
    }
   Liste.add(rsTree);
  }
  DB schließen();
  dt.setDataTable(Liste);
  dt zurückgeben;
 }
 
 /**
  * Parametereinstellungen * @param coulmn
  * @param-Typ
  * @throws SQLException 
  * @throws NumberFormatException 
  */
 privater boolean setPstmtParam(String[] coulmn, int[] type, String sql) wirft NumberFormatException, SQLException
 {
  wenn (sql == null) false zurückgibt;
  pstmt = conn.prepareStatement(sql);
  wenn(coulmn != null und Typ != null und coulmn.length !=0 und Typ.length !=0)
  {  
   für (int i = 0; i<Typ.Länge; i++) {
    Schalter (Typ[i]) {
    Falltypen.INTEGER:
     pstmt.setInt(i+1, Integer.parseInt(coulmn[i]));
     brechen;
    Falltypen.BOOLEAN:
     pstmt.setBoolean(i+1, Boolean.parseBoolean(coulmn[i]));
     brechen;
    Falltypen.CHAR:
     pstmt.setString(i+1, Spalte[i]);
     brechen;
    Falltypen.DOUBLE:
     pstmt.setDouble(i+1, Double.parseDouble(coulmn[i]));
     brechen;
    Falltypen.FLOAT:
     pstmt.setFloat(i+1, Float.parseFloat(coulmn[i]));
     brechen;
    Standard:
     brechen;
    }
   }
  }
  gibt true zurück;
 }
 
 /**
  * Schließen Sie die Datenbank * @throws SQLException
  */
 private void closeDB() wirft SQLException
 {
  wenn(rs != null)
  {
   rs.schließen();
  }
  wenn(pstmt != null)
  {
   pstmt.schließen();
  }
  wenn(conn != null)
  {
   Verbindung schließen();
  }
  
 }
}

Paket com.dao.db;

importiere java.util.ArrayList;
importiere java.util.HashMap;
importiere java.util.Iterator;
importiere java.util.Map;
importiere java.util.Set;

/**
 * Datensatzkapselung * @author Administrator
 *
 */
öffentliche Klasse DataTable {
 
 public String[] column; //Spaltenfeld public String[][] row; //Zeilenwert public int rowCount = 0; //Anzahl der Zeilen public int colCoun = 0; //Anzahl der Spalten public DataTable() {
  super();
 }
 
 öffentliche DataTable(String[] Spalte, String[][] Zeile, int Zeilenanzahl, int Spaltenanzahl) {
  super();
  diese.Spalte = Spalte;
  diese.Zeile = Zeile;
  dies.rowCount = Zeilenanzahl;
  dies.colCoun = colCoun;
 }


 public void setDataTable(ArrayList<HashMap<String, String>> Liste) {
  Zeilenanzahl = Liste.Größe();
  colCoun = list.get(0).size();
  Spalte = neuer String[colCoun];
  Zeile = neuer String[Zeilenanzahl][Spaltenanzahl];
  für (int i = 0; i < Zeilenanzahl; i++) {
   Set<Map.Entry<String, String>> set = list.get(i).entrySet();
   } j = 0;
   für (Iterator<Map.Entry<String, String>> es = set.iterator(); es
     .hasNext();) {
    Map.Entry<String, String> Eintrag = (Map.Entry<String, String>) es
      .nächste();
    Zeile[i][j] = Eintrag.getValue();
    wenn (i == Zeilenanzahl - 1) {
     Spalte[j] = Eintrag.getKey();
    }
    }
   }
  }
 }

 öffentliche String[] getColumn() {
  Rückgabespalte;
 }

 public void setColumn(String[] Spalte) {
  diese.Spalte = Spalte;
 }

 öffentliche String[][] getRow() {
  Zeile zurückgeben;
 }

 öffentliche void setRow(String[][] Zeile) {
  diese.Zeile = Zeile;
 }

 öffentliche int getRowCount() {
  gibt Zeilenanzahl zurück;
 }

 öffentliche void setRowCount(int rowCount) {
  dies.rowCount = Zeilenanzahl;
 }

 öffentliche int getColCoun() {
  RückgabespalteCoun;
 }

 public void setColCoun(int colCoun) {
  dies.colCoun = colCoun;
 }
 
 

}

Paket com.bussiness.test;

importiere java.sql.SQLException;
importiere java.sql.Types;

importiere com.dao.db.DBManager;
importiere com.dao.db.DataTable;

öffentliche Klasse TestBusiness{
 
 statische Zeichenfolge searchSql = "Wählen Sie * aus der Punktzahl aus";
 statischer String insertSql = "einfügen in Punktzahl(Name, Alter, Punktzahl)Werte(?,?,?)";
 statischer String deleteSql = "aus Partitur löschen, wo ID = ?";
 statischer String updateSql = "Scoreset-Name aktualisieren = ? wobei ID = ?";
 
 öffentliche statische void main(String[] args) {
  intsertData();
  Suchdaten();
 }
 
 private statische void intsertData()
 { 
  DBManager dm = neuer DBManager();
  String[] Spalte = neuer String[]{"wyf2", "23", "89.5"};
  int[] Typ = neuer int[]{Typen.CHAR, Typen.INTEGER, Typen.DOUBLE};
  
  versuchen {
   Boolesche Flagge = dm.updateOrAdd(coulmn, type, insertSql);
   wenn(Flagge)
    System.out.println("Erfolgreich eingefügt");
  } Fang (SQLException e) {
   e.printStackTrace();
  }
 }
 private static void suchdaten()
 { 
  DBManager dm = neuer DBManager();
  String[] Spalte = null;
  int[] Typ = null;
  
  versuchen {
   DataTable dt = dm.getResultData(Spalte, Typ, Suchtabelle);
   wenn(dt != null && dt.getRowCount() > 0){   
    für (int i = 0; i<dt.getRowCount(); i++)
    {
     für (int j = 0; j<dt.getColCoun(); j++)
     System.out.printf(dt.getRow()[i][j]+"\t");
     System.out.println();
    }
   }
   anders
    System.out.println("Abfrage fehlgeschlagen");
  } Fang (SQLException e) {
   e.printStackTrace();
  }
 }
}