JDBC与JDBC连接池

红太狼 2023-05-31 15:29 78阅读 0赞

# 一、 JDBC #

### 背景 ###

市场上数据库种类繁多，每个数据库连接操作各不相同，为了使Java程序统一高效的访问数据库，一种规范就诞生了，这种规范就是jdbc。

**Java DataBase Connectivity**——Java数据库连接

#### 本质： ####

**JDBC** 是Java程序连接关系数据库的规范（接口），（接口）是由sum公司定义，由各个数据库厂商如 **Mysql**、**Oracle** 来实现这些接口，提供数据库驱动jar包。

我们可以使用这些接口进行编程，但在这些接口的实现上，是由jar包里面的实现类去完成的！

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDEzMzA5OQ_size_16_color_FFFFFF_t_70]

## 二、 数据库连接过程 ##

public static void main(String[] args) throws Exception { 
            //1.导入jar包
            //2.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //3.获取数据库连接对象
            Connection con=DriverManager.getConnection(
                    "jdbc:mysql://localhost:3306/test1","root",
                    "ldl123");
            //4.定义SQL语句
           String sql="update student set age=50 where id=1";
           //5.获取执行SQL的对象
            Statement statement=con.createStatement();
            //6.执行SQL
            int count = statement.executeUpdate(sql);
            //7.处理结果
            System.out.println(count);
            //8.释放资源
            statement.close();
            con.close();
        }

## 三、详解JDBC各个对象 ##

#### 1、DriverManger ####

**功能：**

（1）注册驱动：告诉程序加载哪一个数据库的 **jar** 包

Class.forName("com.mysql.jdbc.Driver");
    
     Class.forName("com.oracle.jdbc.Driver");

（2）获取数据库连接

#### 2、Connection ####

//3.获取数据库连接对象
            Connection con=DriverManager.getConnection(
                    "jdbc:mysql://localhost:3306/test1","root",
                    "ldl123");

**功能：**

（1）**加载连接对象**

（2）**管理事务**（如果现在看不懂跳过，但这个很重要，以后再弄懂）

*  开启事务
 *  回滚事务
 *  提交事务

**补充：**

**概念：**

事务是应用程序中一系列严密的操作，所有操作必须成功完成，否则在每个操作中所作的所有更改都会被撤消。也就是事务具有原子性，一个事务中的一系列的操作要么全部成功，要么一个都不做

**事务的四大特性**

数据库事务 transanction 正确执行的四个基本要素。ACID,原子性(Atomicity)、一致性(Correspondence)、隔离  
性(Isolation)、持久性(Durability)。

（1）**原子性**：整个事务中的所有操作，要么全部完成，要么全部不完成，不可能停滞在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。  
（2）**一致性**：在事务开始之前和事务结束以后，数据库的完整性约束没有被破坏。  
（3）**隔离性**：隔离状态执行事务，使它们好像是系统在给定时间内执行的唯一操作。如果有两个事务，运行在相同的时间内，执行 相同的功能，事务的隔离性将确保每一事务在系统中认为只有该事务在使用系统。这种属性有时称为串行化，为了防止事务操作间的混淆， 必须串行化或序列化请 求，使得在同一时间仅有一个请求用于同一数据。  
（4）**持久性**：在事务完成以后，该事务所对数据库所作的更改便持久的保存在数据库之中，并不会被回滚。

**例子：转账**

public static void main(String[] args) { 
            Connection con=null;
            PreparedStatement pst1=null;
            PreparedStatement pst2=null;
            try { 
                con= JDBCUtil.getConnection();
                //开启事务
                con.setAutoCommit(false);
    
                String sql1="update account set balance=balance-? where name=?";
                String sql2="update account set balance=balance+? where name=?";
    
                pst1=con.prepareStatement(sql1);
                pst2=con.prepareStatement(sql2);
                
                 // 给？赋值
                pst1.setDouble(1,500);
                pst1.setString(2,"李明");
                pst2.setDouble(1,500);
                pst2.setString(2,"张伟");
    
                pst1.executeUpdate();
    
                //手动制造错误，哈哈
                int i=3/0;
    
                pst2.executeUpdate();
                //提交事务
                con.commit();
            } catch (Exception e) { 
                //事务回滚
                try { 
                    if (con!=null)
                        con.rollback();
                } catch (SQLException e1) { 
                    e1.printStackTrace();
                }
                e.printStackTrace();
            }finally { 
                JDBCUtil.close(pst1,con,null);
                JDBCUtil.close(pst2,null,null);
            }
        }

例如转账，分为关键两步：转账人余额减少，收账人余额增加；这两步要么同时成功，要么同时失败。体现的是其原子性。

#### 3、Statement ####

**功能**：  
（1）执行SQL语句：

//5.获取执行SQL的对象
            Statement statement=con.createStatement();
            //6.执行SQL
            int count = statement.executeUpdate(sql);

excuteUpdate（）返回一个整型数 **count** 表示数据库表中执行 SQL 语句后影响的行数，***可以用 count 判断 SQL 语句是否执行成功，count > 0 则SQL语言执行成功，小于零则执行失败。***

#### 4、PreparedStatement ####

是 statement 旳子类。statement执行的是静态SQL语句，会出现**SQL注入**的问题，preparedStatement 执行的是动态SQL语句，可以解决这一问题，并且PreparedStatement 效率更高。在以后的开发中，我们一般都会使用preparedStatement而不会使用statement。

public static void main(String[] args) { 
    
            PreparedStatement pst=null;
            Connection con=null;
            try { 
                //获取连接
                con= JDBCUtil02.getConnection();
                //定义SQL语句
                String sql="insert into account values(null,?,?)";
                //获取preparedStatement对象
                pst=con.prepareStatement(sql);
                //给？赋值
                pst.setString(1,"张飞");
                pst.setDouble(2,6000);
                //执行SQL语句
                int count=pst.executeUpdate();
                System.out.println(count);
            } catch (SQLException e) { 
                e.printStackTrace();
            }finally { 
                JDBCUtil02.close(null,pst,con);
            }
        }

补充：  
setString（参数1，参数2）：  
参数1：表示SQL语句中的第几个 ？  
参数2：给参数 ？赋的值

#### 5、ResultSet ####

结果集对象。用来封装查询结果

**重要方法：**

*  **boolean next（）**  
    **ResultSet** 对象保持一个**光标**指向其当前的数据行。 最初，光标位于第一行之前。 next方法将光标移动到下一行，并且由于在 ResultSet 对象中没有更多行时返回false ，因此可以在while循环中使用循环来遍历结果集  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDEzMzA5OQ_size_16_color_FFFFFF_t_70 1]
 *  **getXxx(参数)**  
    获取数据

while (rs.next()){ 
                    int id=rs.getInt(1);
                    String name=rs.getString("NAME");
                    int age=rs.getInt("AGE");
                    int sal=rs.getInt("SAL");
                    System.out.println( id +"---"+name+"--"+age+"--"+sal);
                }

**参数**：  
int类型：指定当前行第几列的值  
String类型：指定当前行列名对应的值

**getByte(int columnIndex)** 这个检索的当前行中指定列的值 ResultSet对象为 byte的Java编程语言

**getByte(String columnLabel)** 这个检索的当前行中指定列的值 ResultSet对象为 byte的Java编程语言

**getInt(int columnIndex)** 这个检索的当前行中指定列的值 ResultSet作为对象 int在Java编程语言

**getInt(String columnLabel)** 以Java编程语言中的 int此 ResultSet对象的当前行中指定列的值

## 四、JDBC工具类 ##

频繁地加载驱动和获取连接**效率不高**且使**代码显得冗余**，而创建一个JDBC工具类可以解决这一问题

public class JDBCUtil { 
        private  static String url;
        private static String user;
        private static String password;
        private static String driver;
    
        /* * 配置文件的读取 ，使用静态代码块来一次性获取这些值 * */
       static { 
            try { 
                //创建properties 集合类
                Properties pro=new Properties();
                //获取src下资源文件的路径---》类加载器 
                pro.load(JDBCUtil02.class.getClassLoader().
                        getResourceAsStream("jdbc.properties"));
    
                url=pro.getProperty("url");
            user=pro.getProperty("user");
            password=pro.getProperty("password");
            driver=pro.getProperty("driver");
    
            Class.forName(driver);
    
            } catch (ClassNotFoundException | IOException e) { 
                e.printStackTrace();
            }
    
        }
        /* * 获取连接 * */
        public static Connection getConnection() { 
    
            Connection connection = null;
            try { 
                connection = DriverManager.getConnection(url, user, password);
            } catch (SQLException e) { 
                e.printStackTrace();
            }
            return connection;
        }
    
        /* * 释放资源 先建立的后释放，后建立的先释放 * */
        public static void close(Statement st,Connection con,ResultSet rs){ 
           if (rs!=null){ 
               try { 
                   rs.close();
               } catch (SQLException e) { 
                   e.printStackTrace();
               }
           }
            if (st!=null){ 
                try { 
                    st.close();
                } catch (SQLException e) { 
                    e.printStackTrace();
                }
            }
            if (con!=null){ 
                try { 
                    con.close();
                } catch (SQLException e) { 
                    e.printStackTrace();
                }
            }
        }
    }

# JDBC连接池 #

Why：为啥会有这东西呢？

因为用户访问数据库的时候 数据库连接 **频繁地创建以及释放资源**效率低，浪费资源，耗时

**概念：  
数据库连接池就是一个存放数据库连接的容器（集合）**

系统初始化时，容器会被创建，会申请一些连接对象，当用户来访问数据库时，从容其中获取连接对象，访问结束后，将连接对象归还到数据库连接池中。

使用连接池的好处：  
（1）节约资源  
（2）用户访问高效  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDEzMzA5OQ_size_16_color_FFFFFF_t_70 2]实现：  
1标准接口：DataSource  
方法：  
1）获取连接：getConnection（）  
2）归还连接：如果是从数据库连接池申请的Connection对象，那么调用Connection.close（），不会关闭连接，而是归还连接

2、这些接口由厂商来实现  
1.c3p0： 数据库连接池技术  
2.Druid ：数据库连接池实现技术（阿里巴巴）

c3p0的使用：  
1）导入jar包 mchange-commons-java-0.2.15 c3p0-0.9.5.2 以及数据库的驱动jar包  
2）定义配置文件 c3p0-config.xml

3)创建核心对象： 数据库连接池对象，ComboPooledDataSource

4）获取连接

public class cp30 { 
        public static void main(String[] args) throws SQLException { 
            //创建数据库连接池对象
            DataSource dt=new ComboPooledDataSource();
    
            //获取对象
            Connection con=dt.getConnection();
    
            System.out.println(con);
    
        }
    }

druid的使用  
1）导入jar包 druid-1.0.9  
2）定义配置文件 druid.properties  
3)加载配置文件  
4）获取数据库连接对象：通过工厂类来获取，DruidDataSourceFactory

public class DruidDemo { 
        public static void main(String[] args) throws Exception { 
           //1导入jar包
            //2、定义配置文件
            //3、加载配置文件
            Properties pro=new Properties();
            InputStreamis=DruidDemo.class.getClassLoader().
                          getResourceAsStream("druid.properties");
            pro.load(is);
    
            //4、获取连接池对象
    
            DataSource ds=DruidDataSourceFactory.createDataSource(pro);
            Connection con=ds.getConnection();
            System.out.println(con);
        }
    }

相关jar包下载：  
[https://blog.csdn.net/weixin\_44133099/article/details/102545153][https_blog.csdn.net_weixin_44133099_article_details_102545153]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDEzMzA5OQ_size_16_color_FFFFFF_t_70]: /images/20230531/fc87a09be18b4f9abd8f35b251de7dd0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDEzMzA5OQ_size_16_color_FFFFFF_t_70 1]: /images/20230531/4bac8ef88e104dc0bdf0711bf07081d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDEzMzA5OQ_size_16_color_FFFFFF_t_70 2]: /images/20230531/3e9b0c6c3bcf43f7a30494716237b707.png
[https_blog.csdn.net_weixin_44133099_article_details_102545153]: https://blog.csdn.net/weixin_44133099/article/details/102545153