JAVA基础程序——JDBC

一、JDBC1.1、概述JDBC就是使用JAVA语言操作关系型数据库的一套API1.2、JDBC本质官方定义的一套操作所有关系型数据库的规则，即接口各个数据库厂商去实现这套接口，提供数据库驱动jar包通过使用这套接口来编程，真正执行的代码时驱动jar包中的实现类1.3、JDBC的好处各个数据库厂商使用同样的接口,JAVA代码不需要针对不同的数据库分别开发可随时替换底层数据库，访问数据库的JAVA代

柿子镭

1185人浏览 · 2022-05-13 16:59:46

柿子镭 · 2022-05-13 16:59:46 发布

2.5、处理结果集（执行insert、update、delete无需处理）

2.6、释放资源

三、SQL注入问题

四、预处理对象

五、预处理对象executeUpdate方法

5.1、插入记录：insert

5.2、更新记录：update

5.3、删除记录：delete

六、预处理对象executeQuery方法

8.3、加载配置文件：Properties对象

9.3 QueryRunner实现添加、更新、删除操作

9.4 QueryRunner实现查询操作

十、连接池

10.1、连接池概述

10.2、DBCP连接池

一、JDBC

1.1、概述

JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。是 Java访问数据库的标准规范。
JDBC提供了一种基准,据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序。
JDBC需要连接驱动，驱动是两个设备要进行通信，满足一定通信数据格式，数据格式由设备提供商规定，设备提供商为设备提供驱动软件，通过软件可以与该设备进行通信。

1.2、JDBC原理

Java提供访问数据库规范称为JDBC，而生产厂商提供规范的实现类称为驱动。

JDBC是接口，驱动是接口的实现，没有驱动将无法完成数据库连接，从而不能操作数据库！每个数据库厂商都需要提供自己的驱动，用来连接自己公司的数据库，也就是说驱动一般都由数据库生成厂商提供。

1.3、JDBC的好处

各个数据库厂商使用同样的接口,JAVA代码不需要针对不同的数据库分别开发
可随时替换底层数据库，访问数据库的JAVA代码基本不变

二、JDBC快速入门

JAVA操作数据库的流程：

编写JAVA代码
JAVA代码将SQL发送到MySQL服务端
MySQL服务端接收到SQL语句并执行该SQL语句
将SQL语句执行的结果返回给JAVA代码

JDBC开发步骤

注册驱动
获得连接
获得语句执行平台
执行SQL语句
处理结果
释放资源

2.1、导入驱动包

2.2、注册驱动

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

JDBC规范定义驱动接口：java.sql.Driver，MySql驱动包提供了实现类： com.mysql.jdbc.Driver
DriverManager工具类，提供注册驱动的方法 registerDriver()，方法的参数是 java.sql.Driver，所以我们可以通过如下语句进行注册

DriverManager.registerDriver(new com.mysql.jdbc.Driver());

以上代码不推荐使用，存在两方面不足：

硬编码，后期不易于程序扩展和维护
驱动被注册两次

通常开发我们使用Class.forName() 加载一个使用字符串描述的驱动类。
如果使用Class.forName()将类加载到内存，该类的静态代码将自动执行。
通过查询com.mysql.jdbc.Driver源码，我们发现Driver类“主动”将自己进行注册。

public class JDBCDemo {
    public static void main(String[] args) throws Exception {
        //注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        String url = "jdbc:mysql://127.0.0.1:3306/javatest";
        String username = "root";
        String password = "123456";
        //获取连接
        Connection conn = DriverManager.getConnection(url, username, password);
        String sql = "update tb_user set name='小镭' where id = 1";
        // 获取执行SQL对象
        Statement statement = conn.createStatement();
        // 执行SQL
        int count = statement.executeUpdate(sql);
        // 处理结果
        System.out.println(count);
        // 释放资源
        statement.close();
        conn.close();
    }
}

2.3、获得连接

        String url = "jdbc:mysql://127.0.0.1:3306/javatest?useSSL=false";
        String username = "root";
        String password = "123456";
        Connection conn = DriverManager.getConnection(url, username, password);

获取连接需要方法 DriverManager.getConnection(url,username,password)，三个参数分别表示：

url 需要连接数据库的位置（网址）
user用户名
password 密码

JDBC规定url的格式由三部分组成，每个部分中间使用冒号分隔。

第一部分是jdbc，这是固定的；
第二部分是数据库名称，连接的是mysql数据库
第三部分是由数据库厂商规定的，mysql的第三部分分别由数据库服务器的IP地址（localhost）、端口号（3306），以及DATABASE名称(mydb)组成。

2.4、获得语句执行平台

String sql = "update tb_user set name='小镭' where id = 1";
// 获取执行SQL对象
Statement statement = conn.createStatement();

常用方法：

int executeUpdate(String sql); --执行insert update delete语句。
ResultSet executeQuery(String sql); --执行select语句。
boolean execute(String sql); --执行select返回true 执行其他的语句返回false。

2.5、处理结果集（执行insert、update、delete无需处理）

ResultSet（结果集对象）作用：封装了SQL查询语句的结果

从ResultSet对象中获取数据，ResultSet对象提供了操作结果数据的方法

boolean next(); 将光标从当前位置向前移动一行，判断当前行是否为有效行
xxx getXXX(参数) 获取数据

xxx表示数据类型：int getInt(参数) string getString(参数)

参数：

int 类型的参数列的编号，1
string 类型的参数列的名称

常用方法：

Object getObject(int index) / Object getObject(String name) 获得任意对象
String getString(int index) / Object getObject(String name) 获得字符串
int getInt(int index) / Object getObject(String name) 获得整形
double getDouble(int index) / Object getObject(String name) 获得双精度浮点型

public static void testDQL() throws Exception {
    Class.forName("com.mysql.cj.jdbc.Driver");
    String url = "jdbc:mysql://127.0.0.1:3306/javatest?useSSL=false";
    String username = "root";
    String password = "123456";
    Connection conn = DriverManager.getConnection(url, username, password);
    String sql1 = "select * from tb_user";
    Statement statement = conn.createStatement();
    conn.setAutoCommit(false);
    ResultSet resultSet = statement.executeQuery(sql1);// 返回受影响的行数

    ArrayList<Account> list1 = new ArrayList<>();
    while (resultSet.next()){
        int id = resultSet.getInt(1);
        String name = resultSet.getString(2);
        double money = resultSet.getDouble(3);
        Account account = new Account(id,name,money);
        list1.add(account);
    }
    System.out.println(list1);
    resultSet.close();
    statement.close();
    conn.close();
}

2.6、释放资源

与IO流一样，使用后的东西都需要关闭！关闭的顺序是先得到的后关闭，后得到的先关闭。

        resultSet.close();
        statement.close();
        conn.close();

三、SQL注入问题

假设有登录案例SQL语句如下：

SELECT * FROM 用户表 WHERE NAME = 用户输入的用户名 AND PASSWORD = 用户
输的密码;

此时，当用户输入正确的账号与密码后，查询到了信息则让用户登录。但是当用户输入的账号为XXX 密码为：XXX’ OR ‘a’=’a时，则真正执行的代码变为：

SELECT * FROM 用户表 WHERE NAME = 'XXX' AND PASSWORD ='XXX' OR
'a'='a';

此时，上述查询语句时永远可以查询出结果的。那么用户就直接登录成功了，显然我们不希望看到这样的结果，这便是SQL注入问题。

四、预处理对象

使用PreparedStatement预处理对象时，建议每条sql语句所有的实际参数，都使用逗号分隔。

String sql = "insert into sort(id, name) values(?, ?)";;
PreparedStatement预处理对象代码：
PreparedStatement psmt = conn.prepareStatement(sql)

常用方法：

（1）执行SQL语句：

int executeUpdate(); --执行insert update delete语句。
ResultSet executeQuery(); --执行select语句。
boolean execute(); --执行select返回true 执行其他的语句返回false。

（2）设置实际参数：

void setXxx(int index, Xxx xx) 将指定参数设置为给定Java的xx值。在将此值发送到数据库时，驱动程序将它转换成一个 SQL Xxx类型值。

        PreparedStatement statement = conn.prepareStatement(sql1);
        statement.setString(1,name);
        statement.setString(2,pwd);
        ResultSet resultSet = statement.executeQuery(sql1);

五、预处理对象executeUpdate方法

通过预处理对象的executeUpdate方法，完成记录的insert\update\delete语句的执行。操作格式统一如下：

注册驱动
获取连接
获取预处理对象
SQL语句占位符设置实际参数
执行SQL语句
释放资源

5.1、插入记录：insert

实现向分类表中插入指定的新分类

    public void demo01() throws Exception {
        // 1注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 2获取连接
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306//mydb", "root", "root");
        // 3获得预处理对象
        String sql = "insert into category(name) values(?)";
        PreparedStatement stat = conn.prepareStatement(sql);
        // 4 SQL语句占位符设置实际参数
        stat.setString(1, "奢侈品");
        // 5执行SQL语句
        int line = stat.executeUpdate();
        System.out.println("新添加记录数：" + line);
        // 6释放资源
        stat.close();
        conn.close();
    }

5.2、更新记录：update

实现更新分类表中指定分类ID所对应记录的分类名称

    public void demo02() throws Exception {
        // 1注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 2获取连接
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306//mydb", "root", "root");
        // 3获得预处理对象中
        String sql = "update sort set name=? where id=?";
        PreparedStatement stat = conn.prepareStatement(sql);
        // 4 SQL语句占位符设置实际参数
        stat.setString(1, "数码产品");
        stat.setInt(2, 1);
        // 5执行SQL语句
        int line = stat.executeUpdate();
        System.out.println("更新记录数：" + line);
        // 6释放资源
        stat.close();
        conn.close();
    }

5.3、删除记录：delete

实现删除分类表中指定分类ID的记录

    public void demo03() throws Exception {
        // 1注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 2获取连接
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306//mydb", "root", "root");
        // 3获得预处理对象中
        String sql = "delete from category where id=?";
        PreparedStatement stat = conn.prepareStatement(sql);
        // 4 SQL语句占位符设置实际参数
        stat.setInt(1, 1);
        // 5执行SQL语句
        int line = stat.executeUpdate();
        System.out.println("删除记录数：" + line);
        // 6释放资源
        stat.close();
        conn.close();
    }

六、预处理对象executeQuery方法

通过预处理对象的executeQuery方法，完成记录的select语句的执行。操作格式统一如下：

注册驱动
获取连接
获取预处理对象
SQL语句占位符设置实际参数
执行SQL语句
处理结果集(遍历结果集合)
释放资源

6.1、查询记录：select

实现查询分类表所有记录

    public void demo04() throws Exception {
        // 1注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 2获取连接
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306//mydb", "root", "root");
        // 3获得预处理对象中
        String sql = "select * from category";
        PreparedStatement stat = conn.prepareStatement(sql);
        // 4 SQL语句占位符设置实际参数
        // 5执行SQL语句
        ResultSet rs = stat.executeQuery();
        // 6处理结果集(遍历结果集合)
        while( rs.next() ){
            //获取当前行的分类ID
            String id = rs.getString("id");//方法参数为数据库表中的列名
            // 获取当前行的分类名称
            String name = rs.getString("name");
            //显示数据
            System.out.println(id+"-----"+name);
        }
        // 7释放资源
        rs.close();
        stat.close();
        conn.close();
    }

实现查询分类表中指定分类名称的记录

 public void demo05() throws Exception {
        // 1注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 2获取连接
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306//mydb", "root", "root");
        // 3获得预处理对象
        String sql = "select * from category where name=?";
        PreparedStatement stat = conn.prepareStatement(sql);
        // 4 SQL语句占位符设置实际参数
        stat.setString(1, "奢侈品");
        // 5执行SQL语句
        ResultSet rs = stat.executeQuery();
        // 6处理结果集(遍历结果集合)
        while( rs.next() ){
            //获取当前行的分类ID
            String id = rs.getString("id");//方法参数为数据库表中的列名
            //获取当前行的分类名称
            String name = rs.getString("name");
            //显示数据
            System.out.println(id+"-----"+name);
        }
        // 7释放资源
        rs.close();
        stat.close();
        conn.close();
    }

七、JDBC工具类

“获得数据库连接”操作，将在以后的增删改查所有功能中都存在，可以封装工具类 JDBCUtils。提供获取连接对象的方法，从而达到代码的重复利用。

该工具类提供方法：public static Connection getConn ()。代码如下：

    /*
     * JDBC工具类
     */
    public class JDBCUtils {
        public static final String DRIVERNAME = "com.mysql.jdbc.Driver";
        public static final String URL = "jdbc:mysql://localhost:3306/mydb";
        public static final String USER = "root";
        public static final String PASSWORD = "root";
        static {
            try {
                Class.forName(DRIVERNAME);
            } catch (ClassNotFoundException e) {
                System.out.println("数据库驱动注册失败！");
            }
        }
        //提供获取连接的方法
        public static Connection getConn() throws Exception {
            // 2. 获得连接
            Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);
            // 返回连接
            return conn;
        }
    }

八、properties配置文件

8.1、使用properties配置文件

开发中获得连接的4个参数（驱动、URL、用户名、密码）通常都存在配置文件中，方便后期维护，程序如果需要更换数据库，只需要修改配置文件即可。

通常情况下，我们习惯使用properties文件，此文件我们将做如下要求：

文件位置：任意，建议src下。
文件名称：任意，扩展名为properties。
文件内容：一行一组数据，格式是“key=value”。

key命名自定义，如果是多个单词，习惯使用点分隔。例如： jdbc.driver。
value值不支持中文，如果需要使用非英文字符，将进行unicode转换。

8.2、创建配置文件

在项目跟目录下，创建文件，输入“db.properties”文件名。

文件中的内容

driver=com.mysql.jdbc.Driver

url=jdbc:mysql://localhost:3306/mydb

user=root

password=root

8.3、加载配置文件：Properties对象

对应properties文件处理，开发中也使用Properties对象进行。我们将采用加载 properties文件获得流，然后使用Properties对象进行处理。

JDBCUtils.java中编写代码

public class JDBCUtils {
    private static String driver;
    private static String url;
    private static String user;
    private static String password;

    // 静态代码块
    static{
        try {
            // 1 使用Properties处理流
            // 使用load()方法加载指定的流
            Properties properties =  new Properties();
            FileReader fileReader = new FileReader("db.properties");
            properties.load(fileReader);
            // 2 使用getProperty(key)，通过key获得需要的值
            String driver = properties.getProperty("driver");
            String url = properties.getProperty("url");
            String password = properties.getProperty("password");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     *
     * 获得连接
     */
    public static Connection getConnection() {
        try {
            Class.forName(driver);
            Connection connection = DriverManager.getConnection(url, user, password);
            return  connection;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

8.4、使用JDBCUtils工具类

测试类

public class Demo {
@Test
public void insert(){
try{
//1,获取连接对象
Connection conn = JDBCUtils.getConnection();
//2,指定要执行的SQL语句
String sql = "INSERT INTO zhangwu(name,money,parent)
VALUES(?,?,?)";
//4，获取SQL语句的执行对象 PreparedStatement
PreparedStatement ppstat =
conn.prepareStatement(sql);
//5,执行SQL语句
ppstat.setString(1, "股票收入");
ppstat.setDouble(2, 5000);
ppstat.setString(3, "收入");
int line = ppstat.executeUpdate();
//6,处理结果集
System.out.println("line=" + line);
//7,关闭连接
ppstat.close();
conn.close();
} catch(SQLException e){
throw new RuntimeException(e);
}
}
}

九、DBUtils

DBUtils就是JDBC的简化开发工具包。需要项目导入jar包才能够正常使用DBUtils工具。

9.1、概述

DBUtils是java编程中的数据库操作实用工具，小巧简单实用。
DBUtils封装了对JDBC的操作，简化了JDBC操作，可以少写代码。

Dbutils三个核心功能介绍：

QueryRunner中提供对sql语句操作的API
ResultSetHandler接口，用于定义select操作后，怎样封装结果集
DbUtils类，它就是一个工具类,定义了关闭资源与事务处理的方法

9.2 QueryRunner核心类

update(Connection conn, String sql, Object... params) ，用来完成表数据的增加、删除、更新操作
query(Connection conn, String sql, ResultSetHandler rsh, Object... params) ，用来完成表数据的查询操作

9.3 QueryRunner实现添加、更新、删除操作

（1）添加

    @Test
    public void insert(){
        QueryRunner queryRunner = new QueryRunner();
        String sql = "INSERT INTO tb_account(name,money)VALUES(?,?)";
        Object[] params = {"小黑",1};
        Connection connection = JDBCUtils.getConnection();
        try {
            int update = queryRunner.update(connection, sql, params);
            System.out.println("line = " + update);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

（2）更新

    @Test
    public void update() throws SQLException {
        QueryRunner queryRunner = new QueryRunner();
        String sql = "UPDATE tb_account SET money = money-1 WHERE name=?";
        Object[] params = {"小黑"};
        Connection connection = JDBCUtils.getConnection();
        int update = queryRunner.update(connection, sql, params);
        System.out.println("更新"+update+"条记录");
    }

（3）删除

    @Test
    public void delete() throws SQLException {
        QueryRunner queryRunner = new QueryRunner();
        String sql = "DELETE FROM tb_account WHERE name=?";
        Object[] params = {"小黑"};
        Connection connection = JDBCUtils.getConnection();
        int update = queryRunner.update(connection, sql, params);
        System.out.println("删除"+update+"条记录");
    }

9.4 QueryRunner实现查询操作

query(Connection conn, String sql, ResultSetHandler rsh, Object... params) ，用来完成表数据的查询操作

（1）ResultSetHandler结果集处理类

（2）JavaBean

JavaBean就是一个类，在开发中常用封装数据。具有如下特性：

需要实现接口：java.io.Serializable ，通常实现接口这步骤省略了，不会影响程序。
提供私有字段：private 类型字段名;
提供getter/setter方法。
提供无参构造


public class Account {
    private int id;
    private String name;
    private double money;

    public Account() {
    }

    public Account(int id, String name, double money) {
        this.id = id;
        this.name = name;
        this.money = money;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

（3）ArrayHandler与ArrayListHandler查询

ArrayHandler：将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值。

    @Test
    public void ArrayHandler() throws SQLException {
        QueryRunner queryRunner = new QueryRunner();
        String sql = "SELECT * FROM tb_account";
        Object[] params = {};
        Connection connection = JDBCUtils.getConnection();
        Object[] query = queryRunner.query(connection, sql, new ArrayHandler(), params);
        System.out.println(Arrays.toString(query));
        connection.close();
    }

ArrayListHandler：将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。

    @Test
    public void ArrayListHandler() throws SQLException {
        QueryRunner queryRunner = new QueryRunner();
        String sql = "SELECT * FROM tb_account WHERE money>?";
        Object[] parmas = {200};
        Connection connection = JDBCUtils.getConnection();
        List<Object[]> lists = queryRunner.query(connection, sql, new ArrayListHandler(), parmas);
        for(Object[] o: lists){
            System.out.println(Arrays.toString(o));
        }
        connection.close();
    }

（4）BeanHandler与BeanListHandler查询

BeanHandler ：将结果集中第一条记录封装到一个指定的javaBean中。

    @Test
    public void BeanHandler() throws SQLException {
        QueryRunner queryRunner = new QueryRunner();
        String sql = "SELECT * FROM tb_account WHERE id=?";
        Object[] parmas = {1};
        Connection connection = JDBCUtils.getConnection();
        Account query = queryRunner.query(connection, sql, new BeanHandler<Account>(Account.class), parmas);
        System.out.println(query);
        connection.close();
    }

BeanListHandler ：将结果集中每一条记录封装到指定的javaBean中，将这些 javaBean在封装到List集合中。

    @Test
    public void BeanListHandler() throws SQLException {
        QueryRunner queryRunner = new QueryRunner();
        String sql = "SELECT * FROM tb_account WHERE money>?";
        Object[] parmas = {200};
        Connection connection = JDBCUtils.getConnection();
        List<Account> query = queryRunner.query(connection, sql, new BeanListHandler<Account>(Account.class), parmas);
        for(Account a : query){
            System.out.println(a);
        }
    }

（5） ColumnListHandler与ScalarHandler查询

ColumnListHandler：将结果集中指定的列的字段值，封装到一个List集合中。

    @Test
    public void ColumnListHandler() throws SQLException {
        QueryRunner queryRunner = new QueryRunner();
        String sql = "SELECT name FROM tb_account WHERE money>?";
        Object[] parmas = {200};
        Connection connection = JDBCUtils.getConnection();
        List<Object> query = queryRunner.query(connection, sql, new ColumnListHandler(), parmas);
        for (Object str : query) {
            System.out.println(str);
        }
    }

ScalarHandler：它是用于单数据。例如select count(*) from 表操作。

    @Test
    public void ScalarHandler() throws SQLException {
        QueryRunner queryRunner = new QueryRunner();
        String sql = "SELECT MAX(money) FROM tb_account ";
        Object[] parmas = {};
        Connection connection = JDBCUtils.getConnection();
        Object query = queryRunner.query(connection, sql, new ScalarHandler(), parmas);
        System.out.println(query);
    }

十、连接池

10.1、连接池概述

概念

用池来管理Connection，这样可以重复使用Connection。有了池，所以我们就不用自己来创建Connection，而是通过池来获取Connection对象。当使用完 Connection后，调用Connection的close()方法也不会真的关闭Connection，而是把Connection“归还”给池。池就可以再利用这个Connection对象了。

规范

Java为数据库连接池提供了公共的接口：javax.sql.DataSource，各个厂商需要让自己的连接池实现这个接口。这样应用程序可以方便的切换不同厂商的连接池！常见的连接池：DBCP、C3P0。

10.2、DBCP连接池

DBCP也是一个开源的连接池，是Apache Common成员之一，在企业开发中也比较常见， tomcat内置的连接池。

（1）导入jar包

需要导入的包：commons-dbcp2-2.9.0.jar、commons-pool2-2.11.1.jar 参考前面的导包步骤。 （2）编写工具类

连接数据库表的工具类, 采用DBCP连接池的方式来完成，Java中提供了一个连接池的规则接口：DataSource : 它是java中提供的连接池，作为 DriverManager 工具的替代项。在 DBCP包中提供了DataSource接口的实现类，我们要用的具体的连接池 BasicDataSource类

public class JDBCUtils {
public static final String DRIVER = "com.mysql.jdbc.Driver";public static final String URL =
"jdbc:mysql://localhost:3306/mydb";
public static final String USERNAME = "root";
public static final String PASSWORD = "root";
/*
* 创建连接池BasicDataSource
*/
public static BasicDataSource dataSource = new
BasicDataSource();
//静态代码块
static {
//对连接池对象 进行基本的配置
dataSource.setDriverClassName(DRIVER); // 这是要连接的数据
库的驱动
dataSource.setUrl(URL); //指定要连接的数据库地址
dataSource.setUsername(USERNAME); //指定要连接数据的用户名
dataSource.setPassword(PASSWORD); //指定要连接数据的密码
}
/*
* 返回连接池对象
*/
public static DataSource getDataSource(){
return dataSource;
}
}

（3）工具类的使用

/*
* 演示使用DBUtils工具 完成数据库表的增加操作
*/
public class Demo {
// 插入功能
@Test
public void insert(){
try {
//获取一个用来执行SQL语句的对象 QueryRunner
QueryRunner qr = new
QueryRunner(JDBCUtils.getDataSource());
String sql = "INSERT INTO zhangwu(name,money,parent)
VALUES(?,?,?)";
Object[] params = {"股票收入", 5500, "收入"};
int line = qr.update(sql,params);
//结果集处理
System.out.println("line = " + line);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
//删除功能
@Test
public void delete(){
try {
//创建一个QueryRunner对象，用来完成SQL语句的执行
QueryRunner qr = new
QueryRunner(JDBCUtils.getDataSource());
//执行SQL语句
String sql = "DELETE FROM zhangwu WHERE name = ?";
Object[] params = {"股票收入"};
int line = qr.update(sql, params);
//结果集的处理
System.out.println("line="+line);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
//更新功能
@Test
public void update(){
try {
//创建一个QueryRunner对象，用来完成SQL语句的执行
QueryRunner qr = new
QueryRunner(JDBCUtils.getDataSource());
//执行SQL语句
String sql = "UPDATE zhangwu SET money = money+1000
WHERE name=?";
Object[] params = {"股票收入"};
int line = qr.update(sql, params);
//结果集的处理
System.out.println("line="+line);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
//查询功能,将结果集中第一条记录封装到一个指定的javaBean中。
@Test
public void search(){
try{
//获取QueryRunner
QueryRunner qr = new
QueryRunner(JDBCUtils.getDataSource());
//执行SQL语句
String sql = "SELECT * FROM zhangwu";
Object[] params = {};
Product p = qr.query(sql, new BeanHandler<Product>
(Product.class), params);
//结果集处理
System.out.println(p);
} catch(SQLException e){
throw new RuntimeException(e);
}
}
}

（4）常见配置项

分类	属性	描述
必须项	driverClassName	数据库驱动名称
	url	数据库的地址
	username	用户名
	password	密码
基本项（扩展）	maxActive	最大连接数量
	minIdle	最小空闲连接
	maxIdle	最大空闲连接
	initialSize	初始化连接

CSDN学习社区

CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！

更多推荐

嵌入式作业（七）：基于Ardunio的STM32串口通信

嵌入式作业（七）0作业要求1Ardunio 完成STM32的串口通信（1）安装Ardunio IDE（2）stm32串口通信2关于 stduino IDE0作业要求安装 Ardunio IDE 和相关软件支持库，在Ardunio 完成STM32板子的串口通信程序：（1）持续向串口输出“Hello world！”；（2）当接收到“stop!”时，停止输出。网上有一个国人版的MCU集成开发平台， st

CSDN学习社区

JDBC详解

JDBC文章目录JDBC什么是JDBC?JDBC驱动程序:Java使用JDBC访问数据库的步骤:设置classpath:Oracle连接字符串的书写格式:简单的例子:常用数据库的驱动程序及JDBC URL:Oracle数据库:SQL Server数据库MySQL数据库Access数据库PreparedStatement接口:JNDI-数据源（Data Source）与连接池（Connection

CSDN学习社区

“模式识别与机器学习”学习笔记no2.再谈感知机

接**上篇：上篇主要进行了PLA，Pocket算法的理论过程分析和在给定数据集上利用pocket算法对数据集进行分类学习，得到错分数量最少的分类面。上篇中pocket算法的过程已经进行了编程和测试，框架已经建立了起来，这一篇主要上篇中没有提到或涉及不深的几个问题。1.数据集的构造。上篇是直接使用了题目给的向量，这次来根据正态分布来产生数据集。np.random.normal函数可以根据均值和方差生