devbox
运维做开发
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

javaSE——JDBC_java connection preparestatement

作者：运维做开发 | 2024-07-10 05:57:13

赞

踩

java connection preparestatement

一、JDBC操作

1、java连接MySQL步骤

1、加载MySQL数据库驱动

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

2、创建数据库连接对象

通过DriverManager类创建数据库对象Connection。

Connection connection = DriverManager.getConnection(String url,String user,String pass);

其中MySQL数据库URL通常遵循如下写法：

jdbc:mysql://hostname:port/databasename

  • hostname为数据库服务器的IP地址，如果是本地可写：localhost或127.0.0.1。

  • port为数据库的监听端口，需要看安装时的配置，缺省为3306。

  • databasename数据库的名字。

3、创建Statment对象

Statment类主要用于执行静态SQL语句并返回它所生成结果的对象，通过Connection对象的createStatment()方法可以创建一个Statment对象。

Statment statement = coonn.createStatment();

其Connection创建Statement的方法有三个：

（1）、createStatement()：创建基本的Statement对象

（2）、prepareStatement(String sql)：根据传入的SQL语句创建预编译的Statement对象

  • 可以通过调用 Connection 对象的 preparedStatement(String sql) 方法获取 PreparedStatement 对象

  • PreparedStatement 接口是 Statement 的子接口，它表示一条预编译过的 SQL 语句

  • PreparedStatement 对象所代表的 SQL 语句中的参数用问号(?)来表示，调用 PreparedStatement 对象的 setXxx() 方法来设置这些参数. setXxx() 方法有两个参数，第一个参数是要设置的 SQL 语句中的参数的索引(从 1 开始)，第二个是设置的 SQL 语句中的参数的值

（3）、prepareCall(String sql)：根据所传入的SQL语句创建CallableStatement对象

    Statment弊端：    

  1. 存在拼串操作，繁琐

  2. 存在SQL注入问题

    其中所有的Statment都有如下三个方法来执行SQL语句

  1. execute()：可以执行任何SQL语句

  2. execeteUpdate()：主要用于执行DML和DDL语句。执行DML语句返回受SQL语句影响的行数，执行DDL语句返回0

  3. executeQuery()：只能执行查询语句，执行后返回查询结果的ResultSet对象

     Java与SQL对应数据类型转换表

Java类型

SQL类型

boolean

BIT

byte

TINYINT

short

SMALLINT

int

INTEGER

long

BIGINT

String

CHAR,VARCHAR,LONGVARCHAR

byte array

BINARY , VAR BINARY

java.sql.Date

DATE

java.sql.Time

TIME

java.sql.Timestamp

TIMESTAMP

3、连接数据库

方式一： 代码中显式出现了第三方数据库的API

  1. import java.sql.Connection;
  2. import java.sql.Driver;
  3. import java.sql.DriverManager;
  4. import java.sql.SQLException;
  5. import java.util.Properties;
  6. public class ConnectionTest{
  7. public static void main(String[] args) {
  8.      try {
  9.          //1.提供java.sql.Driver接口实现类的对象
  10.          Driver driver = null;
  11.          driver = new com.mysql.cj.jdbc.Driver();
  12.          
  13.          //2.提供URL，指明具体操作的数据
  14.          String url =  "jdbc:mysql://localhost:3306/mysql?characterEncoding=UTF-8";
  15.          
  16.          //3.提供Properties的对象，指明用户名和密码
  17.          Properties info = new Properties();
  18.          info.setProperty("user", "root");
  19.          info.setProperty("password", "123456");
  20.          
  21.          //4.调用driver的connect()，获取连接
  22.          Connection conn = driver.connect(url, info);
  23.          System.out.println(conn);
  24.      }
  25.      catch(SQLException e) {
  26.          e.printStackTrace();
  27.      }
  28.      }
  29. }

方式二： 相较于方式一，这里使用反射实例化Driver，不在代码中体现第三方数据库的API。体现了面向接口编程 思想。

  1. import java.sql.Connection;
  2. import java.sql.Driver;
  3. import java.sql.DriverManager;
  4. import java.sql.SQLException;
  5. import java.util.Properties;
  6. public class ConnectionTest{
  7. public static void main(String[] args){
  8.      try {
  9.          //1.实例化Driver
  10.          String className = "com.mysql.cj.jdbc.Driver";
  11.          Class clazz = Class.forName(className);
  12.          Driver driver = (Driver) clazz.newInstance();
  13.          
  14.          //2.提供URL，指明具体操作的数据
  15.          String url =  "jdbc:mysql://localhost:3306/mysql?characterEncoding=UTF-8";
  16.          
  17.          //3.提供Properties的对象，指明用户名和密码
  18.          Properties info = new Properties();
  19.          info.setProperty("user", "root");
  20.          info.setProperty("password", "123456");
  21.          
  22.          //4.调用driver的connect()，获取连接
  23.          Connection conn = driver.connect(url, info);
  24.          System.out.println(conn);
  25.      }
  26.      catch(SQLException e) {
  27.          e.printStackTrace();
  28.      } catch (InstantiationException e) {
  29.          // TODO Auto-generated catch block
  30.          e.printStackTrace();
  31.      } catch (IllegalAccessException e) {
  32.          // TODO Auto-generated catch block
  33.          e.printStackTrace();
  34.      } catch (ClassNotFoundException e) {
  35.          // TODO Auto-generated catch block
  36.          e.printStackTrace();
  37.      }
  38.      }
  39. }

方式三： 使用DriverManager实现数据库的连接。

  1. import java.sql.Connection;
  2. import java.sql.Driver;
  3. import java.sql.DriverManager;
  4. import java.sql.SQLException;
  5. import java.util.Properties;
  6. public class ConnectionTest{
  7. public static void main(String[] args){
  8.      try {
  9.          //1.数据库连接的4个基本要素：
  10.          String url =  "jdbc:mysql://localhost:3306/mysql?characterEncoding=UTF-8";
  11.          String user = "root";
  12.          String password = "abc123";
  13.          String driverName = "com.mysql.cj.jdbc.Driver";
  14.          //2.实例化Driver
  15.          Class clazz = Class.forName(driverName);
  16.          Driver driver = (Driver) clazz.newInstance();
  17.          
  18.          //3.注册驱动
  19.          DriverManager.registerDriver(driver);
  20.          
  21.          //4.获取连接
  22.          Connection conn =  DriverManager.getConnection(url, user, password);
  23.          System.out.println(conn);
  24.      }
  25.      catch(SQLException e) {
  26.          e.printStackTrace();
  27.      } catch (InstantiationException e) {
  28.          // TODO Auto-generated catch block
  29.          e.printStackTrace();
  30.      } catch (IllegalAccessException e) {
  31.          // TODO Auto-generated catch block
  32.          e.printStackTrace();
  33.      } catch (ClassNotFoundException e) {
  34.          // TODO Auto-generated catch block
  35.          e.printStackTrace();
  36.      }
  37.      }
  38. }

 方式四： 不必显式的注册驱动了。因为在DriverManager的源码中已经存在静态代码块，实现了驱动的注册。

  1. import java.sql.Connection;
  2. import java.sql.Driver;
  3. import java.sql.DriverManager;
  4. import java.sql.SQLException;
  5. import java.util.Properties;
  6. public class ConnectionTest{
  7. public static void main(String[] args){
  8.      try {
  9.          //1.数据库连接的4个基本要素：
  10.          String url =  "jdbc:mysql://localhost:3306/mysql?characterEncoding=UTF-8";
  11.          String user = "root";
  12.          String password = "123456";
  13.          String driverName =  "com.mysql.cj.jdbc.Driver";
  14.          /*2.实例化Driver
  15.          Class clazz = Class.forName(driverName);
  16.          Driver driver = (Driver) clazz.newInstance();
  17.          
  18.          //3.注册驱动
  19.          DriverManager.registerDriver(driver);
  20.          
  21.          //4.获取连接
  22.           */
  23.          Connection conn =  DriverManager.getConnection(url, user, password);
  24.          System.out.println(conn);
  25.          
  26.      }
  27.      catch(SQLException e) {
  28.          e.printStackTrace();
  29.      }
  30.      }
  31. }

4、查询数据

（1）、ResultSet结果集

结果集(ResultSet)是数据中查询结果返回的一种对象，可以说结果集是一个存储查询结果的对象，但是结果集并不仅仅具有存储的功能，他同时还具有操纵数据的功能，可能完成对数据的更新等。

结果集读取数据的方法主要是getXXX()，他的参数可以是整型表示第几列（是从1开始的），还可以是列名。返回的是对应的XXX类型的值。如果对应那列 是空值，XXX是对象的话返回XXX型的空值，如果XXX是数字类型，如Float等则返回0,boolean返回false.使用getString()可以返回所有的列的值，不过返回的都是字符串类型的。

    1、查询需要调用PreparedStatement 的 executeQuery() 方法，查询结果是一个ResultSet 对象

    2、 ResultSet 对象维护了一个指向当前数据行的游标，初始的时候，游标在第一行之前，可以通过 ResultSet 对象 的 next() 方法移动到下一行。调用 next()方法检测下一行是否有效。若有效，该方法返回 true，且指针下移。 相当于Iterator对象的 hasNext() 和 next() 方法的结合体。

    3、 当指针指向一行时, 可以通过调用 getXxx(int index) 或 getXxx(int columnName) 获取每一列的值。注意：Java与数据库交互涉及到的相关Java API中的索引都从1开始。

    • 例如: getInt(1), getString("name")

    Result基本使用：

    1、直接使用get方法获取对应的类型的数据，当然需要结合while(resultset.next())

  1. ResultSet rs = ps.executeQuery();
  2.             if(rs.next()){
  3.                 employee=new Employee(rs.getLong(1),rs.getString(2),rs.getString(3),rs.getInt(4));
  4.             }

    2、使用getMetaData()方法， 可用于获取关于 ResultSet 对象中列的类型和属性信息的对象。

     ResultSetMetaData meta = rs.getMetaData();
  • getColumnName(int column)：获取指定列的名称
  • getColumnLabel(int column)：获取指定列的别名
  • getColumnCount()：返回当前 ResultSet 对象中的列数。
  • getColumnTypeName(int column)：检索指定列的数据库特定的类型名称。
  • getColumnDisplaySize(int column)：指示指定列的最大标准宽度，以字符为单位。
  • isNullable(int column)：指示指定列中的值是否可以为 null。
  • isAutoIncrement(int column)：指示是否自动为指定列进行编号，这样这些列仍然是只读的。

代码：

  1. ResultSetMetaData rsmd = rs.getMetaData();// 得到记录集，元素对象。
  2.     // 通过此对象可以得到表的结构，包括，列名，列的个数，列数据类型
  3.     while(rs.next()){
  4.         T m = cls.newInstance();// 通过反射得到实体对象。
  5.         for(int i=0;i<rsmd.getColumnCount();i++){
  6.             String col_name = rsmd.getCatalogName(i+1);// 获取列名
  7.             Object value = rs.getObject(col_name);//获取列对应的值。
  8.             Field field = cls.getDeclaredField(col_name);//获取对象对应的名称属性，然后给属性赋值
  9.             field.setAccessible(true);// 让可以访问私有属性
  10.             field.set(m,value);// 给对象私有属性赋值
  11.             }
  12.     list.add(m);

（2）、编译预处理

preparedStatement是和编译预处理有关的类，是Statement的一个子类，preparedStatement类定义的SQL语句中则包含一个或多个问号“？”占位符，他们对应多个IN参数。

preparedStatement的用法：

    1、创建对象

    在对象pstmt中包含了语句“update table1 set x = ? where y = ?”，该语句被发送到DBMS进行编译预处理，为执行做准备

preparedStatement pstmt = con.preparedStatement("update table1 set x = ? where y = ?");

    2、设定参数

pstmt.setLong(1,123456789); pstmt.setLong(2,987654321);

    3、执行语句

pstmt.executeUpdate();

1、使用Statement实例通过执行静态SELECT语句查询数据的代码：

  1. String sql = "sqlect * from database_name where sex = num ";
  2. Statement stmt = con.createStatement();
  3. PreparedStatement pstmt = con.prepareStatement(sql);
  4. CallableStatement cstmt = con.prepareCall("{CALL demoSp(?,?)}");

使用Statement实例执行静态SELECT语句查询记录：

  1. import java.sql.*;
  2. public class StatementStatic_QueryTest{
  3.      static {
  4.          try {
  5.               Class.forName("com.mysql.cj.jdbc.Driver");
  6.          }catch(ClassNotFoundException e) {
  7.               e.printStackTrace();
  8.          }
  9.      }
  10.      public static void main(String[] args) {
  11.          try {
  12.                Connection conn =    DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mysql?characterEncoding=UTF-8","root","123456");           
  13.                Statement stmt = conn.createStatement();
  14.                String sql = "select * from  Statement_QueryTest";
  15.                 ResultSet rs = stmt.executeQuery(sql);
  16.                 while(rs.next()) {
  17.                     String name =  rs.getString(1);
  18.                     int age = rs.getInt(2);
  19.                     String sex = rs.getString(3);
  20.                     System.out.println(name+" "+age+"  "+sex+" ");
  21.                 }
  22.                 stmt.close();
  23.                 conn.close();
  24.          }catch(SQLException e) {
  25.               e.printStackTrace();
  26.          }
  27.      }
  28. }

输出：
张翰林 20 男
刘霖 18 女
胡政 21 男
王子怡 19 女
陈静仪 20 女

    2、利用PreparedStatement实例通过执行动态SELECT语句查询数据的代码：

  1. String sql = "select * from database_name where sex = num ";
  2. PreparedStatement prpdStmt = connection.prepareStatement(sql);
  3. prpdStmt.setString(1,"男");
  4. ResultSet rs = prpdStmt.executeQuery(); 

    使用PreparedStatement实例执行动态SELECT语句查询记录：

  1. import java.sql.*;
  2. public class StatementDynamic_QueryTest{
  3.      static {
  4.          try {
  5.               Class.forName("com.mysql.cj.jdbc.Driver");
  6.          }catch(ClassNotFoundException e) {
  7.               e.printStackTrace();
  8.          }
  9.      }
  10.      public static void main(String[] args) {
  11.          try {
  12.                Connection conn =    DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mysql?characterEncoding=UTF-8","root","123456");           
  13.                Statement stmt = conn.createStatement();
  14.                String sql = "select * from  Statement_QueryTest"; //定义静态SELECT语句
  15.                PreparedStatement prpdStmt =  conn.prepareStatement(sql); //预处理动态INSERT语句
  16.                 ResultSet rs =  prpdStmt.executeQuery(sql); //执行动态INSERT语句
  17.                 ResultSetMetaData metaData =  rs.getMetaData();
  18.                  System.out.println(metaData.getColumnName(1)+" "); //通过列索引获得指定列的名称
  19.                  System.out.println(metaData.getColumnName(2)+" "); //通过列索引获得指定列的名称
  20.                  System.out.println(metaData.getColumnName(3)+" "); //通过列索引获得指定列的名称
  21.                 while(rs.next()) {   
  22.                     String name =  rs.getString(1);    //通过列索引获得指定列的值
  23.                     int age = rs.getInt(2);   //通过列索引获得指定列的值
  24.                     String sex = rs.getString(3);      //通过列索引获得指定列的值
  25.                     System.out.println(name+" "+age+"  "+sex+" ");
  26.                 }
  27.                 rs.close();
  28.                 prpdStmt.close();
  29.                 conn.close();
  30.          }catch(SQLException e) {
  31.               e.printStackTrace();
  32.          }
  33.      }
  34. }

输出：
name
age
sex
张翰林 20 男
刘霖 18 女
胡政 21 男
王子怡 19 女
陈静仪 20 女

    3、利用CallableStatement实例通过执行存储过程查询数据的代码：

  1. String call = "{call pro_record_select_by_sex(?)}";
  2. CallableStatement cablStmt = connection.prepareStatement(call);
  3. cablStmt.setString(1,"男");
  4. ResultSet rs = cablStmt.executeQuery();

5、插入数据

对数据的插入，可有两种操作模式：一种是直接使用SQL语句插入，而是通过可更新的结果集对象集间接插入，用下面的形式创建语句对象：

  1. Statement stmt = con.createStatement(ResultSet.TYPE)
  2. SCROLL_SENSITIVE,ResultSet.CUNCUR_UPDATABLE);

    插入数据两种方式的实例

    第一种：

String sqlins = "INSERT INTO student values(' "+name+" ',' "+age+" ',' "+sex+" ',' "+wage+" ',' "+" ',' "+addr+" ');

    第二种

  1. rs.moveToInsertRow();
  2.     rs.updateString("name","LiMing");
  3.     rs.updateString("age",40);
  4.     rs.updateString("sex","男");
  5.     rs.updateString("wage",4500);
  6.     rs.updateString("addr","北京市");
  7.     rs.insertRow();

    通过Statement实例执行静态INSERT语句添加单条记录

  1. import java.sql.*;
  2. public class StatementStatic_insertTest{     
  3.      static {
  4.          try {
  5.               Class.forName("com.mysql.cj.jdbc.Driver");
  6.          }catch(ClassNotFoundException e) {
  7.               e.printStackTrace();
  8.          }
  9.      }
  10.      public static void main(String[] args) {
  11.          try {
  12.               Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mysql?characterEncoding=UTF-8","root","123456");      
  13.             Statement statement = conn.createStatement();
  14.             String sql = "insert into  Statement_QueryTest(name,age,sex) values ('刘乐',19,'女')";
  15.             statement.executeUpdate(sql);
  16.             statement.close();
  17.             conn.close();
  18.             System.out.println("插入数据成功");
  19.          } catch (SQLException e){
  20.               e.printStackTrace();
  21.          }
  22.      }
  23. }

    通过Statement实例执行动态INSERT语句添加单条记录

  1. import java.sql.*;
  2. public class StatementDynamic_insertTest{     
  3.      static {
  4.          try {
  5.               Class.forName("com.mysql.cj.jdbc.Driver");
  6.          }catch(ClassNotFoundException e) {
  7.               e.printStackTrace();
  8.          }
  9.      }
  10.      public static void main(String[] args) {
  11.          try {
  12.               Connection conn =  DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mysql?characterEncoding=UTF-8","root","123456");
  13.               String[] [] records = {{"王璇","22","女"}};
  14.               String sql = "insert into Statement_QueryTest(name,age,sex) values  (?,?,?)";
  15.               PreparedStatement prpdStmt =  conn.prepareStatement(sql);    //预处理动态INSERT语句
  16.               prpdStmt.clearBatch();    //清空Batch
  17.               for(int i =0;i<records.length;i++) {
  18.                   prpdStmt.setString(1,  records[i][0]);    //向第一个？添加数据
  19.                   prpdStmt.setInt(2,  Integer.valueOf(records[i][1]).intValue());    //向第二个？添加数据
  20.                   prpdStmt.setString(3,  records[i][2]);    //向第三个？添加数据
  21.                   prpdStmt.addBatch();       //将INSERT语句添加到Batch中
  22.  
  23.               }
  24.               prpdStmt.executeBatch();    //批量执行Batch中的INSERT语句
  25.               prpdStmt.close();
  26.             conn.close();
  27.             System.out.println("插入数据成功");
  28.          } catch (SQLException e){
  29.               e.printStackTrace();
  30.          }
  31.      }
  32. }

6、更新数据

    1、利用Statement实例通过执行静态Update语句修改数据代码：

  1. String sql = "updqte tb_record set sqlary = ? where duty = ? ";
  2. statement.executeUpdate(sql);

    2、利用Statement实例通过执行动态Update语句修改数据代码：

  1. String sql = "update tb_record set salary = ? where duty = ?";
  2. PreparedStatement prpdStmt = connection.preparedStatement(sql);
  3. prpdStmt.setInt(1,300);
  4. prpdStmt.setString(2,"部门经理");
  5. prpdStmt.executeUpdate();
  6.     3、利用CallableStatement实例通过执行存储过程修改数据代码：
  7. String call = "{call pro_record_update_salary_by_duty(?,?)}";
  8. CallableStatement cablStmt = connection preparedCall(call);
  9. cablStmt.setInt(1,3000);
  10. cablStmt.setString(2,"部门经理");
  11. cablStmt.executeUpdate();
  12.     通过Statement实例每次执行一条UPDATE语句
  13. import java.sql.*;
  14. public class StatementStatic_UpdateTest{
  15.     static {
  16.         try {
  17.              Class.forName("com.mysql.cj.jdbc.Driver");
  18.         }catch(ClassNotFoundException e) {
  19.              e.printStackTrace();
  20.         }
  21.     }
  22.     public static void main(String[] args) {
  23.         try {
  24.              Connection conn =   DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mysql?characterEncoding=UTF-8","root","123456");
  25.              Statement statement =  conn.createStatement();
  26.              String sql = "update Statement_QueryTest set name = '刘子扬' where name  = '胡政'";
  27.              statement.executeUpdate(sql);
  28.              conn.close();             
  29.         }catch(SQLException e) {
  30.           e.printStackTrace();
  31.         }
  32.     }
  33. }

7、删除数据

        1、利用Statement实例通过执行静态DELETE语句修改数据代码：

  1. String sql = "delete from Statement_QueryTest where name = "王浩";
  2. statement.executeUpdate(sql);

        2、利用PreparedStatement实例通过执行动态DELETE语句修改数据代码：

  1. String sql = "delete from Statement_QueryTest where name = "王浩";
  2. PreparedStatemnet prpdStmt = connection.preparedStatement(sql);
  3. prdStmt.setString(1,"李宁");
  4. prpdStmt.executeUpdate(sql);

        3、利用CallableStatement实例通过执行存储过程删除数据代码：

  1. String call = "{call Statement_QueryTest_delete_by_date(?)}";
  2. CallableStatement cablStmt = connection preparedCall(call);
  3. cablStmt.setInt(1,"李宁");
  4. cablStmt.executeUpdate();

        通过Statement实例每次执行一条DELETE语句

  1. import java.sql.*;
  2. public class Statement_DeleteTest{
  3.     static {
  4.         try {
  5.              Class.forName("com.mysql.cj.jdbc.Driver");
  6.         }catch(ClassNotFoundException e) {
  7.              e.printStackTrace();
  8.         }
  9.     }
  10.     public static void main(String[] args) {
  11.         try {
  12.              Connection conn =   DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mysql?characterEncoding=UTF-8","root","123456");
  13.              Statement statement =  conn.createStatement();
  14.              String sql = "delete from  Statement_QueryTest where name = '刘子扬'";
  15.              statement.executeUpdate(sql);
  16.              statement.close();
  17.              conn.close();            
  18.         }catch(SQLException e) {
  19.           e.printStackTrace();
  20.         }
  21.     }
  22. }
  23.     通过PreparedStatement实例一次执行多条DELETE语句
  24. import java.sql.*;
  25. public class PreparedStatement_DeleteTest{
  26.     static {
  27.         try {
  28.              Class.forName("com.mysql.cj.jdbc.Driver");
  29.         }catch(ClassNotFoundException e) {
  30.              e.printStackTrace();
  31.         }
  32.     }
  33.     public static void main(String[] args) {
  34.         try {
  35.              Connection conn =   DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mysql?characterEncoding=UTF-8","root","123456");
  36.              Statement statement =  conn.createStatement();
  37.              String names[] = {"张飞","张小霞"};
  38.              String sql = "delete from  StatementStatic_QueryTest where name = ?";
  39.              PreparedStatement prpdStmt =  conn.prepareStatement(sql);
  40.              prpdStmt.clearBatch();
  41.              for(int i = 1 ;i<names.length;i++) {
  42.                  prpdStmt.setString(1, names[i]);
  43.                  prpdStmt.addBatch();
  44.              }
  45.              prpdStmt.executeBatch();
  46.              conn.close();            
  47.         }catch(SQLException e) {
  48.           e.printStackTrace();
  49.         }
  50.     }
  51. }

二、数据库连接池

1、概念

（1）、基本思想

数据库连接池的基本思想  就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。我们可以通过设定连接池最大连接数来防止系统无尽的与数据库连接。更为重要的是我们可以通过连接池的管理机制监视数据库的连接的数量﹑使用情况，为系统开发﹑测试及性能调整提供依据。

（2）、工作原理

（3）、优点

  • 资源重用

由于数据库连接得以重用，避免了频繁创建，释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增加了系统运行环境的平稳性。

  • 更快的系统反应速度

数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于连接池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而减少了系统的响应时间

  • 新的资源分配手段

对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接池的配置，实现某一应用最大可用数据库连接数的限制，避免某一应用独占所有的数据库资源

  • 统一的连接管理，避免数据库连接泄漏

在较为完善的数据库连接池实现中，可根据预先的占用超时设定，强制回收被占用连接，从而避免了常规数据库连接操作中可能出现的资源泄露

2、C3P0连接池

（1）、XML形式

导入c3p0依赖

jdbc依赖

MySQL Connector依赖

创建c3p0配置文件c3p0-config.xml

测试

// 1、创建数据库连接池对象

DataSource ds = new ComboPooledDataSource();

// 2、获取连接对象

Connection conn = ds.getConnection();后面的代码和jdbc就接通了

（2）、配置文件形式

c3p0.properties

3、Druid连接池

Druid为阿里巴巴的数据源，（数据库连接池），集合了c3p0、dbcp、proxool等连接池的优点，还加入了日志监控，有效的监控DB池连接和SQL的执行情况。

导入Druid的依赖

编写Druid.properties配置文件

测试

  1. import com.alibaba.druid.pool.DruidDataSourceFactory;
  2. import javax.sql.DataSource;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.sql.Connection;
  6. import java.sql.PreparedStatement;
  7. import java.sql.ResultSet;
  8. import java.sql.SQLException;
  9. import java.util.Properties;
  10.  
  11. public class DruidDemo {
  12.     public static void main(String[] args) {
  13.         //1.导入jar包
  14.         //2.定义配置文件
  15.         //3.加载配置文件
  16.         Properties pro = new Properties();
  17.         InputStream resourceAsStream = DruidDemo.class.getClassLoader().getResourceAsStream("Druid.properties");
  18.         Connection connection = null;
  19.         PreparedStatement preparedStatement = null;
  20.         ResultSet resultSet = null;
  21.         try {
  22.             pro.load(resourceAsStream);
  23.             DataSource ds = DruidDataSourceFactory.createDataSource(pro);
  24.             connection = ds.getConnection();
  25.             String sql = "Select * from studnet.class1";
  26.             preparedStatement = connection.prepareStatement(sql);
  27.             resultSet = preparedStatement.executeQuery();
  28.             while (resultSet.next()){
  29.                 Integer id = resultSet.getInt("序号");
  30.                 String name = resultSet.getString("学号");
  31.                 String value = resultSet.getString("姓名");
  32.  
  33.                 System.out.println(id+" "+name+" "+value);
  34.             }
  35.         } catch (IOException e) {
  36.             e.printStackTrace();
  37.         } catch (SQLException e) {
  38.             e.printStackTrace();
  39.         } catch (Exception e) {
  40.             e.printStackTrace();
  41.         } finally {
  42.             if (connection!=null){
  43.                 try {
  44.                     connection.close();
  45.                 } catch (SQLException e) {
  46.                     e.printStackTrace();
  47.                 }
  48.             }
  49.             if (resultSet!=null){
  50.                 try {
  51.                     resultSet.close();
  52.                 } catch (SQLException e) {
  53.                     e.printStackTrace();
  54.                 }
  55.             }     
  56.             if (preparedStatement!=null){
  57.                 try {
  58.                     preparedStatement.close();
  59.                 } catch (SQLException e) {
  60.                     e.printStackTrace();
  61.                 }
  62.             }
  63.         }
  64.     }
  65. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/运维做开发/article/detail/805045
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号