首页 > 其他分享 >JDBC

JDBC

时间：2022-12-26 20:57:08浏览次数：39  
标签：JDBC java String st sql import conn

JDBC（重点）

1.数据库驱动

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

通过数据库驱动 和 数据库 打交道。

2.JDBC

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

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

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

java.sql

javax.sql

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

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','zhangsan','123456','[email protected]','1980-12-04'),
('2','lisi','123456','[email protected]','1981-12-04'),
('3','wangwu','123456','[email protected]','1979-12-04');

1、创建一个普通项目

2、导入数据库驱动

3、编写测试代码

package com.deng.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
        //useUnicode=true&characterEncoding=utf8&useSSL=true" 支持中文编码+设定中文字符集+使用安全的连接
        //报错：useSSL=true ->useSSL=false  mysql版本问题
        String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false";
        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("birth="+resultSet.getObject("birthday"));
            System.out.println("============================================");
        }

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

步骤总结：

  1. 加载驱动
  2. 连接数据库DriverManager
  3. 获取执行SQL的对象 Statement （不太安全）
  4. 获得返回的结果集
  5. 释放连接

DriverManager

//1.加载驱动
//DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Class.forName("com.mysql.jdbc.Driver"); //固定写法，加载驱动
Connection connection = DriverManager.getConnection(url, username, password);

//connection 代表数据库
//事务回滚
//事务提交
//数据库设置自动提交

connection.rollback();
connection.commit();
connection.setAutoCommit();

URL

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

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

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

Statement执行SQL的对象 prepareStatement执行SQL的对象

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

statement.executeQuery(); //查询操作返回  ResultSet
statement.execute(); //执行任何SQL
statement.executeUpdate();//更新、插入、删除 都是用这个，返回一个受影响的行数
statement.executeBatch();//多个SQL 批处理

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

获得指定的数据类型

resultSet.getObject();//在不知道列类型的情况下使用
//如果知道列的类型就是用指定的类型
resultSet.getString();
resultSet.getInt();
resultSet.getFloat();
resultSet.getDate();
resultset.getObject();
......

遍历：指针

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

释放资源

//6.释放连接
resultSet.close();
statement.close();
connection.close(); //耗资源，用完关掉！

4.statement对象

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

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

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

CRUD操作-create

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

String sql = " insert into user(…) values(…)"
int num= st.executeUpdate(sq1);
if(num>0){
    system.out. printIn("插入成功!!!")
}

CRUD操作 - delete

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

Statement st = conn.createStatement();
String sql = "delete from user where id=l";
int num = st.executeUpdate(sql);
if(num > 0){
   system.out.printIn("删除成功!!!"); 
}

CRUD操作 - update

用 executeUpdate( String sql) 方法完成数据修改操作,示例操作：

Statement st = conn.createStatement();
String sql = "update user set name='' where name =''";
int num = st.executeUpdate(sql);
if(num > 0){
	system.out.printIn("修改成功!!!");
}

CRUD操作 - read

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

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

代码实现

  1. 提取工具类

  2. 编写增删改的方法，executeUpdate

    • 增

      package com.deng.lesson02;

import com.deng.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(); //获得SQL的执行对象
            String sql = "INSERT INTO users(`id`,`NAME`,`PASSWORD`,`email`,`birthday`)" +
                    "VALUES(4,'deng','123456','[email protected]','2022-12-23')";

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

    • 删

      package com.deng.lesson02;

import com.deng.lesson02.utils.JdbcUtils;

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

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

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

        try {
            conn = JdbcUtils.getConnection();//获取数据库连接
            st = conn.createStatement(); //获得SQL的执行对象
            String sql = "DELETE FROM users WHERE id=4";

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

    • 改

      package com.deng.lesson02;

import com.deng.lesson02.utils.JdbcUtils;

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

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

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

        try {
            conn = JdbcUtils.getConnection();//获取数据库连接
            st = conn.createStatement(); //获得SQL的执行对象
            String sql = "UPDATE users SET `NAME`='deng',`email`='[email protected]' WHERE id=1";

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

    1. 查询 executeQuery

      package com.deng.lesson02;

import com.deng.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();

            //SQL
            String sql = "select * from users where id =1";

            rs = st.executeQuery(sql); //查询完毕会返回一个结果集
            if(rs.next()){
                System.out.println(rs.getString("NAME"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

    SQL注入的问题

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

package com.deng.lesson02;

import com.deng.lesson02.utils.JdbcUtils;

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

public class SqlZhuru {
    public static void main(String[] args) {
        // login("deng","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();

            //SQL
            //SELECT * FROM users WHERE `NAME`='deng' AND `PASSWORD`='123456';
            //SELECT * FROM users WHERE `NAME`=''or'1=1' AND `PASSWORD`=''or'1=1';
            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.getString("password"));
                System.out.println("================");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

5.PreparedStatement对象

PreparedStatement 可以防止SQL注入。效率更好！

  1. 新增
package com.deng.lesson03;

import com.deng.lesson02.utils.JdbcUtils;

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

public class TestInsert {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
        // ResultSet rs = 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, 4);
            st.setString(2, "dengsy");
            st.setString(3, "123456");
            st.setString(4, "[email protected]");
            //注意点：sql.Date    数据库  java.sql.Date()
            //       util.Date  Java   new Date().getTime()  获得时间戳
            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);
        }
    }
}
  1. 删除
package com.deng.lesson03;

import com.deng.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);//预编译SQL，先写sql，然后不执行

            //手动给参数赋值
            st.setInt(1, 4);

            //执行
            int i = st.executeUpdate();
            if (i > 0) {
                System.out.println("删除成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, null);
        }
    }
}
  1. 更新
package com.deng.lesson03;

import com.deng.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`=? where id =?;";

            st = conn.prepareStatement(sql);//预编译SQL，先写sql，然后不执行

            //手动给参数赋值
            st.setString(1, "dengsy");
            st.setInt(2, 1);

            //执行
            int i = st.executeUpdate();
            if (i > 0) {
                System.out.println("更新成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, null);
        }
    }
}
  1. 查询
package com.deng.lesson03;

import com.deng.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 id=?";  //编写SQL

            st = conn.prepareStatement(sql);  //预编译

            st.setInt(1,1);   //传递参数

            rs = st.executeQuery();   //执行

            if (rs.next()){
                System.out.println(rs.getString("NAME"));
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}
  1. 防止SQL注入
package com.deng.lesson03;

import com.deng.lesson02.utils.JdbcUtils;

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

public class SqlZhuru {
    public static void main(String[] args) {
        //login("dengsy", "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();

            //PreparedStatement 防止SQL注入的本质：把传递进来的参数当作字符
            //假设其中存在转义字符，就直接忽略了，引号会被直接转义
            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.getString("password"));
                System.out.println("================");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

6.使用IDEA连接数据库

数据库连接不成功的问题解决如下：

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

双击数据库

更新数据：更改数据需要点提交才能更改成功

7.事务

要么都成功，要么都失败

ACID原则

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

一致性：总数不变

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

持久性：一旦提交不可逆

隔离性的问题：

  • 脏读：一个事务读取了另外一个没有提交的事务
  • 不可重复读：在同一个事务内，重复读取表中的数据，表数据发生了改变
  • 虚读（幻读）：在一个事务内，读取到了别人插入的数据，导致前后读出来结果不一致

代码实现

  1. 开启事务 conn.setAutoCommit(false);
  2. 一组业务执行完毕，提交事务
  3. 可以在catch语句中显示的定义回滚语句，但默认失败就会回滚！
package com.deng.lesson04;

import com.deng.lesson02.utils.JdbcUtils;

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

public class TestTransaction1 {
    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 ex) {
                ex.printStackTrace();
            }*/
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

8.数据库连接池

数据库连接-执行完毕-释放 连接--释放 十分浪费资源

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

------- 开门 – 业务员：等待 - 服务 - 关门

最小连接数：10

最大连接数：15

等待超时：100ms

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

开源数据源实现

DBCP

C3P0

Druid：阿里巴巴

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

DBCP

需要用到的jar包

commons-dbcp-1.4、commons-pool-1.6

配置文件：dbcpconfig.properties

#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false
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.deng.lesson05;

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

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

public class TestDBCP {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
        // ResultSet rs = null;
        try {
            conn = JdbcUtils_DBCP.getConnection();

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

            st = conn.prepareStatement(sql);//预编译SQL，先写sql，然后不执行

            //手动给参数赋值
            st.setInt(1, 4);
            st.setString(2, "dengsy");
            st.setString(3, "123456");
            st.setString(4, "[email protected]");
            //注意点：sql.Date    数据库  java.sql.Date()
            //       util.Date  Java   new Date().getTime()  获得时间戳
            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);
        }
    }
}

C3P0

需要用到的jar包

c3p0-0.9.5.5、 mchange-commons-java-0.2.19

配置文件：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.cj.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&amp;characterEncoding=utf8&amp;uesSSL=true</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的命名配置.
    如果在代码中 “ ComboPooleDataSource ds = new ComboPooleDataSource("MySQL");”
    这样写就表示使用的是name是Mysql
    -->
    <named-config name="MySQL">
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcStudy?useUnicode=true&amp;amp;characterEncoding=utf8&amp;amp;useSSL=true</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.deng.lesson05;

import com.deng.lesson05.utils.JdbcUtils_C3P0;

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

public class TestC3P0 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
        // ResultSet rs = null;
        try {
            conn = JdbcUtils_C3P0.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, "dengsy");
            st.setString(3, "123456");
            st.setString(4, "[email protected]");
            //注意点：sql.Date    数据库  java.sql.Date()
            //       util.Date  Java   new Date().getTime()  获得时间戳
            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_C3P0.release(conn, st, null);
        }
    }
}

结论

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

Druid

Apache

补充：useSSL=true 数据库连接不成功时 改为 useSSL=false

标签：JDBC,java,String,st,sql,import,conn
From： https://www.cnblogs.com/dengovo/p/17006809.html

相关文章

  • Spring JDBC
    SpringJDBC  *Spring框架对JDBC的简单封装。提供了JDBCTemplate对象简化JDBC的开发    1.导入jar包（下载地址MavenRepository:Spring-tx(mvnrepository.com)） ......
  • 一文解析Spring JDBC Template的使用指导
    摘要：Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发。本文分享自华为云社区《SpringJdbcTemplate使用解析》，作者：共饮一杯无。Spring框架对JD......
  • JDBC Replication协议
    一、Connector与Failover协议   MysqlConnector/J支持failover协议：即Client链接失效时，将会尝试与其他host建立链接，这个过程对上层应用是透明的。Failover协议是“M......
  • JDBC框架-commonsDbutils
    0.介绍Apache组织提供的一个开源JDBC工具类库1.使用1.1pom.xml<dependency><groupId>commons-dbutils</groupId><artifactId>commons-dbutils</artifactId>......
  • spring中JdbcTemplate的使用
    1、导入依赖<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.......
  • jdbc基本语法
    修改表:  altertableuserrenametouser10;  altertableuseraddpasswordvarchar(20);  altertableuserchangepasswordpwdvarchar(20);  ......
  • JDBC开发步骤
    注册驱动：Class.forName("com.mysql.jdbc.Driver");获得连接：Connnectionconn=DriverManager.getConnection("root","123","jdbc:mysql://localhost:3306/mydb?useUni......
  • 数据库jdbc property文件配置信息片段
    #mysql.propertiesjdbc.url=jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&autoReconnect=true&failOverReadOnly=fals......
  • JDBC
    1.下载jar包下载地址：mvnrepository搜索jar包下载对应的版本2.导入包项目的根目录下新建lib目录，将下载好的包复制进去，最后右击lib目录->AddasLibrary.........
  • 使用 JDBC 和 Spring 访问关系数据
    本指南将引导您完成使用Spring访问关系数据的过程。您将构建什么您将构建一个应用程序，该应用程序使用Spring来访问存储在关系数据库中的数据。​​JdbcTemplate​​你需......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99