碼上歡樂
相關內容    簡體    繁體

#數據庫#連接數據庫的幾個步驟

本文轉載自   查看原文   2018-03-14 15:58   3216    數據庫

  1. 轉載請注明出處，謝謝http://blog.csdn.net/harryweasley/article/details/45689023
    2. •創建一個以JDBC連接數據庫的程序，包含7個步驟：   

    1.  1、加載JDBC驅動程序：   
    1.     在連接數據庫之前，首先要加載想要連接的數據庫的驅動到JVM（Java虛擬機），   這通過java.lang.Class類的靜態方法forName(String  className)實現。   
    2.     例如：   
    3.    
      [java]  view plain  copy
       
      1. try{     
      2.    //加載MySql的驅動類     
      3.    Class.forName("com.mysql.jdbc.Driver") ;     
      4.    }catch(ClassNotFoundException e){     
      5.    System.out.println("找不到驅動程序類 ，加載驅動失敗！");     
      6.    e.printStackTrace() ;     
      7.    }     
    4.    成功加載后，會將Driver類的實例注冊到DriverManager類中。
    6.  不同數據庫廠商的驅動類名不同
      Oracle10g：oracle.jdbc.driver.OracleDriver
      MySQL5：com.mysql.jdbc.Driver
      SQLServer2005：com.microsoft.sqlserver.jdbc.SQLServerDriver   

    1.  2、提供JDBC連接的URL   
    1.    •連接URL定義了連接數據庫時的協議、子協議、數據源標識。   
    2.     •書寫形式：協議：子協議：數據源標識   
    3.     協議：在JDBC中總是以jdbc開始   
    4.     子協議：是橋連接的驅動程序或是數據庫管理系統名稱。   
    5.     數據源標識：標記找到數據庫來源的地址與連接端口。   
    7.     例如：（MySql的連接URL）   
    8. [java]  view plain  copy
       
      1. jdbc:mysql://localhost:3306/test? ;     

    9. 不同數據庫產品的連接URL不同
      Oracle10g：jdbc:oracle:thin:@主機名:端口:數據庫SID
      jdbc:oracle:thin:@localhost:1521:ORCL
      MySQL5：jdbc:mysql://主機名:端口/數據庫名
      jdbc:mysql://localhost:3306/test
      SQLServer2005：jdbc:sqlserver://主機名:端口:DatabaseName=庫名
      jdbc:sqlserver://localhost:1433:DatabaseName=BookDB
      數據庫的用戶名和密碼

  1.  3、創建數據庫的連接   
  1.     •要連接數據庫，需要向java.sql.DriverManager請求並獲得Connection對象，該對象就代表一個數據庫的連接。   
  2.     •使用DriverManager的getConnectin(String url , String username ,  String password )方法傳入指定的欲連接的數據庫的路徑、數據庫的用戶名和   密碼來獲得。   
  3.      例如：   
  4.     
    [java]  view plain  copy
     
    1. //連接MySql數據庫，用戶名和密碼都是root     
    2.     String url = "jdbc:mysql://localhost:3306/test" ;      
    3.     String username = "root" ;     
    4.     String password = "root" ;     
    5.     try{     
    6.    Connection con =      
    7.             DriverManager.getConnection(url , username , password ) ;     
    8.     }catch(SQLException se){     
    9.    System.out.println("數據庫連接失敗！");     
    10.    se.printStackTrace() ;     
    11.     }     

  1.  4、創建一個Statement   
  1.     •要執行SQL語句，必須獲得java.sql.Statement實例，Statement實例分為以下3 種類型：   
  2.       1、執行靜態SQL語句。通常通過Statement實例實現。   
  3.       2、執行動態SQL語句。通常通過PreparedStatement實例實現。   
  4.       3、執行數據庫存儲過程。通常通過CallableStatement實例實現。   
  5.     具體的實現方式：   
  6.      
    [java]  view plain  copy
     
    1. Statement stmt = con.createStatement() ;     
    2.     PreparedStatement pstmt = con.prepareStatement(sql) ;     
    3.     CallableStatement cstmt =      
    4.                          con.prepareCall("{CALL demoSp(? , ?)}") ;     

  1.  5、執行SQL語句   
  1.     Statement接口提供了三種執行SQL語句的方法：executeQuery 、executeUpdate 和execute   
  2.     1、ResultSet executeQuery(String sqlString)：執行查詢數據庫的SQL語句，返回一個結果集（ResultSet）對象。   
  3.      2、int executeUpdate(String sqlString)：用於執行INSERT、UPDATE或 DELETE語句以及SQL DDL語句，如：CREATE TABLE和DROP TABLE等   
  4.      3、execute(sqlString):用於執行返回多個結果集、多個更新計數或二者組合的語句。   
  5.    具體實現的代碼：   
  6.    
    [java]  view plain  copy
     
    1. ResultSet rs = stmt.executeQuery("SELECT * FROM ...") ;     
    2.    int rows = stmt.executeUpdate("INSERT INTO ...") ;     
    3.    boolean flag = stmt.execute(String sql) ;     

  1.  6、處理結果   
  1.     兩種情況：   
  2.      1、執行更新返回的是本次操作影響到的記錄數。   
  3.      2、執行查詢返回的結果是一個ResultSet對象。   
  4.     • ResultSet包含符合SQL語句中條件的所有行，並且它通過一套get方法提供了對這些   
  5.       行中數據的訪問。   
  6.     • 使用結果集（ResultSet）對象的訪問方法獲取數據：   
  7.    
    [java]  view plain  copy
     
    1. while(rs.next()){     
    2.        String name = rs.getString("name") ;     
    3.   String pass = rs.getString(1) ; // 此方法比較高效     
    4.    }     
  8.     （列是從左到右編號的，並且從列1開始）   

  1.  7、關閉JDBC對象    
  1.      操作完成以后要把所有使用的JDBC對象全都關閉，以釋放JDBC資源，關閉順序和聲明順序相反：   
  2.      1、關閉記錄集   
  3.      2、關閉聲明   
  4.      3、關閉連接對象   
[java]  view plain  copy
 
  1. if(rs != null){   // 關閉記錄集     
  2.      try{     
  3.          rs.close() ;     
  4.      }catch(SQLException e){     
  5.          e.printStackTrace() ;     
  6.      }     
  7.        }     
  8.        if(stmt != null){   // 關閉聲明     
  9.      try{     
  10.          stmt.close() ;     
  11.      }catch(SQLException e){     
  12.          e.printStackTrace() ;     
  13.      }     
  14.        }     
  15.        if(conn != null){  // 關閉連接對象     
  16.       try{     
  17.          conn.close() ;     
  18.       }catch(SQLException e){     
  19.          e.printStackTrace() ;     
  20.       }     
  21.        }  


 

8、實例：JdbcUtils

我將他們封裝到一個類中，並進行了測試。代碼中解釋很詳細，我就不再進行解釋了。

[java]  view plain  copy
 
  1. package com.jdbc.dbutils;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.DriverManager;  
  5. import java.sql.PreparedStatement;  
  6. import java.sql.ResultSet;  
  7. import java.sql.ResultSetMetaData;  
  8. import java.sql.SQLException;  
  9. import java.util.ArrayList;  
  10. import java.util.HashMap;  
  11. import java.util.List;  
  12. import java.util.Map;  
  13.   
  14. public class JdbcUtils {  
  15.     /** 
  16.      * 數據庫的用戶名 
  17.      */  
  18.     private final String USER = "root";  
  19.     /** 
  20.      * 數據庫的密碼 
  21.      */  
  22.     private final String PASSWORD = "123456";  
  23.     /** 
  24.      * 數據庫的驅動信息 
  25.      */  
  26.     private final String DRIVER = "com.mysql.jdbc.Driver";  
  27.     /** 
  28.      * 訪問數據庫的地址 
  29.      */  
  30.     private final String URL = "jdbc:mysql://localhost:3306/test";  
  31.     /** 
  32.      * 數據庫的連接 
  33.      */  
  34.     Connection connection;  
  35.     /** 
  36.      * sql語句的執行對象 
  37.      */  
  38.     PreparedStatement preparedStatement;  
  39.     /** 
  40.      * 查詢返回的結果集合 
  41.      */  
  42.     ResultSet resultSet;  
  43.   
  44.     public JdbcUtils() {  
  45.         try {  
  46.             Class.forName(DRIVER);  
  47.             System.out.println("注冊驅動成功");  
  48.         } catch (ClassNotFoundException e) {  
  49.             e.printStackTrace();  
  50.         }  
  51.     }  
  52.   
  53.     /** 
  54.      * 連接數據庫 
  55.      *  
  56.      * @return 數據庫的連接對象 
  57.      */  
  58.     public Connection getConnection() {  
  59.         try {  
  60.             connection = DriverManager.getConnection(URL, USER, PASSWORD);  
  61.         } catch (SQLException e) {  
  62.             e.printStackTrace();  
  63.         }  
  64.         return connection;  
  65.     }  
  66.   
  67.     /** 
  68.      * 完成對數據庫的表的添加刪除和修改的操作 
  69.      *  
  70.      * @param sql 
  71.      * @param params 
  72.      * @return 
  73.      * @throws SQLException 
  74.      */  
  75.     public boolean updateByPrepareStatement(String sql, List<Object> params)  
  76.             throws SQLException {  
  77.         boolean flag = false;  
  78.         int result = -1;// 表示當用戶執行添加刪除和修改的時候所影響數據庫的行數  
  79.         // 創建一個 PreparedStatement 對象來將參數化的 sql 語句發送到數據庫。  
  80.         preparedStatement = connection.prepareStatement(sql);  
  81.         int index = 1;  
  82.         if (params != null && !params.isEmpty()) {  
  83.             for (Object object : params) {  
  84.                 // 使用給定對象設置指定參數的值。index從1開始  
  85.                 preparedStatement.setObject(index++, object);  
  86.             }  
  87.         }  
  88.         // 在此 PreparedStatement 對象中執行 SQL 語句，該語句必須是一個 SQL 數據操作語言語句，比如  
  89.         // INSERT、UPDATE 或 DELETE 語句  
  90.         result = preparedStatement.executeUpdate();  
  91.         flag = result > 0 ? true : false;  
  92.         return flag;  
  93.   
  94.     }  
  95.   
  96.     /** 
  97.      * 查詢返回單條記錄 
  98.      *  
  99.      * @param sql 
  100.      * @param params 
  101.      * @return 
  102.      * @throws SQLException 
  103.      */  
  104.     public Map<String, Object> findSimpleResult(String sql, List<Object> params)  
  105.             throws SQLException {  
  106.         Map<String, Object> map = new HashMap<String, Object>();  
  107.         int index = 1;  
  108.         // 創建一個 PreparedStatement 對象來將參數化的 sql 語句發送到數據庫。  
  109.         preparedStatement = connection.prepareStatement(sql);  
  110.         if (params != null && !params.isEmpty()) {  
  111.             for (Object object : params) {  
  112.                 // 使用給定對象設置指定參數的值。index從1開始  
  113.                 preparedStatement.setObject(index++, object);  
  114.             }  
  115.         }  
  116.         // 在此 PreparedStatement 對象中執行 SQL 查詢，並返回該查詢生成的 ResultSet 對象。  
  117.         resultSet = preparedStatement.executeQuery();  
  118.         // 獲取此 ResultSet 對象的列的編號、類型和屬性。  
  119.         ResultSetMetaData metaData = resultSet.getMetaData();  
  120.         int col_len = metaData.getColumnCount();  
  121.         while (resultSet.next()) {  
  122.             for (int i = 0; i < col_len; i++) {  
  123.                 // sql數據庫列的下標是從1開始的  
  124.                 String col_name = metaData.getColumnName(i + 1);  
  125.                 Object col_value = resultSet.getObject(col_name);  
  126.                 if (col_value == null) {  
  127.                     col_value = "";  
  128.                 }  
  129.                 map.put(col_name, col_value);  
  130.             }  
  131.         }  
  132.   
  133.         return map;  
  134.     }  
  135.   
  136.     public List<Map<String, Object>> findMoreResult(String sql,  
  137.             List<Object> params) throws SQLException {  
  138.         List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();  
  139.         int index = 1;  
  140.         // 創建一個 PreparedStatement 對象來將參數化的 sql 語句發送到數據庫。  
  141.         preparedStatement = connection.prepareStatement(sql);  
  142.         if (params != null && !params.isEmpty()) {  
  143.             for (Object object : params) {  
  144.                 // 使用給定對象設置指定參數的值。index從1開始  
  145.                 preparedStatement.setObject(index++, object);  
  146.             }  
  147.         }  
  148.         // 在此 PreparedStatement 對象中執行 SQL 查詢，並返回該查詢生成的 ResultSet 對象。  
  149.         resultSet = preparedStatement.executeQuery();  
  150.         // 獲取此 ResultSet 對象的列的編號、類型和屬性。  
  151.         ResultSetMetaData metaData = resultSet.getMetaData();  
  152.         int col_len = metaData.getColumnCount();  
  153.         while (resultSet.next()) {  
  154.             Map<String, Object> map = new HashMap<String, Object>();  
  155.             for (int i = 0; i < col_len; i++) {  
  156.                 // sql數據庫列的下標是從1開始的  
  157.                 String col_name = metaData.getColumnName(i + 1);  
  158.                 Object col_value = resultSet.getObject(col_name);  
  159.                 if (col_value == null) {  
  160.                     col_value = "";  
  161.                 }  
  162.                 map.put(col_name, col_value);  
  163.             }  
  164.             list.add(map);  
  165.         }  
  166.         return list;  
  167.     }  
  168.   
  169.     /** 
  170.      * 關閉數據庫 
  171.      *  
  172.      * @throws SQLException 
  173.      */  
  174.     public void releaseConn() throws SQLException {  
  175.         if (resultSet != null) {  
  176.             resultSet.close();  
  177.         }  
  178.   
  179.         if (preparedStatement != null) {  
  180.             preparedStatement.close();  
  181.         }  
  182.         if (connection != null) {  
  183.             connection.close();  
  184.         }  
  185.     }  
  186.   
  187.     static JdbcUtils jdbcUtils;  
  188.   
  189.     public static void main(String[] args) throws SQLException {  
  190.         jdbcUtils = new JdbcUtils();  
  191.         jdbcUtils.getConnection();  
  192.         // insert();  
  193.         // update();  
  194.         // query();  
  195.         Morequery();  
  196.     }  
  197.   
  198.     private static void query() throws SQLException {  
  199.         String sql = "select * from userinfo where pwd = ? ";  
  200.         List<Object> params = new ArrayList<Object>();  
  201.         params.add("123");  
  202.         Map<String, Object> map = jdbcUtils.findSimpleResult(sql, params);  
  203.         System.out.println(map);  
  204.     }  
  205.   
  206.     private static void Morequery() throws SQLException {  
  207.         String sql = "select * from userinfo  ";  
  208.         List<Map<String, Object>> map = jdbcUtils.findMoreResult(sql, null);  
  209.         System.out.println(map);  
  210.     }  
  211.   
  212.     /** 
  213.      * 更新數據庫內容 
  214.      *  
  215.      * @throws SQLException 
  216.      */  
  217.     private static void update() throws SQLException {  
  218.         String sql = "update userinfo set username =? where id=2";  
  219.         List<Object> params = new ArrayList<Object>();  
  220.         params.add("liumr");  
  221.         jdbcUtils.updateByPrepareStatement(sql, params);  
  222.     }  
  223.   
  224.     /** 
  225.      * 增加數據 
  226.      *  
  227.      * @throws SQLException 
  228.      */  
  229.     private static void insert() throws SQLException {  
  230.         String sql = "insert userinfo (username,pwd) values (?,?)";  
  231.         List<Object> params = new ArrayList<Object>();  
  232.         params.add("liugx");  
  233.         params.add("456");  
  234.         jdbcUtils.updateByPrepareStatement(sql, params);  
  235.   
  236.     }  
  237.   
  238. }  


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 JDBC連接數據庫的幾個步驟 hibernate連接數據庫的步驟 JDBC連接數據庫的步驟 JDBC連接數據庫的步驟 JAVA 連接數據庫的步驟 JDBC連接數據庫的7個步驟 jdbc連接數據庫的步驟 JDBC連接數據庫7個步驟 java連接數據庫步驟 連接數據庫
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM