JDBC入门

JDBC

 本文所有用到的jar包以及propertiy文件皆通过以下方式获取：
 https://pan.baidu.com/s/1D6htw0S5FpDTXjkab8dlDQ?pwd=qwx0
 提取码：qwx0

（一）概念：

概念 ：JDBC是使用java语言操作关系型数据库的一套API。也就是说JDBC就是通过java程序来操作数据库的东西，而且JDBC是一种规则，通过这个规则，我们既可以通过同一套代码操作MySQL数据库，也可以操作Oracle数据库等多种数据库，实现一次编写到处运行
全称 ：Java DataBase Connectivity（Java数据库连接）

注意：JDBC本身并不具备实现类，而是各个数据库自己备好了实现类等待JDBC去用
驱动：例如MySQL驱动，Oracle驱动等等，本质上都是为了创建实现类，通过这些实现类实现JDBC对于数据库的操作。各个数据库厂商针对sun公司的这套规则来创建实现类并提供jar包（所以数据库驱动本身就是一个第三方包）

（二）入门代码：

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

//JDBC快速入门
public class JDBCDemo {
    public static void main(String[] args) throws Exception {


        //1.注册驱动：
        //Class.forName("com.mysql.jdbc.Driver"); //驱动程序就是帮助java和数据库进行连接的
        



        //2.获取连接：
        String url = "jdbc:mysql://127.0.0.1:3306/test?useSSL=false";
        String url2 = "jdbc:mysql:///test?useSSL=false";
        
        String username = "itcast";
        String password = "123456";
        Connection connection = DriverManager.getConnection(url2,username,password);

        //3.定义sql语句
        String sql = "update user set name = 123456 where id = 1 ";

        //4.获取执行sql语句的对象 Statement
        Statement statement = connection.createStatement();

        //5.执行sql
        int i = statement.executeUpdate(sql); //会返回受影响的行数

        //6.处理结果：
        System.out.println("受影响的行数为:" + i );

        //7.释放资源，因为statement是由connection而创造，所以先statement后connection
        statement.close();
        connection.close();


    }
}

可将从connection获得的statement理解为java程序的代理人，是它来操作语句

（三）API详解

3.1 DriverManager：

其最为重要的两个操作：

DriverManager.getConnection; --1
DriverManager.registerDriver; --2

在class.forName("com.mysql.jdbc.Driver")的时候，这时如果进入Driver的底层代码进行查看，则会发现（如下图）

小点 ：注册驱动的操作在静态代码块 中，在通过class.forName()加载Driver类的时候，其中的静态代码块自动执行 ，，因此实际上还是DriverManager在执行注册操作而非class.forName()；

注意 ：在MySQL5版本之后，可以不用手动注册驱动，因为mysql的jar包里面的services包中本就包含了驱动类，到时候运行程序它会自动帮我们注册驱动，如图：

3.2 Connection:

（1）事务管理：

事务：是数据库操作的一个逻辑工作单元，里面有一些操作。这些操作要么全部成功执行，要么全部不执行。

就比方说，支付扣款和收款，这就是一个事务，要么收款和付款同时成功，要么同时不成功。不能付款完了收不到款，也不能付款失败却收款成功

1.1 MySQL事务管理：
开启事务（begin / start transaction） ：作为一个"界限"，在这个界限内的所有操作都被叫做事务，要么全部成功，要么全部不执行
提交事务（commit）
回滚事务(rollback) ：撤销已执行的操作，回到一开始的状态。

MySQL默认自动提交事务
自动提交事务 ：每一条单独的SQL语句都会被当作一个独立的事务来处理，执行后自动提交
提交 ：确认并永久保存事务中的所有操作
1.2 JDBC事务管理
开启事务 ：setAutoCommit (boolean autoCommit) true为自动提交事务，false为手动提交事务，也就是开启事务
提交事务 ：commit();
回滚事务 ：rollback();

在jdbc中，事务 就是setAutoCommit(false)到commit()之间的代码块 。

尝试实现如下逻辑：将两个sql语句放入一个事务中，在两个语句之间创造一个异常。出现异常之后，即使第一个语句原本能正常执行，最终依然会被执行失败。示例代码如下：

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

//JDBC快速入门
public class JDBCDemo {
    public static void main(String[] args) throws Exception {


        //1.注册驱动：
        Class.forName("com.mysql.jdbc.Driver"); //驱动程序就是帮助java和数据库进行连接的
        //在MySQL5版本之后，可以不用手动注册驱动，因为mysql的jar包里面的services包中本就包含了驱动类，到时候运行程序它会自动帮我们注册驱动



        //2.获取连接：
        String url = "jdbc:mysql://127.0.0.1:3306/test?useSSL=false";
        String url2 = "jdbc:mysql:///test?useSSL=false";

        String username = "itcast";
        String password = "123456";
        Connection connection = DriverManager.getConnection(url2,username,password);

        //3.定义sql语句
        String sql1 = "update user set name = 123456 where id = 1 ";
        String sql2 = "update user set name = 13 where id = 2";
        //4.获取执行sql语句的对象 Statement
        Statement statement = connection.createStatement();

        try {
            //开启事务：
            connection.setAutoCommit(false);


            //5.执行sql
            int i1 = statement.executeUpdate(sql1); //会返回受影响的行数

            //创造一个异常
            int a = 3 / 0;

            int i2 = statement.executeUpdate(sql2);
            //6.处理结果：
            System.out.println("sql1受影响的行数为:" + i1);
            System.out.println("sql2受影响的行数为:" + i2);

            //提交事务：
            connection.commit();

        }catch (Exception e) {
            e.printStackTrace();
            connection.rollback();
            //如果有异常则回滚
        }
        //7.释放资源，因为statement是由connection而创造，所以先statement后connection
        statement.close();
        connection.close();


    }
}

而mysql数据库的表如下：

由此可见，上述的修改操作并未生效，论证了事务的原子性。
注意 ：如果没写commit()方法，那么就无法形成一个真正的事务。第一条sql语句可以成功执行，第二条sql语句不可以成功执行。
（2）获取执行SQL语句的对象：
2.1 普通的执行SQL语句的对象：

connection.getStatement();

2.2 预编译SQL的执行SQL语句的对象：

connection.prepareStatement();

这个方法是用来防止SQL注入的
SQL注入 ：一种恶意攻击手段，指的是外来攻击者向原SQL语段中插入一段SQL语句，来实现某种目的，或干扰原先进程的行为。
2.3 执行存储过程的对象：

connection.preapareCall();

存储过程 ：指的是将预先编译好，并且存储在数据库中的一组SQL语句，可以像函数一样的调用。类似于java代码里面的封装

实际使用方式：connection.prepareCall()会返回一个CallableStatement对象，由这个对象调用execute()方法来调用SQL语句

3.3 Statement

（1）执行SQL语句

1.1 执行DML，DDL语句。

statement.executeUpadate();

会返回一个整型数据，也就是数据库表中受影响的行数。

执行DML语句时，会返回受影响的行数，届时在创建实际的系统项目时，往往要根据受影响的行数值来给出"修改成功"/"修改失败"的提示，而非单纯的数字。

执行DDL语句时，会对数据库，表本身进行操作，而在进行删除数据库的操作时，会返回一个值为0，因此明明执行成功，却还是返回0，因此不能像对待DML语句那样，根据受影响行数是否大于0来判断是不是修改成功与否。

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

//JDBC快速入门
public class JDBCDemo_StatementDDL {
    public static void main(String[] args) throws Exception {


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

        String sql1 = "create database fjm03";
        Statement statement = connection.createStatement();
            
            int i1 = statement.executeUpdate(sql1); //会返回受影响的行数

         
            System.out.println("sql1受影响的行数为:" + i1);

         
            
        statement.close();
        connection.close();
        
    }
}

注意 ：只有具有create权限的用户才可以创建数据库，而每个mysql数据库会默认有一个root用户，它具有create权限可以直接拿来用，只不过由于其密码不可见的缘故，你需要提前为root用户更改好密码。

而后可能会出现如下提示：

这表明用户root被拒绝访问，可以点击Change Credentials ，进入修改密码，也可以点击Abort 表示此次不修改。
1.2 执行DQL语句。

statement.executeQuery();

会返回一个ResultSet集合 对象。

示例代码如下：

package jdbc;

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

//JDBC快速入门
public class JDBCDemo_ResultSet {
    public static void main(String[] args) throws Exception {


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

        String sql = "select * from user";

        Statement statement = connection.createStatement();
        ResultSet rs = statement.executeQuery(sql);

        while (rs.next()){
            int id = rs.getInt(1);
            String name = rs.getString(2);
            int age = rs.getInt(3);
            int IDCard = rs.getInt(4);
            String Code = rs.getString(5);

            System.out.println("id：" + id + "name" + name + "age：" + age + "IDCard："+ IDCard + "Code：" + Code );
            System.out.println("_____________________________");
        }


        connection.close();

    }
}

注意 ：getInt()/getString()就是获取一个int/String对象的方法，括号内的参数columnIndex 的意思是表的第几列，第一列就是1，第二列就是2。这与一般索引从0开始是不一样的。只是注意要获取的数据类型要和这一列实际的数据类型相同就行。还有一种参数是columnLable，这个意思就是说获取对应标签下的数据。如下：

while (rs.next()){
            int id = rs.getInt("id");
            String name = rs.getString("name");
            int age = rs.getInt("age");
            int IDCard = rs.getInt("IDCard");
            String Code = rs.getString("Code");

            System.out.println("id：" + id + "name" + name + "age：" + age + "IDCard："+ IDCard + "Code：" + Code );
            System.out.println("_____________________________");
        }

运行结果与刚才一摸一样。

statement.executeQuery();返回的是ResultSet对象。里面有一个next() 方法，这个方法就是将搜索光标向下移动一行，如果这行没数据就返回false，有的话就返回true。因此基于这一点建立while循环，一行一行的把数据打出来。至此初步的Demo运行成功

在实际的项目中，不能像输出语句那样松散，需要把这些数据都封装在一个类的对象中，然后添加进入一个集合中。 如下：

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

//JDBC快速入门
public class JDBCDemo_ResultSet {
    public static void main(String[] args) throws Exception {


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

        String sql = "select * from user";

        Statement statement = connection.createStatement();
        ResultSet rs = statement.executeQuery(sql);


        List<Account> list = new ArrayList<>();
        
        while (rs.next()){
            int id = rs.getInt("id");
            String name = rs.getString("name");
            int age = rs.getInt("age");
            int IDCard = rs.getInt("IDCard");
            String Code = rs.getString("Code");

            Account account = new Account();
            account.setId(id);
            account.setName(name);
            account.setAge(age);
            account.setIDCard(IDCard);
            account.setCode(Code);


            list.add(account);
        }
        System.out.println(list);

        connection.close();

    }
}

小疑问：为什么很多人在创建集合的时候喜欢使用List<>创建，而不是ArrayList<>？

答：因为这样写的代码易修改，例如之后要换成LinkedList，只需要修改后面的一部分就行了，不用连带着所有ArrayList的部分一块修改。

3.4 PreaparedStatement

（1）登录逻辑演示：

目前的包括以后的项目中，查找逻辑是这样的：如果能从用户名和密码的组合对应查找到数据，则代表登陆成功，反之如果找不见则代表登陆失败。

package jdbc;

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

//JDBC快速入门
public class JDBCDemo_LoginPreapareStatement {
    public static void main(String[] args) throws Exception {


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

        
            // 定义用户名和密码（这个用户名和密码不是数据库用户，而是表中的用户）
        String name = "8";
            //暂时用id代替密码，因为已经懒得创建一个新表了
        int id = 7;
        String sql1 = "select * from user where name = '"+ name +"' and id = '"+ id +"' ";
        Statement statement = connection.createStatement();

        ResultSet rs = statement.executeQuery(sql1);

        //一开始的rs的next()方法处在第一行的位置
        if(rs.next()){
            System.out.println("登陆成功！！");
        }else{
            System.out.println("登陆失败！！");
        }



        statement.close();
        connection.close();

    }
}

此时如果将sql语句换为：

String sql1 = "select * from user where name = '"+ name +"' and id = '' or '1' = '1' ";

则仍然可以登陆成功。原理如下：

 where name = '"+ name +"' and id = ''

由and分隔开的两部分合在一块的结果为false，但是又因为后面的or '1'='1'始终为true，因此false or true的结果始终为true，所以会登录成功。但是当下的网站基本上都可以防止SQL注入，所以一般不采用这个方式攻击网站。

如何修改这一点呢？

（2）PreparedStatement的使用

原先之所以会出现那个注入问题，就是因为原先的SQL语句需要进行字符串拼接，才会导致语义的改变，因此接下来就不使用字符串拼接，而采用PreparedStatement对象进行预编译。

package jdbc;

import java.sql.*;

//JDBC快速入门
public class JDBCDemo_Login_PreparedStatement {
    public static void main(String[] args) throws Exception {


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

        // 目前的包括以后的项目中，查找逻辑是这样的：如果能从用户名和密码的组合查找到数据，则代表登陆成功，反之如果找不见则代表登陆失败。
            // 定义用户名和密码（这个用户名和密码不是数据库用户，而是表中的用户）
        String name = "8";
            //暂时用id代替密码，因为已经懒得创建一个新表了
        String id = "8";
        String id2 = "'' or '1' = '1'";
        String sql1 = "select * from user where name = ? and id = ? ";
        PreparedStatement preparedStatement = connection.prepareStatement(sql1);

        preparedStatement.setString(1,name);
        preparedStatement.setString(2,id2);

        ResultSet rs = preparedStatement.executeQuery();

        //一开始的rs的next()方法处在第一行的位置
        if(rs.next()){
            System.out.println("登陆成功！！");
        }else{
            System.out.println("登陆失败！！");
        }



        preparedStatement.close();
        connection.close();

    }
}

注意：将原先的sql语句里面的拼接部分去掉，转而变为？，然后使用connection对象获取preparedStatement对象，然后进行参数设置。各自调用SetString()/SetArray()等方法。括号内有两个参数，第一个参数是？的位置，第二个参数是到底该赋什么值。并且参数的类型要与？所在的应该填的位置一一对应。

然后尝试给密码赋值:

String id2 = "'' or '1' = '1'";

结果显示登陆失败，说明该对象有效防止了SQL注入。

数据库连接池

概念 ：就是一个池子，里面尽是些数据库连接，并且能管理它们。
存在缘由 ：如果没有池子，那就是一个用户来连接数据库，创建并使用一个connection，不用了就给它弃掉，再来一个用户连接数据库， 创建并使用一个connection，不用了再给它弃掉。这样做十分的浪费资源。因此创建一个数据库连接池，预先创建好 一定数量的connection，等到用户来连接，就从池子中拿出，如果用户不用了就把connection 放回去 。
好处 ：
1.允许用户重复使用一个现有的连接，而不是再创建一个（资源重用）
2.提升系统响应速度。可以直接使用，不用一个一个先申请再使用（需要进行TCP三次握手等行为）
3.避免数据库连接遗漏。在连接 一定时间后被强制断开还回，即便还在使用。在空闲 一定时间后被断开还回
数据库连接遗漏 ：用户建立连接后一直占用，不还给连接池。导致这个连接无法被复用。

常见的数据库连接池：

DBCP

CP30

Druid（德鲁伊）

德鲁伊是阿里巴巴的开源项目，性能强大，最好的数据库连接池之一

以下是对数据库连接的一个小演示

package config;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.Connection;
import java.util.Properties;

public class DataSourceGet {
    public static void main(String[] args) throws Exception {
        // 导入jar包


        // 配置文件

        // 加载配置文件
            // 创建配置文件对象
        Properties prop = new Properties();
            // 使用该对象加载配置文件
        prop.load(new FileInputStream("src/config/config.properties")); // 注意load的参数应该是文件的字节流对象，而非文件类型数据
        // 获取连接
            // 使用德鲁伊数据库工厂创建数据库连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
            // 从数据库连接池对象获取连接
        Connection connection = dataSource.getConnection();
        
        // 输出结果
        System.out.println(connection);
    }
}

1.导入jar包：

2.配置文件（直接从文章开头的资料链接中获取）

"JDBC相关jar包"是我自己命名的，原文件名字是day03-JDBC

3.加载配置文件：

通过Properties创建一个配置文件对象，然后加载文件字节流对象。

4.获取连接池对象。

通过DruidDataSourseFactory获取数据库连接池对象。

5.获取连接对象。

通过数据库连接池对象获取连接

最终运行结果如下：

实战练习：

（1）查询品牌及相关数据

准备Brand类：

package jdbc;

public class Brand {
    // id 主键
    private int id   ;
    // 品牌名称
    private String brand_name ;
    // 企业名称
    private String company_name;
    // 排序字段
    private int ordered;
            // 描述信息
    private String description     ;
    // 状态：0：禁用  1：启用
    private int status ;

    public int getId() {
        return id;
    }

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

    public String getBrand_name() {
        return brand_name;
    }

    public void setBrand_name(String brand_name) {
        this.brand_name = brand_name;
    }

    public String getCompany_name() {
        return company_name;
    }

    public void setCompany_name(String company_name) {
        this.company_name = company_name;
    }

    public int getOrdered() {
        return ordered;
    }

    public void setOrdered(int ordered) {
        this.ordered = ordered;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    @Override
    public String toString() {
        return "Brand{" +
                "id=" + id +
                ", brand_name='" + brand_name + '\'' +
                ", company_name='" + company_name + '\'' +
                ", ordered=" + ordered +
                ", description='" + description + '\'' +
                ", status=" + status +
                '}';
    }
}

创建BrandTest类：

package jdbc;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class BrandTest {
    /**
     * 查询数据的三个需要关注的核心要素：
     * 1. sql语句怎么些=写
     * 2. 为防止sql注入我们采用了prepareStatement，要不要/怎么设置参数
     * 3. 需不需要对查询到的结果进行封装并添加进入列表中
     *
     */
    public static void main(String[] args) throws Exception{
        //加载配置文件获取数据库连接池
        Properties prop =new Properties();
        prop.load(new FileInputStream("src/config/config.properties"));

        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

        //获取连接：
        Connection connection = dataSource.getConnection();

        //获取PreparedStatement对象
        String sql = "select * from tb_brand";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);

        //设置参数：
        //此处不需要

        ResultSet rs = preparedStatement.executeQuery();

        //创建集合：
        List<Brand> list = new ArrayList<Brand>();
        while(true){
            if(rs.next()){
                // 获取接收到的信息:
                int id = rs.getInt("id");
                String brand_name = rs.getString("brand_name");
                String company_name = rs.getString("company_name");
                int ordered = rs.getInt("ordered");
                String description = rs.getString("description");
                int status = rs.getInt("status");

                // 创建Brand对象：
                Brand brand = new Brand();
                brand.setId(id);
                brand.setBrand_name(brand_name);
                brand.setCompany_name(company_name);
                brand.setOrdered(ordered);
                brand.setDescription(description);
                brand.setStatus(status);

                // 放入集合中：
                list.add(brand);

            }else{
                break;
            }
        }
        System.out.println(list);

    }

}

主要其实就是对于目前的核心类的熟练运用，以及对于核心三要素的实现。

核心三要素：

1.sql语句
2.设置参数
3.封装入集合

异常：

Exception in thread "main" com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Table 'test.tb_brand' doesn't exist

这其实就是配置文件出了个小问题：配置文件里面的那个url语句中的数据库**test不包含tb_brand这个表。**因此将数据库名修改完成即可。

（2）添加/修改/删除（实际应用）

（1）添加：

package jdbc;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class BrandTest {
    /**
     * 查询数据的三个需要关注的核心要素：
     * 1. sql语句怎么写
     * 2. 为防止sql注入我们采用了prepareStatement，要不要/怎么设置参数
     * 3. 需不需要对查询到的结果进行封装并添加进入列表中
     * 添加/修改/删除
     */
    public static void main(String[] args) throws Exception{
        //加载配置文件获取数据库连接池
        Properties prop =new Properties();
        prop.load(new FileInputStream("src/config/config.properties"));

        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

        //获取连接：
        Connection connection = dataSource.getConnection();

        //获取PreparedStatement对象
        String sql = "Insert into tb_brand(brand_name,company_name,ordered,description,status)values(?,?,?,?,?)";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);

        //设置参数：
        preparedStatement.setString(1,"阿里巴巴");
        preparedStatement.setString(2,"阿里巴巴科技长沙有限公司");
        preparedStatement.setInt(3,70);
        preparedStatement.setString(4,"我们的科技十分牛逼");
        preparedStatement.setInt(5,1);
        //查询不需要，添加需要

        int count  = preparedStatement.executeUpdate();

        System.out.println(count > 0);


    }

}

注意：id这个变量之所以没有放入sql语句里面，是因为我们需要让id自动追赠而不是手写sql语句让它自增

异常：

You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '?,?,?,?,?)' at line 1

翻译过来是：你需要检查一下MySQL的服务手册，看看关于这一行的代码的正确语法。

问题就在于使用preparedStatement预编译了一次之后，后续的executeUpdate(sql)方法又执行了一次sql语句。修改方法就是把括号里面的sql删除就行。

（2）修改

package jdbc;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class BrandTest {
    /**
     * 查询数据的三个需要关注的核心要素：
     * 1. sql语句怎么写
     * 2. 为防止sql注入我们采用了prepareStatement，要不要/怎么设置参数
     * 3. 需不需要对查询到的结果进行封装并添加进入列表中
     * 添加/修改/删除
     */
    public static void main(String[] args) throws Exception{
        //加载配置文件获取数据库连接池
        Properties prop =new Properties();
        prop.load(new FileInputStream("src/config/config.properties"));

        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

        //获取连接：
        Connection connection = dataSource.getConnection();

        //获取PreparedStatement对象
        String sql = "Update tb_brand set brand_name = ?, company_name = ?,ordered =  ?, description = ?,status = ? where id = ?";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);

        //设置参数：
        preparedStatement.setString(1,"阿里妈妈");
        preparedStatement.setString(2,"阿里妈妈科技长沙有限公司");
        preparedStatement.setInt(3,80);
        preparedStatement.setString(4,"我们的科技巨牛逼");
        preparedStatement.setInt(5,1);
        preparedStatement.setInt(6,4);
        //查询不需要，添加需要

        int count  = preparedStatement.executeUpdate();

        System.out.println(count > 0);


    }

}

只需要对sql语句修改即可

异常：

Statement parameter 6 not set.

如果没有对第六位的数字进行赋值，就会报出这行错误。

（3）删除数据

package jdbc;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class BrandTest {
    /**
     * 查询数据的三个需要关注的核心要素：
     * 1. sql语句怎么写
     * 2. 为防止sql注入我们采用了prepareStatement，要不要/怎么设置参数
     * 3. 需不需要对查询到的结果进行封装并添加进入列表中
     * 添加/修改/删除
     */
    public static void main(String[] args) throws Exception{
        //加载配置文件获取数据库连接池
        Properties prop =new Properties();
        prop.load(new FileInputStream("src/config/config.properties"));

        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

        //获取连接：
        Connection connection = dataSource.getConnection();

        //获取PreparedStatement对象
        String sql = "delete from tb_brand where id = 4";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        

        int count  = preparedStatement.executeUpdate();

        System.out.println(count > 0);


    }

}

异常：

You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'from tb_brand where id = 4' at line 1

注意 ：删除表中的某行数据 使用delete ，删除整张表 使用drop，不要混用，混用就会报出这些错误。

至此，关于JDBC的基本概念，其中的几个核心类，以及初步的代码实操，实现了进一步对sql语句的掌握和理解。就结束了