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


  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. }  
posted @ 2018-03-14 15:58  赵六六  阅读(4483)  评论(0)  编辑  收藏  举报