第一个JDBC程序

创建测试数据库

  1. CREATE DATABASE jdbcStudy CHARACTER SET utf8 COLLATE utf8_general_ci;
  3. USE jdbcStudy;
  5. CREATE TABLE users(
  6.    id INT PRIMARY KEY,
  7.    NAME VARCHAR(40),
  8.    PASSWORD VARCHAR(40),
  9.    email VARCHAR(60),
  10.    birthday DATE
  11. )
  13. INSERT INTO users(id,NAME,PASSWORD,email,birthday)
  14. VALUES(1,'zhangsan','123456','zs@sina.com','1980-12-04'),
  15. (2,'lisi','123456','lisi@sina.com','1981-12-04'),
  16. (3,'wangwu','123456','wangwu@sina.com','1979-12-04');
  1. 创建一个普通项目
  2. 导入数据库驱动
  3. 编写测试代码
  1. import java.sql.*;
  3. //我的第一个JDBC程序
  4. public class JdbcFirstDemo {
  5.     public static void main(String[] args) throws ClassNotFoundException, SQLException {
  6.         //1. 加载驱动
  7.         Class.forName("com.mysql.jdbc.Driver"); //固定写法，加载驱动
  8.         //2. 用户信息和url
  9.         String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true";
  10.         String username = "root";
  11.         String password = "123456";
  12.         //3. 连接成功，返回数据库对象
  13.         Connection connection = DriverManager.getConnection(url, username, password);
  15.         //4. 执行SQL的对象
  16.         Statement statement = connection.createStatement();
  18.         //5. 执行SQL的对象 去 执行SQL，可能存在结果，查看返回结果
  19.         String sql = "SELECT * FROM users";
  20.         ResultSet resultSet = statement.executeQuery(sql); //返回的结果集，结果集中封装了我们全部的查询出来的结果
  22.         while (resultSet.next()){
  23.             System.out.println("id="+resultSet.getObject("id"));
  24.             System.out.println("name="+resultSet.getObject("NAME"));
  25.             System.out.println("pwd="+resultSet.getObject("PASSWORD"));
  26.             System.out.println("email="+resultSet.getObject("email"));
  27.             System.out.println("birth="+resultSet.getObject("birthday"));
  28.             System.out.println("=================================");
  29.         }
  30.         //6. 释放连接
  31.         resultSet.close();
  32.         statement.close();
  33.         connection.close();
  34.     }
  35. }

步骤总结：

  1. 加载驱动
  2. 连接数据库DriverManager.getConnection
  3. 获得执行sql的对象 Statement
  4. 获得返回的结果集
  5. 释放连接

DriverManager

  1. //1. 加载驱动
  2. //DriverManager.registerDriver(new com.mysql.jdbc.Driver());
  3. Class.forName("com.mysql.jdbc.Driver"); //固定写法，加载驱动
  4. Connection connection = DriverManager.getConnection(url, username, password);
  6. // connection 代表数据库
  7. // 数据库设置自动提交
  8. // 事务提交
  9. // 事务回滚
  10. connection.rollback();
  11. connection.commit();
  12. connection.setAutoCommit();

URL

  1. String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true";
  3. // mysql  -- 3306
  4. //jdbc:mysql://主机地址:端口号/数据库名?参数1&参数2&参数3
  6. // oracle -- 1521
  7. //jdbc:oracle:thin:@localhost:1521:sid

Statement 执行SQL的对象 PrepareStatement 执行SQL的对象

  1. String sql = "SELECT * FROM users"; //编写SQL
  3. statement.executeQuery(); //查询操作返回 ResultSet
  4. statement.execute(); // 执行任何SQL
  5. statement.executeUpdate(); // 更新、插入、删除。都是用这个，返回一个受影响的行数

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

获得指定的数据类型

  1. resultSet.getObject(); // 在不知道列类型的情况下使用
  2. // 如果知道列的类型就使用指定的类型
  3. resultSet.getString();
  4. resultSet.getInt();
  5. resultSet.getFloat();
  6. resultSet.getDouble();
  7. resultSet.getDate();
  8. ....

遍历，指针

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

释放资源

  1. //6. 释放资源
  2. resultSet.close();
  3. statement.close();
  4. connection.close(); // 耗资源，用完关掉！

statement对象

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

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

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

CRUD操作-create

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

  1. Statement st = conn.createStatement();
  2. String sql = "insert into user(...) values(...)";
  3. int num = st.executeUpdate(sql);
  4. if(num>0){
  5.     System.out.println("插入成功！")
  6. }

CRUD操作-delete

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

  1. Statement st = conn.createStatement();
  2. String sql = "delete from user where id=1";
  3. int num = st.executeUpdate(sql);
  4. if(num>0){
  5.     System.out.println("删除成功！")
  6. }

CRUD操作-update

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

  1. Statement st = conn.createStatement();
  2. String sql = "update user set name='' where name=''";
  3. int num = st.executeUpdate(sql);
  4. if(num>0){
  5.     System.out.println("修改成功！")
  6. }

CRUD操作-read

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

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

代码实现

1、提取工具类

  1. driver=com.mysql.jdbc.Driver
  2. url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true
  3. username=root
  4. password=123456
  5. ==========================================================================
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8. import java.sql.*;
  9. import java.util.Properties;
  11. public class JdbcUtils {
  12.     private static String driver = null;
  13.     private static String url = null;
  14.     private static String username = null;
  15.     private static String password = null;
  17.     static{
  18.         try{
  19.             InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
  20.             Properties properties = new Properties();
  21.             properties.load(in);
  23.             driver = properties.getProperty("driver");
  24.             url = properties.getProperty("url");
  25.             username = properties.getProperty("username");
  26.             password = properties.getProperty("password");
  28.             //1.驱动只用加载一次
  29.             Class.forName(driver);
  30.         }catch(IOException | ClassNotFoundException e){
  31.             e.printStackTrace();
  32.         }
  33.     }
  35.     //获取连接
  36.     public static Connection getConnection() throws SQLException {
  37.         return DriverManager.getConnection(url,username,password);
  38.     }
  40.     //释放连接资源
  41.     public static void release(Connection conn, Statement st, ResultSet rs){
  42.         if (rs!=null){
  43.             try {
  44.                 rs.close();
  45.             } catch (SQLException e) {
  46.                 e.printStackTrace();
  47.             }
  48.         }
  49.         if (st!=null){
  50.             try {
  51.                 st.close();
  52.             } catch (SQLException e) {
  53.                 e.printStackTrace();
  54.             }
  55.         }
  56.         if (conn!=null){
  57.             try {
  58.                 conn.close();
  59.             } catch (SQLException e) {
  60.                 e.printStackTrace();
  61.             }
  62.         }
  63.     }
  64. }

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

  1. import com.kuang.lesson02.utils.JdbcUtils;
  3. import java.sql.Connection;
  4. import java.sql.ResultSet;
  5. import java.sql.SQLException;
  6. import java.sql.Statement;
  8. public class TestInsert {
  9.     public static void main(String[] args) {
  10.         Connection conn = null;
  11.         Statement st = null;
  12.         ResultSet rs = null;
  13.         try {
  14.             conn = JdbcUtils.getConnection();//获取数据库连接
  15.             st = conn.createStatement();//获得SQL的执行对象
  16.             String sql = "INSERT INTO users(id,`NAME`,`PASSWORD`,email,birthday)" +
  17.                     "VALUES(4,'kuangshen','123456','24736743@qq.com','2020-01-01')";
  18.             int i = st.executeUpdate(sql);
  19.             if (i>0){
  20.                 System.out.println("插入成功！");
  21.             }
  22.         } catch (SQLException e) {
  23.             e.printStackTrace();
  24.         } finally {
  25.             JdbcUtils.release(conn,st,rs);
  26.         }
  27.     }
  28. }
  29. ==================================================================
  30. import com.kuang.lesson02.utils.JdbcUtils;
  32. import java.sql.Connection;
  33. import java.sql.ResultSet;
  34. import java.sql.SQLException;
  35. import java.sql.Statement;
  37. public class TestDelete {
  38.     public static void main(String[] args) {
  39.         Connection conn = null;
  40.         Statement st = null;
  41.         ResultSet rs = null;
  42.         try {
  43.             conn = JdbcUtils.getConnection();//获取数据库连接
  44.             st = conn.createStatement();//获得SQL的执行对象
  45.             String sql = "DELETE FROM users WHERE id=4;";
  46.             int i = st.executeUpdate(sql);
  47.             if (i>0){
  48.                 System.out.println("删除成功！");
  49.             }
  50.         } catch (SQLException e) {
  51.             e.printStackTrace();
  52.         } finally {
  53.             JdbcUtils.release(conn,st,rs);
  54.         }
  55.     }
  56. }
  57. ================================================================
  58. import com.kuang.lesson02.utils.JdbcUtils;
  60. import java.sql.Connection;
  61. import java.sql.ResultSet;
  62. import java.sql.SQLException;
  63. import java.sql.Statement;
  65. public class TestUpdate {
  66.     public static void main(String[] args) {
  67.         Connection conn = null;
  68.         Statement st = null;
  69.         ResultSet rs = null;
  70.         try {
  71.             conn = JdbcUtils.getConnection();//获取数据库连接
  72.             st = conn.createStatement();//获得SQL的执行对象
  73.             String sql = "UPDATE users SET `NAME` = 'kuangshen' WHERE id=1;";
  74.             int i = st.executeUpdate(sql);
  75.             if (i>0){
  76.                 System.out.println("更新成功！");
  77.             }
  78.         } catch (SQLException e) {
  79.             e.printStackTrace();
  80.         } finally {
  81.             JdbcUtils.release(conn,st,rs);
  82.         }
  83.     }
  84. }

3、查询，executeQuery

  1. import com.kuang.lesson02.utils.JdbcUtils;
  3. import java.sql.Connection;
  4. import java.sql.ResultSet;
  5. import java.sql.SQLException;
  6. import java.sql.Statement;
  8. public class TestSelect {
  9.     public static void main(String[] args) {
  10.         Connection conn = null;
  11.         Statement st = null;
  12.         ResultSet rs = null;
  13.         try {
  14.             conn = JdbcUtils.getConnection();
  15.             st = conn.createStatement();
  16.             String sql = "SELECT * FROM users WHERE `id` = 1;";
  17.             rs = st.executeQuery(sql);
  18.             while (rs.next()){
  19.                 System.out.println(rs.getString("NAME"));
  20.             }
  21.         } catch (SQLException e) {
  22.             e.printStackTrace();
  23.         }finally {
  24.             JdbcUtils.release(conn,st,rs);
  25.         }
  26.     }
  27. }

SQL注入的问题

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

  1. import java.sql.Connection;
  2. import java.sql.ResultSet;
  3. import java.sql.SQLException;
  4. import java.sql.Statement;
  6. public class SQL注入 {
  7.     public static void main(String[] args) {
  8.         // login("kuangshen","123456");
  9.         login(" 'or '1=1"," 'or '1=1"); //技巧
  10.     }
  11.     // 登陆业务
  12.     public static void login(String username,String password){
  14.         Connection conn = null;
  15.         Statement st = null;
  16.         ResultSet rs = null;
  17.         try {
  18.             conn = JdbcUtils.getConnection();
  19.             st = conn.createStatement();
  21.             //SELECT * FROM users WHERE `NAME`='kuangshen' AND `PASSWORD`='123456'
  22.             //SELECT * FROM users WHERE `NAME`=' 'or '1=1' AND `PASSWORD`=' 'or '1=1'
  23.             String sql = "SELECT * FROM users WHERE `NAME` = '"+username+"' AND `password` ='"+password+"'";
  25.             rs = st.executeQuery(sql);
  26.             while (rs.next()){
  27.                 System.out.println(rs.getString("NAME"));
  28.                 System.out.println(rs.getString("password"));
  29.             }
  30.         } catch (SQLException e) {
  31.             e.printStackTrace();
  32.         }finally {
  33.             JdbcUtils.release(conn,st,rs);
  34.         }
  35.     }
  36. }

PreparedStatement对象

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

1、新增

  1. import com.kuang.lesson02.utils.JdbcUtils;
  3. import java.sql.*;
  4. import java.util.Date;
  6. public class TestInsert {
  7.     public static void main(String[] args) {
  8.         Connection conn = null;
  9.         PreparedStatement st = null;
  10.         try {
  11.             conn = JdbcUtils.getConnection();
  13.             //区别
  14.             //使用？占位符代替参数
  15.             String sql = "insert into users(id,`NAME`,`PASSWORD`,`email`,`birthday`) values(?,?,?,?,?)";
  17.             st = conn.prepareStatement(sql); //预编译SQL，先写sql，然后不执行
  19.             //手动给参数赋值
  20.             st.setInt(1,4);
  21.             st.setString(2,"qinjiang");
  22.             st.setString(3,"123456");
  23.             st.setString(4,"24736743@qq.com");
  24.             //注意点：sql.Date     数据库  java.sql.Date()
  25.             //       util.Date    Java   new Date().getTime()  获得时间戳
  26.             st.setDate(5,new java.sql.Date(new Date().getTime()));
  28.             //执行
  29.             int i = st.executeUpdate();
  30.             if (i>0){
  31.                 System.out.println("插入成功！");
  32.             }
  34.         } catch (SQLException e) {
  35.             e.printStackTrace();
  36.         }finally {
  37.             JdbcUtils.release(conn,st,null);
  38.         }
  39.     }
  40. }

2、删除

  1. import com.kuang.lesson02.utils.JdbcUtils;
  3. import java.sql.Connection;
  4. import java.sql.PreparedStatement;
  5. import java.sql.SQLException;
  6. import java.util.Date;
  8. public class TestDelete {
  9.     public static void main(String[] args) {
  10.         Connection conn = null;
  11.         PreparedStatement st = null;
  12.         try {
  13.             conn = JdbcUtils.getConnection();
  15.             //区别
  16.             //使用？占位符代替参数
  17.             String sql = "delete from users where id=?";
  19.             st = conn.prepareStatement(sql); //预编译SQL，先写sql，然后不执行
  21.             //手动给参数赋值
  22.             st.setInt(1,4);
  24.             //执行
  25.             int i = st.executeUpdate();
  26.             if (i>0){
  27.                 System.out.println("删除成功！");
  28.             }
  30.         } catch (SQLException e) {
  31.             e.printStackTrace();
  32.         }finally {
  33.             JdbcUtils.release(conn,st,null);
  34.         }
  35.     }
  36. }

3、更新

  1. import com.kuang.lesson02.utils.JdbcUtils;
  3. import java.sql.Connection;
  4. import java.sql.PreparedStatement;
  5. import java.sql.SQLException;
  7. public class TestUpdate {
  8.     public static void main(String[] args) {
  9.         Connection conn = null;
  10.         PreparedStatement st = null;
  11.         try {
  12.             conn = JdbcUtils.getConnection();
  14.             //区别
  15.             //使用？占位符代替参数
  16.             String sql = "update users set `NAME` = ? where id=?;";
  18.             st = conn.prepareStatement(sql); //预编译SQL，先写sql，然后不执行
  20.             //手动给参数赋值
  21.             st.setString(1,"狂神");
  22.             st.setInt(2,1);
  24.             //执行
  25.             int i = st.executeUpdate();
  26.             if (i>0){
  27.                 System.out.println("更新成功！");
  28.             }
  30.         } catch (SQLException e) {
  31.             e.printStackTrace();
  32.         }finally {
  33.             JdbcUtils.release(conn,st,null);
  34.         }
  35.     }
  36. }

4、查询

  1. import com.kuang.lesson02.utils.JdbcUtils;
  3. import java.sql.Connection;
  4. import java.sql.PreparedStatement;
  5. import java.sql.ResultSet;
  6. import java.sql.SQLException;
  8. public class TestSelect {
  9.     public static void main(String[] args) {
  11.         Connection conn = null;
  12.         PreparedStatement st = null;
  13.         ResultSet rs = null;
  15.         try {
  16.             conn = JdbcUtils.getConnection();
  18.             String sql = "select * from users where id=?";//编写SQL
  19.             st = conn.prepareStatement(sql);//预编译
  21.             st.setInt(1,1);//传递参数
  23.             rs = st.executeQuery();//执行
  24.             if (rs.next()){
  25.                 System.out.println("查询成功！");
  26.                 System.out.println(rs.getString("NAME"));
  27.             }
  29.         } catch (SQLException e) {
  30.             e.printStackTrace();
  31.         }
  32.     }
  33. }

5、防止SQL注入

  1. import com.kuang.lesson02.utils.JdbcUtils;
  3. import java.sql.Connection;
  4. import java.sql.PreparedStatement;
  5. import java.sql.ResultSet;
  7. public class SQL注入 {
  8.     public static void main(String[] args) {
  9.         login("lisi","123456");
  10.         //login("'' or 1=1","123456"); //技巧
  11.     }
  12.     // 登陆业务
  13.     public static void login(String username,String password){
  15.         Connection conn = null;
  16.         PreparedStatement st = null;
  17.         ResultSet rs = null;
  18.         try {
  19.             conn = JdbcUtils.getConnection();
  21.             //PreparedStatement 防止SQL诸如的本质，把传递进来的参数当作字符
  22.             //假设其中存在转义字符，比如说 ' 会被直接转义
  23.             String sql = "select * from users where `NAME` = ? and `PASSWORD` = ?;";
  25.             st = conn.prepareStatement(sql);
  26.             st.setString(1,username);
  27.             st.setString(2,password);
  29.             rs = st.executeQuery(sql);//查询完毕会返回一个结果集
  30.             while (rs.next()){
  31.                 System.out.println(rs.getString("NAME"));
  32.                 System.out.println(rs.getString("password"));
  33.             }
  34.         } catch (Exception e) {
  35.             e.printStackTrace();
  36.         }finally {
  37.             JdbcUtils.release(conn,st,rs);
  38.         }
  39.     }
  40. }

使用IDEA连接数据库

1、

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

更新数据

切换数据库

IDEA实现事务

要么都成功，要么都失败

ACID原则

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

一致性：总数不变

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

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

隔离性的问题：

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

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

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

代码实现

1、开启事务 conn.setAutoCommit(false);

2、一组业务执行完毕，提交事务

3、可以在catch语句中显式的定义回滚语句，但默认失败就会回滚

  1. import com.kuang.lesson02.utils.JdbcUtils;
  3. import java.sql.Connection;
  4. import java.sql.PreparedStatement;
  5. import java.sql.ResultSet;
  6. import java.sql.SQLException;
  8. public class TestTransaction1 {
  9.     public static void main(String[] args) {
  10.         Connection conn = null;
  11.         PreparedStatement st = null;
  12.         ResultSet rs = null;
  14.         try {
  15.             conn = JdbcUtils.getConnection();
  16.             //关闭数据库的自动提交,自动会开启事务
  17.             conn.setAutoCommit(false);
  19.             String sql1 = "update account set money = money-100 where name = 'A'";
  20.             st = conn.prepareStatement(sql1);
  21.             st.executeUpdate();
  23.             int x = 1/0; //报错
  25.             String sql2 = "update account set money = money+100 where name = 'B'";
  26.             st = conn.prepareStatement(sql2);
  27.             st.executeUpdate();
  29.             //业务完毕，提交事务
  30.             conn.commit();
  31.             System.out.println("成功！");
  33.         } catch (SQLException e) {
  34.             //如果失败，则默认回滚
  35.             /*try {
  36.                 conn.rollback();//如果失败则回滚事务
  37.             } catch (SQLException ex) {
  38.                 ex.printStackTrace();
  39.             }*/
  40.             e.printStackTrace();
  41.         }finally {
  42.             JdbcUtils.release(conn,st,null);
  43.         }
  44.     }
  45. }

数据库连接池

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

连接 --- 释放 十分浪费系统资源

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

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

常用连接数 10个

最小连接数：10

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

排队等待，

等待超时：100ms

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

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

DBCP

C3P0

Druid：阿里巴巴

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

DBCP

需要用到的 jar 包

commons-dbcp-1.4、commons-pool-1.6

  1. //Java的src文件夹下设置properties配置文件
  2. #连接设置
  3. driverClassName=com.mysql.jdbc.Driver
  4. url=jdbc:mysql://localhost:3306/jdbcStudy?useUnicode=true&characterEncoding=utf8&useSSL=true
  5. username=root
  6. password=123456
  8. #<!-- 初始化连接 -->
  9. initialSize=10
  11. #最大连接数量
  12. maxActive=50
  14. #<!-- 最大空闲连接 -->
  15. maxIdle=20
  17. #<!-- 最小空闲连接 -->
  18. minIdle=5
  20. #<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
  21. maxWait=60000
  23. #JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;]
  24. #注意："user" 与 "password" 两个属性会被明确的传递，因此这里不需要包含他们。
  25. connectionProperties=useUnicode=true;characterEncoding=UTF8
  27. #指定由连接池所创建的连接的自动提交（auto-commit）状态。
  28. defaultAutoCommit=true
  30. #driver default 指定由连接池所创建的连接的只读（read-only）状态。
  31. #如果没有设置该值，则"setReadOnly"方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
  32. defaultReadOnly=
  34. #driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
  35. #可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED,READ_COMMITTED,REPEATABLE_READ,SERIALIZABLE
  36. defaultTransactionIsolation=READ_UNCOMMITTED
  37. ===================================
  38. import com.kuang.lesson02.utils.JdbcUtils;
  39. import org.apache.commons.dbcp.BasicDataSourceFactory;
  40. import javax.sql.DataSource;
  41. import java.io.InputStream;
  42. import java.sql.*;
  43. import java.util.Properties;
  45. public class JdbcUtils_DBCP {
  47.     private static DataSource dataSource;
  49.     static{
  50.         try{
  51.             InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
  52.             Properties properties = new Properties();
  53.             properties.load(in);
  54.             //创建数据源 工厂模式--> 创建
  55.             dataSource = BasicDataSourceFactory.createDataSource(properties);
  56.         }catch(Exception e){
  57.             e.printStackTrace();
  58.         }
  59.     }
  60.     //获取连接
  61.     public static Connection getConnection() throws SQLException {
  62.         return dataSource.getConnection();//从数据源中获取连接
  63.     }
  64.     //释放连接资源
  65.     public static void release(Connection conn, Statement st, ResultSet rs){
  66.         if (rs!=null){
  67.             try {
  68.                 rs.close();
  69.             } catch (SQLException e) {
  70.                 e.printStackTrace();
  71.             }
  72.         }
  73.         if (st!=null){
  74.             try {
  75.                 st.close();
  76.             } catch (SQLException e) {
  77.                 e.printStackTrace();
  78.             }
  79.         }
  80.         if (conn!=null){
  81.             try {
  82.                 conn.close();
  83.             } catch (SQLException e) {
  84.                 e.printStackTrace();
  85.             }
  86.         }
  87.     }
  88. }
  89. ===================================
  90. import com.kuang.lesson05.utils.JdbcUtils_DBCP;
  91. import java.sql.Connection;
  92. import java.sql.PreparedStatement;
  93. import java.sql.SQLException;
  94. import java.util.Date;
  96. public class TestDBCP {
  97.     public static void main(String[] args) {
  98.         Connection conn = null;
  99.         PreparedStatement st = null;
  100.         try {
  101.             conn = JdbcUtils_DBCP.getConnection();
  102.             //区别
  103.             //使用？占位符代替参数
  104.             String sql = "insert into users(id,`NAME`,`PASSWORD`,`email`,`birthday`) values(?,?,?,?,?)";
  105.             st = conn.prepareStatement(sql); //预编译SQL，先写sql，然后不执行
  106.             //手动给参数赋值
  107.             st.setInt(1,4);
  108.             st.setString(2,"qinjiang");
  109.             st.setString(3,"123456");
  110.             st.setString(4,"24736743@qq.com");
  111.             //注意点：sql.Date     数据库  java.sql.Date()
  112.             //       util.Date    Java   new Date().getTime()  获得时间戳
  113.             st.setDate(5,new java.sql.Date(new Date().getTime()));
  114.             //执行
  115.             int i = st.executeUpdate();
  116.             if (i>0){
  117.                 System.out.println("插入成功！");
  118.             }
  119.         } catch (SQLException e) {
  120.             e.printStackTrace();
  121.         }finally {
  122.             JdbcUtils_DBCP.release(conn,st,null);
  123.         }
  124.     }
  125. }

C3P0

需要用到的 jar 包

commons-dbcp-1.4、 commons-pool-1.6

  1. //Java的src文件夹下设置XML配置文件
  2. <?xml version="1.0" encoding="UTF-8"?>
  3. <c3p0-config>
  4.     <!--
  5.     C3P0的缺省（默认）配置，
  6.     如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource();”这样写就表示使用的是C3P0的缺省（默认）
  7.     -->
  8.     <default-config>
  9.         <property name="driverClass">com.mysql.jdbc.Driver</property>
  10.         <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcStudy?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=true</property>
  11.         <property name="user">root</property>
  12.         <property name="password">123456</property>
  13.         <property name="acquireIncrement">5</property>
  14.         <property name="initialPoolSize">10</property>
  15.         <property name="minPoolSize">5</property>
  16.         <property name="maxPoolSize">20</property>
  17.     </default-config>
  19.     <!--
  20.     C3P0的命名配置，
  21.     如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource("MySQL");”这样写就表示使用的是name是MySQL
  22.     -->
  23.     <named-config name="MySQL">
  24.         <property name="driverClass">com.mysql.jdbc.Driver</property>
  25.         <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcStudy?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=true</property>
  26.         <property name="user">root</property>
  27.         <property name="password">123456</property>
  28.         <property name="acquireIncrement">5</property>
  29.         <property name="initialPoolSize">10</property>
  30.         <property name="minPoolSize">5</property>
  31.         <property name="maxPoolSize">20</property>
  32.     </named-config>
  33. </c3p0-config>
  34. ==================================
  35. import com.mchange.v2.c3p0.ComboPooledDataSource;
  36. import javax.sql.DataSource;
  37. import java.sql.Connection;
  38. import java.sql.ResultSet;
  39. import java.sql.SQLException;
  40. import java.sql.Statement;
  42. public class JdbcUtils_C3P0 {
  43.     private static DataSource dataSource;
  45.     static{
  46.         try{
  47.             //代码版配置
  48.             /*dataSource = new ComboPooledDataSource();
  49.             dataSource.setDriverClass();
  50.             dataSource.setUser();
  51.             dataSource.setPassword();
  52.             dataSource.setJdbcUrl();
  53.             dataSource.setMaxPoolSize();
  54.             dataSource.setMinPoolSize();*/
  56.             //创建数据源 工厂模式--> 创建
  57.             dataSource = new ComboPooledDataSource("MySQL");//配置文件写法
  58.         }catch(Exception e){
  59.             e.printStackTrace();
  60.         }
  61.     }
  62.     //获取连接
  63.     public static Connection getConnection() throws SQLException {
  64.         return dataSource.getConnection();//从数据源中获取连接
  65.     }
  66.     //释放连接资源
  67.     public static void release(Connection conn, Statement st, ResultSet rs){
  68.         if (rs!=null){
  69.             try {
  70.                 rs.close();
  71.             } catch (SQLException e) {
  72.                 e.printStackTrace();
  73.             }
  74.         }
  75.         if (st!=null){
  76.             try {
  77.                 st.close();
  78.             } catch (SQLException e) {
  79.                 e.printStackTrace();
  80.             }
  81.         }
  82.         if (conn!=null){
  83.             try {
  84.                 conn.close();
  85.             } catch (SQLException e) {
  86.                 e.printStackTrace();
  87.             }
  88.         }
  89.     }
  90. }
  91. ===================================
  92. import com.kuang.lesson05.utils.JdbcUtils_C3P0;
  93. import java.sql.Connection;
  94. import java.sql.PreparedStatement;
  95. import java.sql.SQLException;
  96. import java.util.Date;
  98. public class TestC3P0 {
  99.     public static void main(String[] args) {
  100.         Connection conn = null;
  101.         PreparedStatement st = null;
  102.         try {
  103.             conn = JdbcUtils_C3P0.getConnection();//原来是自己实现的，现在用别人实现的
  104.             //区别
  105.             //使用？占位符代替参数
  106.             String sql = "insert into users(id,`NAME`,`PASSWORD`,`email`,`birthday`) values(?,?,?,?,?)";
  107.             st = conn.prepareStatement(sql); //预编译SQL，先写sql，然后不执行
  108.             //手动给参数赋值
  109.             st.setInt(1,5);
  110.             st.setString(2,"qinjiang");
  111.             st.setString(3,"123456");
  112.             st.setString(4,"24736743@qq.com");
  113.             //注意点：sql.Date     数据库  java.sql.Date()
  114.             //       util.Date    Java   new Date().getTime()  获得时间戳
  115.             st.setDate(5,new java.sql.Date(new Date().getTime()));
  117.             //执行
  118.             int i = st.executeUpdate();
  119.             if (i>0){
  120.                 System.out.println("插入成功！");
  121.             }
  122.         } catch (SQLException e) {
  123.             e.printStackTrace();
  124.         }finally {
  125.             JdbcUtils_C3P0.release(conn,st,null);
  126.         }
  127.     }
  128. }

结论

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

Java的JDBC的更多相关文章

  1. Java的JDBC操作

    Java的JDBC操作 [TOC] 1.JDBC入门 1.1.什么是JDBC JDBC从物理结构上来说就是java语言访问数据库的一套接口集合,本质上是java语言根数据库之间的协议.JDBC提供一组 ...

  2. JAVA使用JDBC技术操作SqlServer数据库执行存储过程

    Java使用JDBC技术操作SqlServer数据库执行存储过程: 1.新建SQLSERVER数据库:java_conn_test 2.新建表:tb_User 3.分别新建三个存储过程: 1>带 ...

  3. Java使用Jdbc操作MySql数据库(一)

    这个示例是Java操作MySql的基本方法. 在这个示例之前,要安装好MySql,并且配置好账户密码,创建一个logininfo数据库,在数据库中创建userinfo数据表.并且在表中添加示例数据. ...

  4. Java 通过JDBC查询数据库表结构(字段名称,类型,长度等)

    Java 通过JDBC查询数据库表结构(字段名称,类型,长度等) 发布者:唛唛家的豆子   时间:2012-11-20 17:54:02   Java 通过JDBC查询数据库表结构(字段名称,类型,长 ...

  5. JAVA使用jdbc连接MYSQL简单示例

    以下展示的为JAVA使用jdbc连接MYSQL简单示例: import java.sql.DriverManager; import java.sql.ResultSet; import java.s ...

  6. 基于CDH5.x 下面使用eclipse 操作hive 。使用java通过jdbc连接HIVESERVICE 创建表

    基于CDH5.x 下面使用eclipse 操作hive .使用java通过jdbc连接HIVESERVICE 创建表 import java.sql.Connection; import java.s ...

  7. java之JDBC

    java之JDBC 一.什么是JDBC Java 数据库连接,(Java Database Connectivity,简称JDBC)是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口,提 ...

  8. java 调用jdbc 实现excel和csv的导入和导出

    jdbc 的连接 实体类 package com.gpdi.mdata.web.manage.database.data;public class DBQueryData {private Strin ...

  9. Java的JDBC事务详解

    Java的JDBC事务详解         分类:             Hibernate              2010-06-02 10:04     12298人阅读     评论(9) ...

  10. Java数据库连接--JDBC调用存储过程，事务管理和高级应用

    相关链接:Jdbc调用存储过程 一.JDBC常用的API深入详解及存储过程的调用 1.存储过程的介绍 我们常用的操作数据库语言SQL语句在执行的时候要先进行编译,然后执行,而存储过程是在大型数据库系统 ...

随机推荐

  1. c++和c中const的区别

    const在c与c++的区别与使用 大学期间对c和c++的了解太少了,现在工作了导致自己来恶补,简单的const关键字里面的学问还是挺大的,越是基础的知识越是容易忘却,所以今天开始记录着自己每一天的学 ...

  2. RabbitMQ，RocketMQ，Kafka 消息模型对比分析

    消息模型 消息队列的演进 消息队列模型 发布订阅模型 RabbitMQ的消息模型 交换器的类型 direct topic fanout headers Kafka的消息模型 RocketMQ的消息模型 ...

  3. CF31B Sysadmin Bob 题解

    Content 给定一个字符串 \(s\),请将其分解为诸如 \(\texttt{xx@xx}\) 的子串,并将分解后的所有子串输出,或者说不存在这样的方案. 数据范围:\(1\leqslant|s| ...

  4. CF1492A Three swimmers 题解

    Update \(\texttt{2021.3.9}\) 修改了题解中的错别字. \(\texttt{2021.12.16}\) 修改了一个没括回的区间. Content 有 \(3\) 个游泳者,同 ...

  5. 缓存系统redis操作、mongdb、memeche

    mongdb :默认数据持久化,存在内存的同时也向硬盘写数据. redis:可配置数据持久化,默认数据在内存中 memeche:only support 内存模式 redis操作 https://ww ...

  6. Jenkins安装部署使用图文详解（非常详细）

    前言 最近公司需要弄一套自动化运维部署,于是抽空学习了一下,用了两天左右完成Jenkins的安装部署和各种项目的配置化,于是整理一下进行分享. 介绍 Jenkins是一个独立的开源软件项目,是基于Ja ...

  7. Caused by: redis.clients.jedis.exceptions.JedisDataException: READONLY You can't write against a read only slave.

    Caused by: redis.clients.jedis.exceptions.JedisDataException: READONLY You can't write against a rea ...

  8. CMake之常用内置变量和message用法

    关于 cmake 定义了相当丰富的变量,然而,我常用的也就那几个 脑子笨,记不住变量的值时,我会使用cmake的message函数输出变量值 为什么要写这个? 最近尝试使用Modern CMake, ...

  9. 【LeetCode】716. Max Stack 解题报告(C++)

    作者: 负雪明烛 id: fuxuemingzhu 个人博客:http://fuxuemingzhu.cn/ 目录 题目描述 题目大意 解题方法 双栈 日期 题目地址:https://leetcode ...

  10. 【LeetCode】910. Smallest Range II 解题报告（Python & C++）

    作者: 负雪明烛 id: fuxuemingzhu 个人博客: http://fuxuemingzhu.cn/ 目录 题目描述 题目大意 解题方法 日期 题目地址:https://leetcode.c ...