【沉浸式求职学习day33】【规范化数据库设计、JDBC、数据库连接池详解】【一篇全是经典代码~】

最新推荐文章于 2025-05-09 17:11:59 发布
最新推荐文章于 2025-05-09 17:11:59 发布
阅读量1.2k 收藏 25
点赞数 28
分类专栏： 沉浸式求职学习 文章标签： 数据库 学习 oracle mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48962633/article/details/147785367
版权

沉浸式求职学习

规范化数据库设计

1.为什么需要数据库设计

当数据库比较复杂时我们需要设计数据库。

糟糕的数据库设计 :

  • 数据冗余,存储空间浪费；
  • 数据更新和插入的异常【屏蔽使用物理外键】；
  • 程序性能差；

良好的数据库设计 :

  • 节省数据的存储空间；
  • 能够保证数据的完整性；
  • 方便进行数据库应用系统的开发；

软件项目开发周期中数据库设计 :

  • 需求分析阶段: 分析客户的业务和数据处理需求；
  • 概要设计阶段:设计数据库的E-R模型图 , 确认需求信息的正确和完整。

设计数据库步骤：

  • 分析需求：分析业务和需要处理的数据库的需求；
  • 概要设计：设计关系E-R图；
  • 收集信息
  • 与该系统有关人员进行交流 , 座谈 , 充分了解用户需求 , 理解数据库需要完成的任务.
  • 标识实体[Entity]
    • 标识数据库要管理的关键对象或实体,实体一般是名词；
    • 标识每个实体需要存储的详细信息[Attribute]；
    • 标识实体之间的关系[Relationship]。

2.三大范式

问题 : 为什么需要数据规范化?

不合规范的表设计会导致的问题：

  • 信息重复

  • 更新异常

  • 插入异常

    • 无法正确表示信息

  • 删除异常

    • 丢失有效信息

三大范式

第一范式 (1NF)

  • 第一范式的目标是确保每列的原子性，如果每列都是不可再分的最小数据单元，则满足第一范式。

第二范式(2NF)

  • 第二范式（2NF）是在第一范式（1NF）的基础上建立起来的，即满足第二范式（2NF）必须先满足第一范式（1NF）。

  • 第二范式要求每个表只描述一件事情。

第三范式(3NF)

  • 如果一个关系满足第二范式,并且除了主键以外的其他列都不传递依赖于主键列,则满足第三范式。

  • 第三范式需要确保数据表中的每一列数据都和主键直接相关，而不能间接相关。

规范化和性能的关系

  • 为满足某种商业目标 , 数据库性能比规范化数据库更重要；
  • 在数据规范化的同时 , 要综合考虑数据库的性能；
  • 通过在给定的表中添加额外的字段,以大量减少需要从中搜索信息所需的时间；
  • 通过在给定的表中插入计算列,以方便查询。

JDBC

1.数据库驱动

这里的驱动的概念和平时听到的那种驱动的概念是一样的，比如平时购买的声卡，网卡直接插到计算机上面是不能用的，必须要安装相应的驱动程序之后才能够使用声卡和网卡，同样道理，我们安装好数据库之后，我们的应用程序也是不能直接使用数据库的，必须要通过相应的数据库驱动程序，通过驱动程 序去和数据库打交道，如下所示：

在这里插入图片描述

2.JDBC介绍

SUN公司为了简化、统一对数据库的操作，定义了一套Java操作数据库的规范（接口），称之为JDBC。 这套接口由数据库厂商去实现，这样，开发人员只需要学习jdbc接口，并通过jdbc加载具体的驱动，就 可以操作数据库。

  • 如下图所示：

在这里插入图片描述

  • JDBC全称为：Java Data Base Connectivity（java数据库连接），它主要由接口组成。
  • 组成JDBC的２个包：java.sql、javax.sql
  • 开发JDBC应用需要以上2个包的支持外，还需要导入相应JDBC的数据库实现(即数据库驱动包—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,'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');

编写程序从user表中读取数据，并打印在命令行窗口中。

package com.hh.jdbc.Demo1;

import java.sql.*;

// 第一个jdbc程序
public class jdbcDemo1 {

    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.getInt("id"));
            System.out.println("name="+ resultSet.getString("Name"));
            System.out.println("pwd="+ resultSet.getObject("PASSWORD"));
            System.out.println("email="+ resultSet.getObject("email"));
            System.out.println("bir="+ resultSet.getObject("birthday"));
            System.out.println("=====================================");
        }

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


    }

}

步骤总结：

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

4.使用jdbc对数据库进行增删改查

  1. 新建一个 lesson02 的包；
  2. 在src目录下创建一个db.properties文件，写入如下内容：
driver = com.mysql.jdbc.Driver
url = jdbc:mysql://localhost:3306/jdbcstudy?uesUnicode=true&characterEncoding=utf8&useSSL=true
username=root
password=123456
  1. 在lesson02 下新建一个 utils 包，新建一个类 Utils：
package com.hh.jdbc.Demo2.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 e) {
            throw new RuntimeException(e);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }


    }

    // 获取连接
    public  static Connection getConnection() throws SQLException {

        return DriverManager.getConnection(url,username,password);
    }

    // 释放资源
    public static  void release(Connection conn, Statement st, ResultSet re){

        if(re!=null)
        {
            try {
                re.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if(st!=null)
        {
            try {
                st.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (conn!=null)
        {
            try {
                conn.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }


    }

}

这是一个工具类，首先是读配置，即db.properties里的用户名等内容。然后写了两个方法，一个是创建连接，一个是释放资源。

  1. 执行增删改查数据
package com.hh.jdbc.Demo2;

import com.hh.jdbc.Demo2.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 re = null;

        try {
             conn = jdbcUtils.getConnection();
             st = conn.createStatement();
             String sql = "INSERT INTO users(id,`NAME`,PASSWORD,email,birthday)" +
                     "VALUES (4,'zhangheyuan','123456','1292735408@qq.com','2001-02-26')";
            int i =  st.executeUpdate(sql);
            if(i>0)
            {
                System.out.println("插入成功!");
            }

        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            jdbcUtils.release(conn,st,re);
        }

    }
}

package com.hh.jdbc.Demo2;

import com.hh.jdbc.Demo2.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 re = null;
                try {
                    conn = jdbcUtils.getConnection();
                    st = conn.createStatement();
                    String sql = "DELETE FROM users WHERE id = 4";
                    int i =  st.executeUpdate(sql);
                    if(i>0)
                    {
                        System.out.println("删除成功!");
                    }

                } catch (SQLException e) {
                    throw new RuntimeException(e);
                }finally {
                    jdbcUtils.release(conn,st,re);
                }

            }
        }

package com.hh.jdbc.Demo2;

import com.hh.jdbc.Demo2.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 re = null;
        try {
            conn = jdbcUtils.getConnection();
            st = conn.createStatement();
            String sql = "UPDATE users SET NAME='小马',email = '123456789@qq.com' WHERE id = 1";
            int i =  st.executeUpdate(sql);
            if(i>0)
            {
                System.out.println("更新成功!");
            }

        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            jdbcUtils.release(conn,st,re);
        }
    }
}

package com.hh.jdbc.Demo2;


import com.hh.jdbc.Demo2.utils.jdbcUtils;

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

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

        try {
            conn = jdbcUtils.getConnection();
            st = conn.createStatement();
            // sql
            String sql = "SELECT * FROM users WHERE id=1";

            re = st.executeQuery(sql);
            while (re.next()){
                System.out.println(re.getString("NAME"));
                System.out.println("======================================");
            }

        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            jdbcUtils.release(conn,st,re);
        }

    }




}

SQL注入

  • 通过巧妙的技巧来拼接字符串，造成SQL短路，从而获取数据库数据
  • SQL存在漏洞，会被攻击。
package com.hh.jdbc.Demo2;

import com.hh.jdbc.Demo2.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("小马","1234567"); //正常登录
        login(" ' or '1=1","123456");
    }



    // 登录业务
    public static  void login(String username,String password)
    {
        Connection conn = null;
        Statement st = null;
        ResultSet re = null;

        try {
            conn = jdbcUtils.getConnection();
            st = conn.createStatement();
            // sql
             // select * from users where name=''or '1=1' and password='123456'
            String sql = "select * from users where name='"+username  +"' and password='"+password+"'";

            re = st.executeQuery(sql);
            while (re.next()){
                System.out.println(re.getString("NAME"));
                System.out.println(re.getString("PASSWORD"));
                System.out.println("======================================");
            }

        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            jdbcUtils.release(conn,st,re);
        }
    }
}

其实就是利用或逻辑使得where子句后面是true，导致所有记录都被查出来。

5.PreparedStatement对象

PreperedStatement是Statement的子类，它的实例对象可以通过调用 Connection.preparedStatement()方法获得，相对于Statement对象而言：PreperedStatement可以避 免SQL注入的问题。

Statement会使数据库频繁编译SQL，可能造成数据库缓冲区溢出。

PreparedStatement可对SQL进行预编译，从而提高数据库的执行效率。并且PreperedStatement对于 sql中的参数，允许使用占位符的形式进行替换，简化sql语句的编写。

使用PreparedStatement对象完成对数据库的CRUD操作

  • 插入数据
package com.hh.jdbc.Demo3;
import com.hh.jdbc.Demo2.utils.jdbcUtils;

import java.sql.Connection;

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.setObject(1,4);
            st.setObject(2,"hahahahahah");
            st.setObject(3,"789");
            st.setObject(4,"asdjasd@163.com");
            // 第一个sql的date 另外一个是java的date new java.util.Date().getTime())是时间戳
            st.setObject(5,new java.sql.Date(new java.util.Date().getTime()));

            // 执行
            int i = st.executeUpdate();
            if(i>0)
            {
                System.out.println("插入成功");
            }


        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            jdbcUtils.release(conn,st,null);
        }
    }


}

package com.hh.jdbc.Demo3;

import com.hh.jdbc.Demo2.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.setObject(1,4);



            // 执行
            int i = st.executeUpdate();
            if(i>0)
            {
                System.out.println("删除成功");
            }


        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            jdbcUtils.release(conn,st,null);
        }
    }
    }

package com.hh.jdbc.Demo3;

import com.hh.jdbc.Demo2.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.setObject(1,"贺泽");
            st.setObject(2,1);



            // 执行
            int i = st.executeUpdate();
            if(i>0)
            {
                System.out.println("更新成功");
            }


        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            jdbcUtils.release(conn,st,null);
        }


    }
}

package com.hh.jdbc.Demo3;
import com.hh.jdbc.Demo2.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=?";
            st =  conn.prepareStatement(sql);
            st.setInt(1,2);
            // 执行
            rs =st.executeQuery();
            while (rs.next())
            {
                System.out.println(rs.getString("NAME"));
            }

        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            jdbcUtils.release(conn,st,rs);
        }


    }
}

避免SQL注入

package com.hh.jdbc.Demo3;

import com.hh.jdbc.Demo2.utils.jdbcUtils;

import java.sql.*;

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

    }

    // 登录业务
    public static  void login(String username,String password)
    {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet re = null;

        try {
            conn = jdbcUtils.getConnection();
            // sql
            // preparedStatement 防止SQL注入的本质：
            // 把传递进来的参数当作字符，假设其中存在转义字符，就直接忽略，比如'会被直接转义
            String sql = "select * from users where NAME=? and PASSWORD = ? ";   // mybatis

            st = conn.prepareStatement(sql);

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

            re = st.executeQuery();

            while (re.next()){
                System.out.println(re.getString("NAME"));
                System.out.println(re.getString("PASSWORD"));
                System.out.println("======================================");
            }

        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            jdbcUtils.release(conn,st,re);
        }
    }

}

原理：执行的时候参数会用引号包起来，并把参数中的引号作为转义字符，从而避免了参数也作为条件 的一部分。

6.JDBC操作事务

  • 事务：逻辑上的一组操作，组成这组操作的各个单元，要不全部成功，要不全部不成功。

  • ACID原则：

    • 原子性(Atomic)：要么全部完成，要么都不完成。
    • 一致性(Consist)：总数不变。
    • 隔离性(Isolated)：多个进程互不干扰。
    • 持久性(Durable)：一旦提交不可逆，持久化到数据库了。

  • 隔离导致的一些问题：

    • 脏读：一个事务读取了另外一个事务未提交的数据。
    • 不可重复读：在一个事务内读取表中的某一行数据，多次读取结果不同。（这个不一定是错误，只是某些场合不对）。
    • 虚读(幻读)：是指在一个事务内读取到了别的事务插入的数据，导致前后读取数量总量不一致。

  • 当Jdbc程序向数据库获得一个Connection对象时，默认情况下这个Connection对象会自动向数据库提交 在它上面发送的SQL语句。若想关闭这种默认提交方式，让多条SQL在一个事务中执行，可使用下列的 JDBC控制事务语句。

package com.hh.jdbc.Demo4;

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

import com.hh.jdbc.Demo2.utils.jdbcUtils;
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 +1000 where `NAME` = 'A'";
            st = conn.prepareStatement(sql1);
            st.executeUpdate();


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

            // 业务完毕，提交事务
            conn.commit();
            System.out.println("成功！");




            
        } catch (SQLException e) {
            try {
                conn.rollback(); // 如果失败就默认回滚
            } catch (SQLException ex) {
                throw new RuntimeException(ex);
            }
            throw new RuntimeException(e);
        }finally {
            jdbcUtils.release(conn,st,rs);
        }


    }

}

这是一个模拟转账事务的程序。

数据库连接池

用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也 较长。假设网站一天10万访问量，数据库服务器就需要创建10万次连接，极大的浪费数据库的资源，并且极易造成数据库服务器内存溢出、拓机。

数据库连接池的基本概念

数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现的尤为突出。对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。数据库连接池正式针对这个问题提出来的。数据库连接池负责分配,管理和释放数据库连接,它允许应用程序重复使用一个现有的 数据库连接,而不是重新建立一个。

数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数 超过最大连接数量时，这些请求将被加入到等待队列中。

数据库连接池的最小连接数和最大连接数的设置要考虑到以下几个因素:

  1. 最小连接数：是连接池一直保持的数据库连接，所以如果应用程序对数据库连接的使用量不大，将会有大量的数据库连接资源被浪费。
  2. 最大连接数：是连接池能申请的最大连接数，如果数据库连接请求超过次数，后面的数据库连接请求将被加入到等待队列中，这会影响以后的数据库操作。
  3. 如果最小连接数与最大连接数相差很大：那么最先连接请求将会获利，之后超过最小连接数量的连接请求等价于建立一个新的数据库连接。不过，这些大于最小连接数的数据库连接在使用完不会马上被释放，他将被放到连接池中等待重复使用或是空间超时后被释放。

编写连接池，需实现java.sql.DataSource接口。

开源数据源实现

现在很多WEB服务器(Weblogic, WebSphere, Tomcat)都提供了DataSoruce的实现，即连接池的实现。 通常我们把DataSource的实现，按其英文含义称之为数据源，数据源中都包含了数据库连接池的实 现。

也有一些开源组织提供了数据源的独立实现：

  • DBCP 数据库连接池
  • C3P0 数据库连接池
  • Druid 数据库连接池 —— 阿里巴巴

在使用了数据库连接池之后，在项目的实际开发中就不需要编写连接数据库的代码了，直接从数据源获得数据库的连接。

DBCP

在src目录下加入dbcp的配置文件：dbcpconfig.properties

#连接设置
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

编写工具类 Utils_DBCP

package com.hh.jdbc.Demo5.utils;

import com.hh.jdbc.Demo2.utils.jdbcUtils;
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.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
            Properties properties = new Properties();
            properties.load(in);

            // 创建数据源
           dataSource = BasicDataSourceFactory.createDataSource(properties);


        } catch (IOException e) {
            throw new RuntimeException(e);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }


    }

    // 获取连接
    public  static Connection getConnection() throws SQLException {

        return dataSource.getConnection();  // 从数据源中获取连接
    }

    // 释放资源
    public static  void release(Connection conn, Statement st, ResultSet re){

        if(re!=null)
        {
            try {
                re.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if(st!=null)
        {
            try {
                st.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (conn!=null)
        {
            try {
                conn.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }


    }
}

测试

package com.hh.jdbc.Demo5;

import com.hh.jdbc.Demo2.utils.jdbcUtils;
import com.hh.jdbc.Demo5.utils.jdbcUtils_DBCP;

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

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

        Connection conn =  null;
        PreparedStatement st = null;


        try {
            conn = jdbcUtils_DBCP.getConnection();
            String sql = "insert into users(id,NAME,PASSWORD,email,birthday) values(?,?,?,?,?) ";
            // 区别
            // 使用？占位符代替参数
            st = conn.prepareStatement(sql); //预编译SQL，先写sql，然后不执行

            // 手动给参数赋值
            st.setObject(1,4);
            st.setObject(2,"hahahahahah");
            st.setObject(3,"789");
            st.setObject(4,"asdjasd@163.com");
            // 第一个sql的date 另外一个是java的date new java.util.Date().getTime())是时间戳
            st.setObject(5,new java.sql.Date(new java.util.Date().getTime()));

            // 执行
            int i = st.executeUpdate();
            if(i>0)
            {
                System.out.println("插入成功");
            }


        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            jdbcUtils.release(conn,st,null);
        }
    }
    }

这和之前Demo3中的插入一样的，只不过换了工具类，改了一下数据源。

C3P0

  • C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。

  • c3p0与dbcp区别：

    • dbcp没有自动回收空闲连接的功能；
    • c3p0有自动回收空闲连接功能。

  • 要使用C3P0数据源，需要导入如下两个 jar 文件：

  • 在src目录下加入C3P0的配置文件：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>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcStudy? useUnicode=true&amp;characterEncoding=utf8&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>
    </default-config>
    <!--
    C3P0的命名配置，
    如果在代码中“ComboPooledDataSource ds = new
    ComboPooledDataSource("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;characterEncoding=utf8&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>

编写工具类 Utils_C3P0.java

package com.hh.jdbc.Demo5.utils;

import com.hh.jdbc.Demo2.utils.jdbcUtils;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
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();



            // 创建数据源
            dataSource = new ComboPooledDataSource("MySQL");   // 配置文件写法


        }
         catch (Exception e) {
            throw new RuntimeException(e);
        }


    }

    // 获取连接
    public  static Connection getConnection() throws SQLException {

        return dataSource.getConnection();  // 从数据源中获取连接
    }

    // 释放资源
    public static  void release(Connection conn, Statement st, ResultSet re){

        if(re!=null)
        {
            try {
                re.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if(st!=null)
        {
            try {
                st.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (conn!=null)
        {
            try {
                conn.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }


    }
}

测试

package com.hh.jdbc.Demo5;

import com.hh.jdbc.Demo2.utils.jdbcUtils;
import com.hh.jdbc.Demo5.utils.jdbcUtils_C3P0;


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

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


        try {
            conn = jdbcUtils_C3P0.getConnection();
            String sql = "insert into users(id,NAME,PASSWORD,email,birthday) values(?,?,?,?,?) ";
            // 区别
            // 使用？占位符代替参数
            st = conn.prepareStatement(sql); //预编译SQL，先写sql，然后不执行

            // 手动给参数赋值
            st.setObject(1,5);
            st.setObject(2,"hahahahahah");
            st.setObject(3,"789");
            st.setObject(4,"asdjasd@163.com");
            // 第一个sql的date 另外一个是java的date new java.util.Date().getTime())是时间戳
            st.setObject(5,new java.sql.Date(new java.util.Date().getTime()));

            // 执行
            int i = st.executeUpdate();
            if(i>0)
            {
                System.out.println("插入成功");
            }


        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            jdbcUtils_C3P0.release(conn,st,null);
        }
    }
    }

无论使用什么数据源，本质都是一样的！！！

MySQL快速入门完结🎉🎉🎉🎉

JDBC详解学习文档
流楚丶格念的博客
06-11 3253
文章目录1. JDBC 入门1.1 客户端操作 MySQL 数据库的方式：1.1.1什么是 JDBC使用 JDBC 的好处：1.1.2 使用 JDBC 开发使用到的包：1.2 JDBC 的核心 API1.3导入驱动 Jar 包1.4加载和注册驱动com.mysql.jdbc.Driver 源代码：2. DriverManager 类2.1DriverManager 作用：2.2类中的方法：2.3 使用 JDBC 连接数据库的四个参数：2.4 连接数据库的 URL 地址格式：2.4.1MySQL 写法：2.4
JDBC详解
限定私语的博客
05-27 4190
JDBC目录1. JDBC 入门1.1 客户端操作 MySQL 数据库的方式：什么是JDBC使用 JDBC 开发使用到的包：1.2 JDBC 的核心 API1.3 加载和注册驱动2. DriverManager 类2.1 DriverManager 作用：2.2 类中的方法：2.3 使用JDBC连接数据库的四个参数：2.4 连接数据库的 URL 地址格式：MySQL 写法：MySQL 中可以简写：乱码的处理2.5 得到 MySQL 的数据库连接对象3. Connection 接口：3.1 Connectio
JDBC概述——API详解、数据库连接池Driud使用、利用JDBC进行CRUD
coderge's CSDN Blog.
03-06 342
在开发中我们使用的是java语言，那么势必要通过java语言操作数据库中的数据。这就是接下来要学习的JDBC。Statement对象的作用就是用来执行SQL语句。而针对不同类型的SQL语句使用的方法也不一样。执行DDL、DML语句执行DQL语句该方法涉及到了ResultSet对象，而这个对象我们还没有学习，一会再重点讲解。封装了SQL查询语句的结果。ResultSet executeQuery(sql) ：执行DQL 语句，返回 ResultSet 对象那么我们就需要从ResultSet。
（jdbc、数据库连接池和数据库底层原理）day36javaEE基础查漏补缺
休哥哥的博客
01-10 852
jdbc和数据库连接池1.客户端和服务器端来回传输数据，用的都是Statement对象嘛？？？2.直接创建数据库驱动driver，占用内存空间3.工作中如何写sql代码：4.什么是上下文？5.接口由组长编写么？6.jdbc简介：7.研究一下数据库索引和慢查询等问题？？？8.防止sql注入的方式：9.数据库的行和列索引是从几开始的？？？10.如何开启mysql数据库日志？11.释放资源顺序：一般先开的后关12.释放资源不要放在一个try...catch里：13.有没有释放资源的工具类，或者注解啥的14.回滚出
MySQL数据库——JDBC、JDBC连接池&JDBCTemplate
your_棒棒糖的博客
08-01 527
JDBC目录JDBC目录JDBC：1. 概念：2. 快速入门：3. 详解各个对象：1. DriverManager：驱动管理对象2. Connection：数据库连接对象3. Statement：执行sql的对象4. ResultSet：结果集对象,封装查询结果5. PreparedStatement：执行sql的对象抽取JDBC工具类 ： JDBCUtilsJDBC控制事务： JDBC目录 1. JDBC基本概念 2. 快速入门 3. 对JDBC中各个接口和类详解 JDBC： 1. 概念： Java D
JDBC学习笔记03【JDBC事务管理、数据库连接池、JDBCTemplate】
upward
02-06 779
JDBC事务管理、数据库连接池、JDBCTemplate
MySQL数据库复习_day04_Jdbc&数据库连接池
weixin_42931689的博客
02-20 391
Jdbc 一. 概念 Java DataBase Connectivity Java 数据库连接， Java语言操作数据库 其实是官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类。 二. 步骤 导入驱动jar包 mysql-connector-j...
JDBC教程：JDBC连接Mysql数据库超详细讲解（从入门到熟练使用）
热门推荐
kkkyyy0817的博客
02-04 4万+
带你快速入门掌握！包括导包步骤以及功能类详解、增删改查(CRUD)、sql注入、事务、连接池...
JDBC及数据库连接池
abcgkj的博客
03-01 266
本文主要讲解JDBC的快速入门、对JDBC中各个接口和类进行详解、如何自定义JDBC工具类、JDBC如何控制事务、数据库连接池（C3P0、Druid）和Spring JDBC （JDBC Template）的基本操作。
数据库连接池原理（一）
xzp_12345的博客
09-21 745
一、什么是数据库连接池？ 官方：数据库连接池（Connection pooling）是程序启动时建立足够的数据库连接，并将这些连接组成一个连接池，由程序动态地对池中的连接进行申请，使用，释放。 个人理解：创建数据库连接是一个很耗时的操作，也容易对数据库造成安全隐患。所以，在程序初始化的时候，集中创建多个数据库连接，并把他们集中管理，供程序使用，可以保证较快的数据库读写速度，还更加安全可
Java数据库开发与应用之MySQL数据库、JDBC操作数据库、C3P0数据库连接池，Java反射等
qq_38326107的博客
11-29 1417
第三节学习MySQL数据库，JDBC接口，MyBatis框架等，掌握的数据的存放和管理。 Java数据库开发基础，介绍MySQL数据库、JDBC操作数据库、C3P0数据库连接池，Java反射等内容，进行油画商城开发。 3.1.1 MySQL基础之数据类型 MySQL数据库的安装、数据类型。 MySQL数据库内容分两部分介绍： MySQL安装：www.mysql.com。 MySQL属于关系型数据库，MySQL是按照数据结构来组织、存储和管理数据的仓库。 ALTER USER ‘root’@‘loc
JAVA WEB学习课件及代码详解第二部分
07-07
JAVA的J2EE WEB学习资料，其中包括了学习视频、讲义、笔记、以及练习代码等，适合刚接触JAVA同时需要搭建WEB平台的同学使用。...2、day06_JDBC连接池&JDBCTemplate 3、day07_HTML 4、day08_HTML&CSS
掌握结构化数据库编码技巧：以MySQL为例详解
标题“day14_结构化数据库代码_以mysql为例_包含db.properties,JdbcUtils.java等”涉及的知识点可以分为以下几部分： 1. 数据库的结构化：结构化数据库指的是数据以特定格式存储的数据库系统，常见的结构化数据库...
JavaEE开发笔记：数据库技术要点详解
- 数据库连接池的使用和配置。 - 数据库事务的概念以及在Java中的控制方式。 - 数据库连接的管理和异常处理。 - 面向对象数据库访问的思考与实践。 2. **2015081000_开课概述.doc** 本文件很可能是对整个...
JavaWeb：MySQL进阶
IT瘾君子的博客
05-07 632
JavaWeb、MySQL进阶、事务、所以，子查询，外连接，内连接
【SQLSERVER】Ubuntu 连接远程 SQL Server（MSSQL）
linjiuxiansheng的博客
05-08 404
在 Ubuntu 上连接 SQL Server 使用 sqlcmd 是最简单高效的方法。本文详细介绍了如何配置和连接，同时解决了常见问题。希望本文对你的跨平台数据库连接有所帮助。
centos 7 安装 java 运行环境
最新发布
abc
05-09 167
centos 7 安装 java 运行环境。
Mysql数据库操作
Lemon__ing的博客
05-09 783
经过初始化后的MySQL服务器，会自动创建四个数据库，分别为：sysmysql和。
[数据库之十一] 数据库索引之联合索引
rita_0567的博客
05-08 688
执行数据库查询时，通常查询条件是多对个属性进行判断和约束，对于这种类型的查询，如果存在多个索引则使用多个索引，或者使用建立在多属性搜索码上的索引，这样能提高查询效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值