zoukankan      html  css  js  c++  java

  • #数据库#连接数据库的几个步骤


    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. }  
  • 相关阅读:
    Qt Undo Framework
    pyinstaller打包shotgun有关的程序
    博客初衷
    文件隐写
    IDA使用初探-1.启动IDA
    隐写术总结
    无线网破解 跑字典 EWSA使用教程
    CTF中图片隐藏文件分离方法总结
    【转载】Pangolin4.0最新破解版-SQL注入渗透工具
    名词解释
  • 原文地址：https://www.cnblogs.com/tnt-33/p/8568140.html
Copyright © 2011-2022 走看看