19.JDBC

JDBC

Java 数据库连接（Java DataBase Connectivity）

概念：

Java 数据库连接（Java DataBase Connectivity）

规定了数据库厂商和Java连接的一些规则（接口），将来数据库厂商如果想编写程序连接到Java，必须要遵守指定的规则，需要实现规定的接口。

程序员使用的时候，需要使用数据库厂商提供的jar包来完成连接操作。

package com.day19.jdbc1;

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

public class JDBCDemo01 {
    public static void main(String[] args) throws Exception {
        //快速实现JDBC使用
        //1.导入jar包，将jar包拷贝到src下，右击 add as library
        //2.加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //3.设置数据库连接，获取数据库连接对象Connection
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test" +
                                                      "?serverTimezone=GMT%2B8&useSSL=false&useUnicode=true&characterEncoding=utf-8",
                                                      "root", "123456");
        //4.通过连接对象，获取执行
        Statement stmt = conn.createStatement();
        //5.写一个SQL语句
        String sql="INSERT INTO test VALUES(1001,'jack',19);";
        //6.执行sql，返回结果
        int i = stmt.executeUpdate(sql);
        //7.处理结果
        if (i>0){
            System.out.println("数据库执行修改操作成功！");
        }
        //8.资源关闭
        stmt.close();
        conn.close();
    }

}

package com.day19.jdbc1;

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

public class JDBCDemo02 {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        try {
            //快速实现JDBC使用
            //1.导入jar包，将jar包拷贝到src下，右击 add as library
            //2.加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            //3.设置数据库连接，获取数据库连接对象Connection
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test" +
                                               "?serverTimezone=GMT%2B8&useSSL=false&useUnicode=true&characterEncoding=utf-8",
                                               "root", "123456");
            //4.通过连接对象，获取执行
            stmt = conn.createStatement();
            //5.写一个SQL语句
            String sql="INSERT INTO test VALUES(1003,'Amy',20);";//增删改

            //6.执行sql，返回结果
            int i = stmt.executeUpdate(sql);//增删改

            //7.处理结果
            if (i>0){//增删改
                System.out.println("数据库执行修改操作成功！");
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            //8.资源关闭
            try {
                if (stmt != null){
                    stmt.close();
                }
                if (conn != null){
                    conn.close();
                }

            } catch (SQLException e) {
                e.printStackTrace();
            }

        }

    }
}

通过JDBC实现数据查询

package com.day19.jdbc2;

import java.sql.*;

/*
通过JDBC实现数据查询
 */
public class JDBCDemo03 {
    public static void main(String[] args) {
        Connection connection = null;
        Statement statement = null;
        try {
            //1.导入jar包，将jar包拷贝到src下，右击 add as library
            //2.加载驱动（mysql5.5之后可以不写）
            Class.forName("com.mysql.jdbc.Driver");
            //3.设置数据库连接，获取数据库连接对象Connection
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test" +
                                                     "?serverTimezone=GMT%2B8&useSSL=false&useUnicode=true&characterEncoding=utf-8",
                                                     "root", "123456");
            //4.通过连接对象，获取执行
            statement = connection.createStatement();
            //5.写一个SQL语句
            String sql="select * from test";//查询
            //6.执行sql，返回结果
            ResultSet resultSet = statement.executeQuery(sql);//查询

            //7.调用结果集对象，获取数据
            //next()方法返回布尔值类型，如果没有数据返回了，返回false，
            while (resultSet.next()){
                //调用getxxx()方法，获取数据
                //具体调用什么get方法，根据数据库中的每个字段的类型来
                //字符串 getString()
                //整数 getInt()

                //传入的参数可以是String类型和int类型

                //String类型，一般表示字段的名称，如果有别名，就用别名
                int sid = resultSet.getInt("sid");
                String sname = resultSet.getString("sname");
                int sage = resultSet.getInt("sage");
                System.out.println(sid+"--"+sname+"--"+sage);

                //int类型，表示获取数据中第几列的值
                int s_id = resultSet.getInt(1);
                String s_name = resultSet.getString(2);
                int s_age = resultSet.getInt(3);
                System.out.println(s_id+"--"+s_name+"--"+s_age);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //8.资源关闭
            try {
                if (statement != null){
                    statement.close();
                }
                if (connection != null){
                    connection.close();
                }

            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }
}

练习 1 ：将所有Student对象查询后，存入集合，并返回

package com.day19.jdbc2prac;
/*
创建和数据库student对应的实体类
 */
public class Student {
    private int sid;
    private String sname;
    private int sage;
    private String ssex;
    private String snativeplace;
    private String smajor;
    private String sclass;
    private String snative;

    public Student() {
    }

    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public int getSage() {
        return sage;
    }

    public void setSage(int sage) {
        this.sage = sage;
    }

    public String getSsex() {
        return ssex;
    }

    public void setSsex(String ssex) {
        this.ssex = ssex;
    }

    public String getSnativeplace() {
        return snativeplace;
    }

    public void setSnativeplace(String snativeplace) {
        this.snativeplace = snativeplace;
    }

    public String getSmajor() {
        return smajor;
    }

    public void setSmajor(String smajor) {
        this.smajor = smajor;
    }

    public String getSclass() {
        return sclass;
    }

    public void setSclass(String sclass) {
        this.sclass = sclass;
    }

    public String getSnative() {
        return snative;
    }

    public void setSnative(String snative) {
        this.snative = snative;
    }

    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", sname='" + sname + '\'' +
                ", sage=" + sage +
                ", ssex='" + ssex + '\'' +
                ", snativeplace='" + snativeplace + '\'' +
                ", smajor='" + smajor + '\'' +
                ", sclass='" + sclass + '\'' +
                ", snative='" + snative + '\'' +
                '}';
    }
}

package com.day19.jdbc2prac;
/*
将所有Student对象查询后，存入集合，并返回
 */
import java.sql.*;
import java.util.ArrayList;

public class Demo04 {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        ResultSet resultSet = null;
        try {
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test2" +
                            "?serverTimezone=GMT%2B8&useSSL=false&useUnicode=true&characterEncoding=utf-8",
                    "root", "123456");

            stmt = conn.createStatement();

            String sql="select * from student";

            resultSet = stmt.executeQuery(sql);

            ArrayList<Student> list = new ArrayList<>();
            while (resultSet.next()){
//                int sid = resultSet.getInt(1);
//                String sname = resultSet.getString(2);
//                int sage = resultSet.getInt(3);
//                String ssex = resultSet.getString(4);
//                String snativeplace = resultSet.getString(5);
//                String smajor = resultSet.getString(6);
//                String sclass = resultSet.getString(7);
//                String snative = resultSet.getString(8);

                Student student = new Student();
                student.setSid(resultSet.getInt(1));
                student.setSname(resultSet.getString(2));
                student.setSage(resultSet.getInt(3));
                student.setSsex(resultSet.getString(4));
                student.setSnativeplace(resultSet.getString(5));
                student.setSmajor(resultSet.getString(6));
                student.setSclass(resultSet.getString(6));
                student.setSnative(resultSet.getString(8));

                list.add(student);
            }
            System.out.println(list);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (resultSet!=null){
                    resultSet.close();
                }
                if (conn!=null){
                    conn.close();
                }
                if (stmt!=null){
                    stmt.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }


    }
}

练习 2:使用jdbc模拟登陆系统，让用户输入用户名和密码

如果用户名和密码都正确，则返回 登录 成功

package com.day19.jdbc3;

public class TUser {
    private int tid;
    private String tname;
    private String tpwd;

    public TUser() {
    }

    public int getTid() {
        return tid;
    }

    public void setTid(int tid) {
        this.tid = tid;
    }

    public String getTname() {
        return tname;
    }

    public void setTname(String tname) {
        this.tname = tname;
    }

    public void setTpwd(String tpwd) {
        this.tpwd = tpwd;
    }

    public String getTpwd() {
        return tpwd;
    }

    @Override
    public String toString() {
        return "TUser{" +
                "tid=" + tid +
                ", tname='" + tname + '\'' +
                ", tpwd='" + tpwd + '\'' +
                '}';
    }
}

package com.day19.jdbc3;

import java.sql.*;
import java.util.ArrayList;
import java.util.Scanner;
/**
*使用jdbc模拟登录系统，让用户输入用户名和密码
 如果用户名和密码都正确，则返回登陆成功
 */
public class JDBCDemo05 {
    public static void main(String[] args) throws Exception {
        //创建输入对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String name = sc.next();
        System.out.println("请输入密码：");
        String pwd = sc.next();

        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test" +
                        "?serverTimezone=GMT%2B8&useSSL=false&useUnicode=true&characterEncoding=utf-8",
                "root", "123456");

//        Statement stmt = conn.createStatement();

        //使用字符串拼接的写法，将来会出现SQL注入问题
        //请输入用户名：
        //fwaef
        //请输入密码：
        //awfef'or'a'='a
        //select * from tuser where tname = 'fwaef' and tpwd= 'awfef'or'a'='a'
        //[TUser{tid=1, tname='jack', tpwd='111111'}]
        //登陆成功！
//        String sql="select * from tuser where tname = '"+name+"' and tpwd= '"+pwd+"' " ;

        //将来一般通过预编译的方式，使用占位符，去代替拼接的变量
//        String sql="select * from tuser where tname = '"+name+"' and tpwd= '"+pwd+"' " ;
        String sql ="select * from tuser where tname = ? and tpwd= ? " ;
        System.out.println(sql);//查看sql语句是否正确

        //如果使用占位符，解决SQL注入问题，这个sql语句将来在执行之前得预编译，
        //将？的值绑定为传递进来的变量值
        
        PreparedStatement pstmt = conn.prepareStatement(sql);

        //绑定？的值
        pstmt.setString(1,name);
        pstmt.setString(2,pwd);
        //执行sql，获取结果集对象
        ResultSet resultSet = pstmt.executeQuery();

//        ResultSet resultSet = stmt.executeQuery(sql);

        ArrayList<TUser> list = new ArrayList<>();
        if (resultSet.next()){
            TUser tUser = new TUser();
            tUser.setTid(resultSet.getInt(1));
            tUser.setTname(resultSet.getString(2));
            tUser.setTpwd(resultSet.getString(3));

            list.add(tUser);

            System.out.println(list);
            System.out.println("登录成功！");
        }else{
            System.out.println("登录失败！");
        }

        resultSet.close();
        pstmt.close();
//    stmt.close();
        conn.close();
    }

}

登录的时候，输入用户名和密码
1，如果用户名不存在， 则提示用户名不存在
2，如果用户名存在，密码不对，则提示密码错误
3，如果都正确，提示登录成功

package com.day19.jdbc3;
/*
登录的时候，输入用户名和密码
1，如果用户名不存在， 则提示用户名不存在
2，如果用户名存在，密码不对，则提示密码错误
3，如果都正确，提示登录成功
 */
import java.sql.*;
import java.util.Scanner;

public class JDBCDemo06 {
    public static void main(String[] args) throws Exception {
        //创建输入对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String name = sc.next();
        System.out.println("请输入密码：");
        String pwd = sc.next();

        String s = login(name, pwd);
        System.out.println(s);
    }

    //定义一个登陆方法
    public static String login(String name,String pwd) throws Exception {
        //获取数据库连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test" +
                        "?serverTimezone=GMT%2B8&useSSL=false&useUnicode=true&characterEncoding=utf-8",
                "root", "123456");

        //定义sql
        String sql ="select * from tuser where tname = ? " ;
        System.out.println(sql);//查看sql语句是否正确
        //获取数据库执行对象
        PreparedStatement pstmt = conn.prepareStatement(sql);
        pstmt.setString(1,name);
        //执行sql，获取结果集对象
        ResultSet resultSet = pstmt.executeQuery();

        //判断结果，用户名不存在， 则提示用户名不存在，并结束程序
        if (!resultSet.next()){
            return "用户名不存在!";
        }
        //用户名存在的情况
        TUser tUser = new TUser();
        tUser.setTid(resultSet.getInt(1));
        tUser.setTname(resultSet.getString(2));
        tUser.setTpwd(resultSet.getString(3));

        //密码不匹配的情况
        if (!pwd.equals(tUser.getTpwd())){
            return "密码错误！";
        }
            return "登录成功！";
    }
}

JDBC中使用的对象

1.DriverManager 驱动管理对象

作用：

1.注册驱动，告诉程序使用哪个数据库驱动jar包，mysql5版本后，可以省略此步骤

2.获取数据库连接对象Connection

static Connection getConnection(String url, String user, String password)

尝试建立与给定数据库URL的连接。

参数：

url：表示数据库连接地址。

mysql地址：jdbc:mysql://主机ip:3306/数据库名

oracle地址：jdbc:oracle:thin:@//主机ip:1521/数据库名

user：数据库用户名

password：数据库连接密码

2.Connection 数据库连接对象

作用：

1.获取执行sql语句的对象

Statement createStatement()

创建一个 Statement对象，用于将SQL语句发送到数据库。

PreparedStatement prepareStatement(String sql)

创建一个 PreparedStatement对象，用于将参数化的SQL语句发送到数据库。

2.事务管理

void commit()

使自上次提交/回滚以来所做的所有更改都将永久性，并释放此 Connection对象当前持有的任何数据库锁。

void setAutoCommit(boolean autoCommit)

将此连接的自动提交模式设置为给定状态。

void rollback()

撤消在当前事务中所做的所有更改，并释放此 Connection对象当前持有的任何数据库锁。

3.Statement

作用：

执行sql语句

执行查询sql->ResultSet executeQuery(String sql)

执行给定的SQL语句，该语句返回单个 ResultSet对象。

int executeUpdate(String sql)

执行给定的SQL语句，这可能是 INSERT，UPDATE，或DELETE语句，

或者不返回任何内容，如SQL DDL语句的SQL语句。

4.ResultSet

作用：

用来存放查询结果

ResultSet对象保持一个光标指向其当前的数据行。

最初，光标位于第一行之前。 next方法将光标移动到下一行，

并且由于在ResultSet对象中没有更多行时返回false，

因此可以在while循环中使用循环来遍历结果集。

常用方法：

1.boolean next()

将光标从当前位置向前移动一行。

2.Xxx getXxx方法：获取结果集中的具体值的方法

这里的Xxx代表了获取值的具体类型

比如：

String getString(int columnIndex)

这个检索的当前行中指定列的值 ResultSet对象为 String的Java编程语言。

String getString(String columnLabel)

这个检索的当前行中指定列的值 ResultSet对象为 String的Java编程语言。

int getInt(int columnIndex)

这个检索的当前行中指定列的值 ResultSet作为对象 int在Java编程语言。

int getInt(String columnLabel)

以Java编程语言中的 int此 ResultSet对象的当前行中指定列的值。

参数：

可以有2种类型参数，一个是int类型，一个字符串类型

传入int，就表示返回数据库结果集中的第几列

传入String，就表示返回数据库结果集中的具体的字段名

5.PreparedStatement 处理与编译的SQL对象

作用：

可以用来解决Statement对象使用的时候出现的SQL注入问题

SQL注入：

指的是编写SQL语句的时候，使用字符串拼接的方式，拼接数据，将来传值进来的时候，

可能会存在某些拼接问题，导致查询到不该查询的数据，引发数据安全问题。

PreparedStatement使用预编译的方式，将SQL语句中要传入的数据，以？代替，

然后再调用方法，去给？绑定值，最终完成sql的执行。

使用步骤：

1.定义sql

String sql ="select * from tuser where tname = ? " ;

System.out.println(sql);//查看sql语句是否正确

2.获取数据库执行对象

PreparedStatement pstmt = conn.prepareStatement(sql);

3.绑定？占位符的值

pstmt.setString(1,name);

常用方法：

执行方法：

ResultSet executeQuery()

执行此 PreparedStatement对象中的SQL查询，并返回查询 PreparedStatement的 ResultSet对象。

int executeUpdate()

执行在该SQL语句PreparedStatement对象，它必须是一个SQL数据操纵语言（DML）语句，

如INSERT ， UPDATE或DELETE ; 或不返回任何内容的SQL语句，例如DDL语句。

设置值方法：

setXxx(索引值,具体值)方法，用来绑定sql语句中的？的值

索引值表示绑定的是第几个?

具体值就是给?绑定的实际值，将来传入sql中使用的。

通过转账案例，完成事务流程执行

一次事务中，包含了2次修改操作 ，这两个操作，应该在同一个事务中，如果

第一次操作结束，发生异常，可以将数据回滚，否则数据一致性就不能得到保证

package com.day19.jdbc4;
/**
 * 事务操作
 *  通过转账案例，完成事务流程执行
 *  一次事务中，包含了2次修改操作 ，这两个操作，应该在同一个事务中，如果
 *  第一次操作结束，发生异常，可以将数据回滚，否则数据一致性就不能得到保证
 */
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class JDBCDemo07 {
    public static void main(String[] args) throws SQLException {
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test" +
                        "?serverTimezone=GMT%2B8&useSSL=false&useUnicode=true&characterEncoding=utf-8",
                "root", "123456");

        //转账第一个操作
        String sql1="update account set t_money = t_money-500 where t_name = 'jack'";
        PreparedStatement pstmt1 = conn.prepareStatement(sql1);
        int i1 = pstmt1.executeUpdate();
//        int a=3/0;//模拟异常
        //转账第二个操作
        String sql2="update account set t_money = t_money+500 where t_name = 'tom'";
        PreparedStatement pstmt2 = conn.prepareStatement(sql2);
        int i2 = pstmt2.executeUpdate();

        if (i1>0 && i2>0){
            System.out.println("转账完成！");
        }
    }
}

package com.day19.jdbc4;

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

/**
 * 事务操作异常情况
 *  通过转账案例，完成事务流程执行
 *  一次事务中，包含了2次修改操作 ，这两个操作，应该在同一个事务中，如果
 *  第一次操作结束，发生异常，可以将数据回滚，否则数据一致性就不能得到保证
 */
public class JDBCDemo08 {
    public static void main(String[] args){
        Connection conn = null;
        PreparedStatement pstmt1 = null;
        PreparedStatement pstmt2 = null;
        try {
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test" +
                            "?serverTimezone=GMT%2B8&useSSL=false&useUnicode=true&characterEncoding=utf-8",
                    "root", "123456");

            // 关闭事务的自动提交，手动开启事务
            conn.setAutoCommit(false);

            //转账第一个操作
            String sql1="update account set t_money = t_money-500 where t_name = 'jack'";
            pstmt1 = conn.prepareStatement(sql1);
            int i1 = pstmt1.executeUpdate();

            int a=3/0;//模拟异常

            //转账第二个操作
            String sql2="update account set t_money = t_money+500 where t_name = 'tom'";
            pstmt2 = conn.prepareStatement(sql2);
            int i2 = pstmt2.executeUpdate();

            if (i1>0 && i2>0){
                System.out.println("转账完成！");
            }

            conn.commit();//提交事务
            conn.setAutoCommit(true);
        } catch (Exception e) {
            //在catch块中做事务回滚
            try {
                System.out.println("转账过程中发生未知问题！");
                conn.rollback();
                conn.setAutoCommit(true);
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        } finally {
            try {
                if (pstmt1 !=null){
                    pstmt1.close();
                }
                if (pstmt2 !=null){
                    pstmt2.close();
                }
                if (conn !=null){
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

JDBC工具类封装

url=jdbc:mysql://localhost:3306/test1?serverTimezone=GMT%2B8&useSSL=false&useUnicode=true&characterEncoding=utf-8
user=root
password=123456
driver=com.mysql.jdbc.Driver

工具类主要用来存放一些常用的方法，可以方便调用，方便代码编写

1.获取数据据库连接，每次都要传参数，后续不想每次都去传递参数，还要保证通用性

2.关闭资源方法

package com.day19.jdbc5;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

/**
 * JDBC工具类封装
 * 工具类主要用来存放一些常用的方法，可以方便调用，方便代码编写
 * 1.获取数据据库连接，每次都要传参数，后续不想每次都去传递参数，还要保证通用性
 * 2.关闭资源方法
 */
public class JDBCUtils {
    //数据库连接的解决办法
    //把配置信息，放到配置文件中，将来直接从配置文件中读取或修改
    //将来直接调用获取Connection的方法，就给我返回Connection对象
    //不需要我再传值进去
    //每次调用类，就可以把配置信息加载，然后传入到方法中
    private static String url;
    private static String user;
    private static String password;
    private static String driver;

    //获取配置文件中的值
    static {
        try {
            InputStream inputStream = JDBCUtils.class.getClassLoader()
                    .getResourceAsStream("jdbc.properties");
            Properties properties = new Properties();
            properties.load(inputStream);
            //获取到加载配置文件中的各个属性值
            url=properties.getProperty("url");
            user=properties.getProperty("user");
            password=properties.getProperty("password");
            driver=properties.getProperty("driver");
            //注册驱动
            Class.forName(driver);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    //方法不需要参数
    public static Connection getConnection() {
        Connection connection = null;
        try {
            connection = DriverManager.getConnection(url, user, password);
        } catch (SQLException e) {
            System.err.println("数据库连接出问题了！");
            e.printStackTrace();
        }
        return connection;
    }

    //写一个统一的关闭资源的方法
    public static void close(ResultSet resultSet,Connection conn,Statement stmt){
        try {
            if (resultSet!=null){
                resultSet.close();
            }
            if (conn!=null){
                conn.close();
            }
            if (stmt!=null){
                stmt.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //利用可变长的参数，完成数据的动态绑定,可以被当成数组使用
    public static void setValue(PreparedStatement pstmt,Object ...objects ){
        try {
            for (int i = 0; i < objects.length; i++) {
                pstmt.setObject(i+1,objects[i]);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

package com.day19.jdbc5;

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

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

        try {
            //调用工具类中的getConnection()方法，直接给我返回Connection
            conn = JDBCUtils.getConnection();

            //创建sql语句
            String sql ="update tuser set tpwd= ? where tname = ? " ;
//            String sql1 ="insert into tuser values(?, ?, ? )" ;

            pstmt = conn.prepareStatement(sql);
            //绑定数据
//            pstmt.setString(2,"jack");
//            pstmt.setString(1,"123456");
            //直接传值到绑定方法中
//            JDBCUtils.setValue(pstmt,"123123","jack");
            //先把参数存入数组，再传入方法
            Object[] objects={"123123","jack"};
            JDBCUtils.setValue(pstmt,objects);

            int i = pstmt.executeUpdate();

            System.out.println(i>0 ? "成功" : "失败");
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            JDBCUtils.close(null,conn,pstmt);
        }

    }
}

使用工具类，完成增加学生的功能，需要让用户输入需要增加的学生信息， 然后将数据加到表中

package com.day19.jdbc5prac;
/**
 * 使用工具类，完成增加学生的功能，需要让用户输入需要增加的学生信息，
 * 然后将数据加到表中
 */

import com.day19.jdbc5.BaseDao;
import com.day19.jdbc5.JDBCUtils;

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

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

            Scanner sc = new Scanner(System.in);
            System.out.println("请输入要添加的学生信息");
            System.out.print("学号：");
            int sId = sc.nextInt();
            System.out.print("姓名：");
            String sName = sc.next();
            System.out.print("年龄：");
            int sAge = sc.nextInt();
            System.out.print("性别：");
            String sSex = sc.next();
            System.out.print("家乡：");
            String sNativePlace = sc.next();
            System.out.print("专业：");
            String sMajor = sc.next();
            System.out.print("班级：");
            String sClass = sc.next();
            System.out.print("民族：");
            String sNative = sc.next();

            String sql="insert into student values(?,?,?,?,?,?,?,?)";
            Object[] objects={sId,sName,sAge,sSex,sNativePlace,sMajor, sClass,sNative};
            BaseDao baseDao = new BaseDao();
            boolean b = baseDao.update(sql, objects);

            if (b){
                System.out.println("执行成功！");
            }
//            conn = JDBCUtils.getConnection();
//
//            //创建sql
//            String sql="insert into student values(?,?,?,?,?,?,?,?)";
//
//            pstmt = conn.prepareStatement(sql);
//            Object[] objects={sId,sName,sAge,sSex,sNativePlace,sMajor,sClass,sNative};
//            JDBCUtils.setValue(pstmt,objects);
//
//            int i = pstmt.executeUpdate();
//            System.out.println(i>0 ? "成功！" : "失败！");
//            JDBCUtils.close(null,conn,pstmt);

    }
}

公共方法封装

* 实现增删改的方法

* 实现查询所有的方法

package com.day19.jdbc5;

import org.apache.commons.beanutils.BeanUtils;

import java.lang.reflect.InvocationTargetException;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

/**
 * 存放一些公共方法
 * 实现增删改的方法
 * 实现查询所有的方法
 */
public class BaseDao {
    //实现增删改的方法
    public boolean update(String sql,Object ...objects){
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            conn = JDBCUtils.getConnection();
            pstmt = conn.prepareStatement(sql);
            JDBCUtils.setValue(pstmt,objects);

            int i = pstmt.executeUpdate();
            return i>0 ? true : false;
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.close(null,conn,pstmt);
        }
        return false;
    }

    //写一个通用的查询方法，将来可以传入任意类，并查询到这个类的对象，
    //把数据绑定后，返回对象
    //泛型决定返回值类型，反射用来获取对象
    public <T>T queryOne(Class<T> tClass,String sql,Object ...objects){
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            conn = JDBCUtils.getConnection();
            pstmt = conn.prepareStatement(sql);
            JDBCUtils.setValue(pstmt,objects);
            rs = pstmt.executeQuery();
            
            //这个ResultSetMetaData对象中，可以获取到字段的名称和类型
            ResultSetMetaData metaData = rs.getMetaData();

            T bean=null;
            while (rs.next()){
                //通过反射创建实体类对象
                bean = tClass.newInstance();
                //根据列的数量来循环绑定值
                for (int i = 0; i < metaData.getColumnCount(); i++) {
                    //BeanUtils工具类，根据实体类对象、列名、rs中获取到的每列的值
                    //去动态绑定这个实体对象
                    BeanUtils.setProperty(bean,metaData.getColumnLabel(i+1),
                                          rs.getObject(i+1));
                }
            }
            return bean;
        } catch (Exception e) {
            e.printStackTrace();
        }

        JDBCUtils.close(rs,conn,pstmt);
        return null;
    }

    //查询表中全部数据的方法
    public <T> List<T> queryAll(Class<T> tClass, String sql, Object ...objects){
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            conn = JDBCUtils.getConnection();
            pstmt = conn.prepareStatement(sql);
            JDBCUtils.setValue(pstmt,objects);
            rs = pstmt.executeQuery();

            ArrayList<T> list = new ArrayList<>();
            //这个ResultSetMetaData对象中，可以获取到字段的名称和类型
            ResultSetMetaData metaData = rs.getMetaData();
        
            T bean=null;
            while (rs.next()){
                bean = tClass.newInstance();
                //根据列的数量来循环绑定值
                for (int i = 0; i < metaData.getColumnCount(); i++) {
                    //BeanUtils工具类，根据实体类对象、列名、rs中获取到的每列的值
                    //去动态绑定这个实体对象

                    BeanUtils.setProperty(bean,metaData.getColumnLabel(i+1),
                                          rs.getObject(i+1));
                }
                list.add(bean);
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        }

        JDBCUtils.close(rs,conn,pstmt);
        return null;
    }

}

package com.day19.jdbc5;

import com.day19.jdbc2prac.Student;

import java.util.ArrayList;

public class JDBCDemo10 {
    public static void main(String[] args) {
        BaseDao baseDao = new BaseDao();
        //查询单行数据
        String sql = "select * from student where sid = ?";
        Student s1 = baseDao.queryOne(Student.class, sql, 10001);
        System.out.println(s1);

        //查询多行数据
        String sql1 = "select * from student";
        List<Student> students = baseDao.queryAll(Student.class, sql1);
        System.out.println(students);

    }
}