学习笔记---JDBC

最新推荐文章于 2024-04-30 11:01:45 发布

gdutlog

最新推荐文章于 2024-04-30 11:01:45 发布

阅读量98

点赞数

分类专栏： mysql学习笔记

本文链接：https://blog.csdn.net/yang862819503/article/details/114392479

版权

mysql学习笔记专栏收录该内容

11 篇文章 0 订阅

订阅专栏

JDBC

1.数据库驱动

驱动：声卡，显卡，数据库

在这里插入图片描述

程序会通过数据库驱动与数据库打交道

2.JDBC

SUN公司为了简化开发人员的（对数据库的统一）操作，提供了一个Java操作数据库的规范，俗称JDBC

这些规范的实现由具体的厂商去做

对于开发人员来说，我们只需要掌握JDBC的接口操作即可！

在这里插入图片描述

java.sql

javax.sql

还需要导入一个数据库驱动包 mysql-connector-java

3.第一个JDBC程序

创建测试数据库

CREATE DATABASE jdbcStudy CHARACTER SET utf8 COLLATE utf8_general_ci;

USE jdbcStudy;

CREATE TABLE `users`(
id INT PRIMARY KEY,
NAME VARCHAR(40),
PASSWORD VARCHAR(40),
email VARCHAR(60),
birthday DATE
);

INSERT INTO `users`(id,NAME,PASSWORD,email,birthday)
VALUES(1,'zhansan','123456','zs@sina.com','1980-12-04'),
(2,'lisi','123456','lisi@sina.com','1981-12-04'),
(3,'wangwu','123456','wangwu@sina.com','1979-12-04')

创建一个普通项目
导入数据库驱动（lib为directory类型文件）

在这里插入图片描述

编写测试代码

package com.yanglog.lesson01;

import java.sql.*;

//我的第一个JDBC程序
public class JdbcFirstDemo {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");  //固定写法，加载驱动

        //2.填写信息（用户信息及url）
        String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true";
        String username = "root";
        String password = "123456";

        //3.连接成功，数据库对象    connection 代表数据库
        Connection connection = DriverManager.getConnection(url, username, password);

        //4.执行SQL的对象  Statement执行SQL的对象
        Statement statement = connection.createStatement();

        //5.执行SQL的对象 去 执行SQL，可能存在结果，查看返回结果
        String sql = "SELECT * FROM `users`";

        ResultSet resultSet = statement.executeQuery(sql);  //返回的结果集，结果集中封装了我们全部查询出来的结果

        while(resultSet.next()){
            System.out.println("id:" + resultSet.getObject("id"));
            System.out.println("name:" + resultSet.getObject("NAME"));
            System.out.println("pwd" + resultSet.getObject("PASSWORD"));
            System.out.println("email" + resultSet.getObject("email"));
            System.out.println("birthday" + resultSet.getObject("birthday"));
            System.out.println("========================");
        }

        //6.释放连接
        resultSet.close();
        connection.close();
        statement.close();
    }
}

步骤总结：

加载驱动
填写用户信息及url
连接数据库DriverManager
获得执行sql的对象 Statement
获得返回的结果集
释放连接

DriverManager

//DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Class.forName("com.mysql.jdbc.Driver");  //固定写法，加载驱动

Connection connection = DriverManager.getConnection(url, username, password);
// connection代表数据库   数据库能干的都能干
// 数据库设置自动提交
// 事务提交
// 事务回滚
connection.setAutoCommit();
connection.commit();
connection.rollback();

URL

String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true";

// mysql -- 3306
// 协议://主机地址:端口号/数据库名?参数1&参数2&参数3

// oracle  -- 1521
// jdbc:oracle:thin:@localhost:1521:sid

Statement 执行SQL的对象

String sql = "SELECT * FROM `users`";  // 编写sql

statement.execute();  // 执行所有的sql
statement.executeQuery();  // 查询操作，返回ResultSet
statement.executeUpdate();  //  更新，插入，删除，都是用这个，返回一个受影响的行数

ResultSet 查询的结果集，封装了所有的查询结果

获得指定的数据类型

resultSet.getObject(); // 不知道该列类型的情况下使用
// 知道该列具体的类型的情况下使用（精确）
resultSet.getInt();
resultSet.getFloat();
resultSet.getString();
resultSet.getDate();
resultSet.getTime();
...

遍历

resultSet.beforeFirst();    // 移动到最前面
resultSet.afterLast();      // 移动到最后面
resultSet.next();           // 移动到下一个数据
resultSet.previous();       // 移动到上一行
resultSet.absolute(row);    // 移动到指定行

释放资源

//6.释放连接
resultSet.close();
connection.close();
statement.close();

4.statement对象

JDBC中的statement对象用于向数据库发送SQL语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可

statement对象的executeUpdate方法，用于向数据库发送增，删，改的sql语句，executeUpdate执行完后，将会返回一个整数（即增删改语句导致了数据库几行数据发生了变化）。

statement.executeQuery方法用于向数据库发送查询语句，executeQuery方法返回代表查询结果的ResultSet对象。

CRUD操作-create

使用executeUpdate(Sting sql)方法完成数据添加操作，示例操作:

Statement statement = connection.createStatement();
String sql = "insert into user(...) values(...)";
int num = statement.executeUpdate(sql);
if(num>0){
    System.out.println("插入成功！");
}

CRUD操作-delete

使用executeUpdate(Sting sql)方法完成数据删除操作，示例操作:

Statement statement = connection.createStatement();
String sql = "delete from user where id = 1";
int num = statement.executeUpdate(sql);
if(num>0){
    System.out.println("删除成功！");
}

CRUD操作-update

使用executeUpdate(Sting sql)方法完成数据修改操作，示例操作:

Statement statement = connection.createStatement();
String sql = "update user set name = '' where name = ''";
int num = statement.executeUpdate(sql);
if(num>0){
    System.out.println("修改成功！");
}

CRUD操作-read

使用executeQuery(String sql)方法完成数据查询操作，示例操作：

Statement statement = connection.createStatement();
String sql = "select * from user where id = 1";
ResultSet resultSet = statement.executeQuery(sql);
if(resultSet.next()){
    // 根据获取类的数据类型，分别调用resultSet的相应方法映射到java对象中
}

5.建立JDBC连接工具类

在这里插入图片描述

建立文件（db.properties）

代码示例：

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true
username=root
password=123456

建立工具类（JdbcUtils）

代码示例：

package com.yanglog.lesson02.utils;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class JdbcUtils {

    private static String driver = null;
    private static String url = null;
    private static String username = null;
    private static String password = null;

    static{

        try {
            InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
            Properties properties = new Properties();
            properties.load(in);

            driver = properties.getProperty("driver");
            url = properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");

            //1.驱动只用加载一次
            Class.forName(driver);

        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    //获取连接
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }

    //释放资源
    public static void release(Connection conn, Statement st, ResultSet rs){
        if(rs!=null){
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(st!=null){
            try {
                st.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

使用工具示例

代码示例 (Insert)

package com.yanglog.lesson02;

import com.yanglog.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestInsert {
    public static void main(String[] args) {

        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();
            st = conn.createStatement();

            String sql = "INSERT INTO users(`id`,`NAME`,`PASSWORD`,`email`,`birthday`)" +
                    "VALUES(4,'xiaoming','123456','19191919919@qq.com','2021-03-03')";

            int i = st.executeUpdate(sql);
            if(i>0){
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally{
            JdbcUtils.release(conn,st,rs);
        }
    }
}

代码示例 (Select)

package com.yanglog.lesson02;

import com.yanglog.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestSelect {
    public static void main(String[] args) {

        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;

        try{
            conn = JdbcUtils.getConnection();
            st = conn.createStatement();
            String sql = "SELECT * FROM `users` WHERE id = 1";
            rs = st.executeQuery(sql);
            while(rs.next()){
                System.out.println(rs.getString("name"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

6.SQL注入

sql存在漏洞，会被攻击导致数据泄露

SQL会被拼接（or）

package com.yanglog.lesson02;

import com.yanglog.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class SQL注入 {
    public static void main(String[] args) {
        // login("lisi","123456");    //正常登录
        login("'or'1=1","'or'1=1");	  //盗取出全部用户的名字和密码
    }

    //登录业务
    public static void login(String username,String password){

        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;

        try{
            conn = JdbcUtils.getConnection();
            st = conn.createStatement();
            String sql = "SELECT * FROM `users` WHERE `NAME`='"+username+"' AND `PASSWORD`='"+password+"'";
            rs = st.executeQuery(sql);
            while(rs.next()){
                System.out.println(rs.getString("name"));
                System.out.println(rs.getInt("password"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

7.PreparedStatement对象

PreparedStatement可以防止SQL注入，并且效率更高

新增

package com.yanglog.lesson03;

import com.yanglog.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.util.Date;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class TestInsert {

    public static void main(String[] args) {

        Connection conn = null;
        PreparedStatement st = null;

        try{
            conn = JdbcUtils.getConnection();
            //区别
            //使用?占位符代替参数
            String sql = "INSERT INTO `users`(`id`,`NAME`,`PASSWORD`,`email`,`birthday`) values(?,?,?,?,?)";

            st = conn.prepareStatement(sql); //预编译sql，先写sql，但是不执行

            //手动给参数赋值
            st.setInt(1,5);
            st.setString(2,"yang");
            st.setString(3,"123456");
            st.setString(4,"23434325435@qq.com");
            st.setDate(5,new java.sql.Date(new Date().getTime()));

            int i = st.executeUpdate();
            if(i>0){
                System.out.println("插入成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally{
            JdbcUtils.release(conn,st,null);
        }
    }
}

删除

package com.yanglog.lesson03;

import com.yanglog.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class TestDelete {
    public static void main(String[] args) {

        Connection conn = null;
        PreparedStatement st = null;

        try{
            conn = JdbcUtils.getConnection();
            String sql = "DELETE FROM `users` WHERE id = ?";
            st = conn.prepareStatement(sql);
            st.setInt(1,5);
            int i = st.executeUpdate();
            if(i>0){
                System.out.println("删除成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally{
            JdbcUtils.release(conn,st,null);
        }
    }
}

修改

package com.yanglog.lesson03;

import com.yanglog.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class TestUpdate {
    public static void main(String[] args) {

        Connection conn = null;
        PreparedStatement st = null;

        try{
            conn = JdbcUtils.getConnection();
            String sql = "UPDATE `users` SET `NAME` = 'xiaogang' WHERE `id` = ?";
            st = conn.prepareStatement(sql);

            st.setInt(1,4);
            int i = st.executeUpdate();
            if(i>0){
                System.out.println("修改成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

查询

package com.yanglog.lesson03;

import com.yanglog.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class TestSelect {
    public static void main(String[] args) {

        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtils.getConnection();
            String sql = "SELECT * FROM `users` WHERE `NAMe`=? AND `PASSWORD`=?";
            st = conn.prepareStatement(sql);

            st.setString(1,"lisi");
            st.setString(2,"123456");

            rs = st.executeQuery();
            while(rs.next()){
                System.out.println("id:"+rs.getInt("id"));
                System.out.println("name:"+rs.getString("NAME"));
                System.out.println("password:"+rs.getString("PASSWORD"));
                System.out.println("email:"+rs.getString("email"));
                System.out.println("birthday:"+rs.getDate("birthday"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

防止SQL注入

package com.yanglog.lesson03;

import com.yanglog.lesson02.utils.JdbcUtils;

import java.sql.*;

public class SQL注入 {
    public static void main(String[] args) {
       // login("lisi","123456");
        login(" '' or 1=1","123456");
    }

    public static void login(String username,String password){

        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;

        try{
            conn = JdbcUtils.getConnection();
            String sql = "SELECT * FROM `users` WHERE `NAME`=? AND `PASSWORD`=?";
            st = conn.prepareStatement(sql);

            st.setString(1,username);
            st.setString(2,password);

            rs = st.executeQuery();
            while(rs.next()){
                System.out.println(rs.getString("name"));
                System.out.println(rs.getInt("password"));
                System.out.println("==============================");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

8.使用IDEA连接数据库

在这里插入图片描述

连接成功后，可以选择数据库

双击数据库

在这里插入图片描述

更新数据，点击提交

在这里插入图片描述

连接失败，查看原因
在这里插入图片描述

9.事务

要么都成功，要么都失败

ACID原则

原子性：要么全部完成，要么都不完成

一致性：结果总数不变

隔离性：多个进程互不干扰

持久性：一旦提交不可逆，持久化到数据库

隔离性的问题：

脏读：一个事务读取了另一个没有提交的事务

不可重复读：在同一个事务内重复读取表中的数据，表数据发生了改变

虚度（幻读）：在一个事务内读取到了别人插入的数据，导致前后读出来的结果不一样

代码实现

开启事务

conn.setAutoCommit(false);//开启事务

一组业务执行完毕，提交事务
可以在catch语句中显示地定义回滚语句，但默认失败就会回滚

完整代码

package com.yanglog.lesson04;

import com.yanglog.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class TestTransaction2 {
    public static void main(String[] args) {

        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();

            //关闭数据库的自动提交，这里会自动开启事务
            conn.setAutoCommit(false);//开启事务

            String sql1 = "update `account` set money = money-100 where `name` = 'A'";
            st = conn.prepareStatement(sql1);
            st.executeUpdate();

            int x = 1/0;  //报错，使事务中下面的语句无法执行，此时会被回滚

            String sql2 = "update `account` set money = money+100 where `name` = 'B'";
            st = conn.prepareStatement(sql2);
            st.executeUpdate();

            conn.commit(); //提交事务
            System.out.println("成功");

        } catch (SQLException e) {
            //此处不回滚也可，若出错事务会自动回滚，此处为显示捕获错误
            try {
                conn.rollback();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            e.printStackTrace();
        } finally{
            JdbcUtils.release(conn,st,rs);
        }
    }
}

10.数据库连接池

数据库连接—执行完毕—释放

由于连接—执行十分浪费系统资源因此开发出 “池化技术”

池化技术：准备一些预先的资源，过来就连接这些预先准备好的

最小连接数：10

最大连接数：100 业务最高承载上限

排队等待

等待超时

编写连接池，实现一个接口 DataSource

开源数据源实现（拿来即用）

DBCP

C3P0

Druid：阿里巴巴

使用了这些数据库连接池以后，我们在项目开发中就不需要编写连接数据库的代码了

DBCP

需要用到的jar包：commons-pool-1.6 commons-dbcp-1.4

配置文件（dbcpconfig.properties）

#连接设置    这里面的名字，是DBCP数据源中定义好的
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true
username=root
password=123456

#<!-- 初始化连接 -->
initialSize=10

#最大连接数量
maxActive=50

#<!-- 最大空闲连接 -->
maxIdle=20

#<!-- 最小空闲连接 -->
minIdle=5

#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
maxWait=60000
#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：【属性名=property;】
#注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=UTF8

#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true

#driver default 指定由连接池所创建的连接的只读（read-only）状态。
#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
defaultReadOnly=

#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_UNCOMMITTED

工具

package com.yanglog.lesson05.utils;

import org.apache.commons.dbcp.BasicDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class JdbcUtils_DBCP {

    private static DataSource dataSource = null;
    static{

        try {
            InputStream in = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
            Properties properties = new Properties();
            properties.load(in);

            //创建数据源    工厂模式-->创建
            dataSource = BasicDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //获取连接
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();  //从数据源中获取连接
    }

    //释放资源
    public static void release(Connection conn, Statement st, ResultSet rs){
        if(rs!=null){
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(st!=null){
            try {
                st.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

测试代码

package com.yanglog.lesson05;

import com.yanglog.lesson02.utils.JdbcUtils;
import com.yanglog.lesson05.utils.JdbcUtils_DBCP;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestDBCP {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils_DBCP.getConnection();
            st = conn.createStatement();

            String sql = "INSERT INTO users(`id`,`NAME`,`PASSWORD`,`email`,`birthday`)" +
                    "VALUES(6,'yang','123456','2343246766@qq.com','2021-03-05')";

            int i = st.executeUpdate(sql);
            if(i>0){
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally{
            JdbcUtils_DBCP.release(conn,st,rs);
        }
    }
}

C30P

需要用到的jar包：c3p0-0.9.2.1 mchange-commons-java-0.2.3.4

配置文件（c3p0-config.xml）

<?xml version="1.0" encoding="UTF-8" ?>
<c3p0-config>
    <!--c3p0的缺省（默认）配置
    如果在代码中"ComboPooledDataSource ds = new ComboPooledDataSource();"这样写就表示使用的是C3P0的缺省(默认)配置
    -->
    <default-config>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <!--改成你自己的url-->
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false</property>
        <!--改成你自己的用户名-->
        <property name="user">root</property>
        <!--改成你自己的密码-->
        <property name="password">123456</property>

        <property name="acquireIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </default-config>

    <!--
    C3P0的命名配置,
    如果在代码中"ComboPooledDataSource ds = new ComboPooledDataSource("MySQL");"这样写就表示使用的是name是MySQL
    -->
    <named-config name="MySQL">
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <!--改成你自己的url-->
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false</property>
        <!--改成你自己的用户名-->
        <property name="user">root</property>
        <!--改成你自己的密码-->
        <property name="password">123456</property>

        <property name="acquireIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </named-config>

</c3p0-config>

工具类

package com.yanglog.lesson05;

import com.yanglog.lesson05.utils.JdbcUtils_C3P0;
import com.yanglog.lesson05.utils.JdbcUtils_DBCP;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestC3P0 {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils_C3P0.getConnection();
            st = conn.createStatement();

            String sql = "INSERT INTO users(`id`,`NAME`,`PASSWORD`,`email`,`birthday`)" +
                    "VALUES(6,'wi','123456','675675676576@qq.com','2021-03-05')";

            int i = st.executeUpdate(sql);
            if(i>0){
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally{
            JdbcUtils_C3P0.release(conn,st,rs);
        }
    }
}

测试代码

package com.yanglog.lesson05.utils;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

public class JdbcUtils_C3P0 {

    private static ComboPooledDataSource dataSource = null;
    static{

        try {
            //创建数据源    工厂模式-->创建
            dataSource = new ComboPooledDataSource();//配置文件写法
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //获取连接
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();  //从数据源中获取连接
    }

    //释放资源
    public static void release(Connection conn, Statement st, ResultSet rs){
        if(rs!=null){
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(st!=null){
            try {
                st.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

结论

无论使用什么数据源，本质是一样的，DataSource接口不会变，方法就不会变

gdutlog

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
学习笔记---JDBC

JDBC1.数据库驱动驱动：声卡，显卡，数据库程序会通过数据库驱动与数据库打交道2.JDBCSUN公司为了简化开发人员的（对数据库的统一）操作，提供了一个Java操作数据库的规范，俗称JDBC这些规范的实现由具体的厂商去做对于开发人员来说，我们只需要掌握JDBC的接口操作即可！java.sqljavax.sql还需要导入一个数据库驱动包 mysql-connector-java3.第一个JDBC程序创建测试数据库CREATE DATABASE jdbcStudy CHAR
复制链接

扫一扫

专栏目录