JDBC 概述

@Test

    public void test () throws SQLException {

        // 方式一

        // 注册驱动

        Driver driver = new Driver();

        // 编写连接数据库的 url

        String url = "jdbc:mysql://localhost:3306/Demo";

        // 创建 Properties 配置文件类

        Properties properties = new Properties();

        // 设置配置文件信息

        properties.setProperty("user","root");

        properties.setProperty("password","dkx");

        // 创建 Connection 通过 Driver 对象调用 connect 添加 url 跟数据库的 user 和 password 连接数据库

        Connection connection = driver.connect(url,properties);

        // 编写一条 sql 语句

        String sql = "update `Demo` set name = '刘桑' where id = 28";

        // 将 sql 语句发送给 MySQL 数据库并返回其对象

        Statement statement = connection.createStatement();

        // 通过返回对象调用 executeUpdate 返回一个 int 类型的值

        int i = statement.executeUpdate(sql);

        // 判断这个值如果大于 1 则说明执行成功，否则失败

        System.out.println(i > 0 ? "连接成功" : "连接失败");

        // 关闭源，释放资源

        connection.close();

        statement.close();

    }

@Test

    public void testone () throws ClassNotFoundException, InstantiationException, IllegalAccessException, SQLException {

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

        Driver driver = (Driver)cls.newInstance();

        String url = "jdbc:mysql://localhost:3306/Demo";

        Properties properties = new Properties();

        properties.setProperty("user","root");

        properties.setProperty("password","dkx");

        Connection connection = driver.connect(url,properties);

        System.out.println("Driver:"+connection);

    }

@Test

    public void testtwo () throws ClassNotFoundException, InstantiationException, IllegalAccessException, SQLException {

        //Java 反射机制实例化 Driver 类

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

        // 向下转型

        Driver driver = (Driver)cls.newInstance();

        String url = "jdbc:mysql://localhost:3306/Demo";

        String user = "root";

        String password = "dkx";

        // 使用 DriverManager 注册给定的驱动程序，调用 resterDriver 使其为自身

        DriverManager.registerDriver(driver);

        // 通过 Connection 提供 url,user,password 连接数据库

        Connection connection = DriverManager.getConnection(url,user,password);

        System.out.println("Driver:"+connection);

    }

@Test

    public void testsan () throws ClassNotFoundException, SQLException {

        // 通过反射机制加载 Driver 类

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

        String url = "jdbc:mysql://localhost:3306/Demo";

        String user = "root";

        String password = "dkx";

        // 通过 DriverManager 调用 getConnection 方法传入数据库的 url,user,password 连接到数据库

        Connection connection = DriverManager.getConnection(url,user,password);

        System.out.println(connection);

    }

@Test

    public void testsi () throws ClassNotFoundException, IOException, SQLException {

        // 实例化配置文件对象

        Properties properties = new Properties();

        // 向配置文件中添加信息

        properties.setProperty("driver","com.mysql.jdbc.Driver");

        properties.setProperty("url","jdbc:mysql://localhost:3306/Demo");

        properties.setProperty("user","root");

        properties.setProperty("password","dkx");

        // 通过调用 store 方法新建输出流将配置文件写出到指定位置中，第二个参数为注释

        properties.store(new FileOutputStream("src//re.Properties"),"LinuxProperties");

        // 获取配置文件中的信息

        String driver = properties.getProperty("driver");

        String url = properties.getProperty("url");

        String password = properties.getProperty("password");

        String user = properties.getProperty("user");

        // 通过反射机制加载 Driver 类，虽然自动加载但是还是建议写上

        Class.forName(driver);

        // 实例化 Connection 类通过 DriverManager 调用 getConnection 方法传入连接数据库的数据

        Connection connection = DriverManager.getConnection(url,user,password);

        // 编写一条 SQL 语句

        String sql = "select * from Demo";

        // 向数据库发送 SQL 语句，并返回其对象

        Statement statement = connection.createStatement();

        // 通过 Statement 对象调用 executeQuery 执行 SQL DQL 语句并返回给 ResultSet 对象

        ResultSet resultset = statement.executeQuery(sql);

        // 因为不知道循环多少次，使用 while 循环来处理 resultset.next () 每次执行指向下一个

        // 当没有可查询列后返回 false 即结束循环

        while(resultset.next()){

            //id 在第一列中为 int 类型

            int id = resultset.getInt(1);

            String name = resultset.getString(2);

            String sex = resultset.getString(3);

            Date date = resultset.getDate(4);

            String dian = resultset.getString(5);

            System.out.println(id+"\t"+name+"\t"+sex+"\t"+date+"\t"+dian);

        }

        // 关闭源，释放资源

        connection.close();

        statement.close();

    }

Scanner sc = new Scanner(System.in);

        System.out.println("请输入用户名与密码");

        System.out.print("请输入用户名:");

        String zhang = sc.nextLine();

        System.out.print("请输入密码:");

        String mima = sc.nextLine();

        Properties properties = new Properties();

        properties.load(new FileInputStream("src//re.Properties"));

        String driver = properties.getProperty("driver");

        String url = properties.getProperty("url");

        String user = properties.getProperty("user");

        String password = properties.getProperty("password");

        Class.forName(driver);

        String sql = "select * from admin where name = '"+zhang+"'and pwd = '"+mima+"'";

        Connection connection = DriverManager.getConnection(url,user,password);

        Statement statement = connection.createStatement();

        ResultSet resultset = statement.executeQuery(sql);

        if(resultset.next()){

            System.out.println("登入成功");

        }else{

            System.out.println("登入失败");

        }

        connection.close();

        statement.close();

package com.dkx.xer;

import java.io.FileInputStream;

import java.io.IOException;

import java.sql.*;

import java.util.Properties;

import java.util.Scanner;

@SuppressWarnings({"all"})

public class My_Connection {

    public static void main (String[]args) throws IOException, ClassNotFoundException, SQLException {

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入内容");

        System.out.print("请输入用户名:");

        String admin_name = sc.nextLine();

        System.out.print("请输入密码:");

        String admin_neir = sc.nextLine();

        Properties properties = new Properties();

        properties.load(new FileInputStream("src//re.Properties"));

        String driver = properties.getProperty("driver");

        String url = properties.getProperty("url");

        String user = properties.getProperty("user");

        String password = properties.getProperty("password");

        Class.forName(driver);

        //Connection 连接数据库

        Connection connection = DriverManager.getConnection(url,user,password);

        // 得到 PreparedStatement

        //1. 编写 SQL 语句 ？ 号相当于是一个占位符

        String sql = "select * from admin where name = ? and pwd = ?";

        //2.PreparedStatement 对象实现了 PreparedStatement 接口的实现类对象

        PreparedStatement preparedstatement = connection.prepareStatement(sql);

        //3. 通过 PreparedStatement 给？赋值，进行了预处理

        preparedstatement.setString(1,admin_name);

        preparedstatement.setString(2,admin_neir);

        //4. 执行 select   DQL 语句使用 executeQuery ();

        // 如果执行的是 DML (update,insert,delete) 则使用 executeUpdate ();

        // 这里的参数中不能给 sql, 这里赋值 sql 对象的话，相当于将带有？号的语句给了这个对象就会发生报错

        ResultSet resultset = preparedstatement.executeQuery();

        if(resultset.next()){

            System.out.println("登入成功");

        }else{

            System.out.println("抱歉，登入失败！");

        }

        resultset.close();

        preparedstatement.close();

        connection.close();

    }

}

package com.dkx.jdbcutils;

import java.io.FileInputStream;

import java.sql.*;

import java.util.Properties;

public class Jdbcutils {

    // 定义相关的属性（4 个）因为只需要一份，因此，为 static

    private static String driver;

    private static String url;

    private static String user;

    private static String password;

    static {

        try{

        Properties properties = new Properties();

        properties.load(new FileInputStream("src//re.Properties"));

        // 读取相关的属性

             driver = properties.getProperty("driver");

             url = properties.getProperty("url");

             user = properties.getProperty("user");

             password = properties.getProperty("password");

             // 注册驱动

             Class.forName("driver");

        }catch(Exception e){

            // 在实际开发中，可以将编译异常转成运行时异常

            // 调用者可以选择捕获该异常，也可以选择默认处理，比较方便

            throw new RuntimeException(e);

        }

    }

    // 连接数据库，返回 Connection

    public static Connection getConnection () {

        try{

            return DriverManager.getConnection(url,user,password);

        }catch(Exception e){

            throw new RuntimeException(e);

        }

    }

    // 关闭相关资源

    /*

    1.ResultSet 结果集

    2.Statement 或者 PreparedStatement

    3.Connection

    4. 如果需要关闭资源，就传入对象，否则传入 null

     */

    public static void close (ResultSet set, PreparedStatement preparestatement, Connection connection) {

        // 判断是否为 null

        try{

            if(set != null){

                set.close();

            }

            if(preparestatement != null){

                preparestatement.close();

            }

            if(connection != null){

                connection.close();

            }

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

    }

}

package com.dkx.jdbcutils;

import java.sql.Connection;

import java.sql.PreparedStatement;

public class Jdbcutils_use {

    public static void main(String[]args){

        // 实例化对象

        var ar = new Jdbcutils_use();

        // 对象调用方法执行操作数据库

        ar.test_connector();

    }

    public void test_connector () {

        //1. 得到连接

        Connection connection = null;

        //2. 编写一条 SQL 语句

        String sql = "insert into admin values (?,?)";

        //3. 创建 PreparedStatement 对象，扩大 PrearedStatement 的作用域

        PreparedStatement preparedstatement = null;

        try{

            connection = Jdbcutils.getConnection();

            preparedstatement = connection.prepareStatement(sql);

            // 给占位符进行赋值

            preparedstatement.setString(1,"张三");

            preparedstatement.setString(2,"123");

            int i = preparedstatement.executeUpdate();

            if(i > 0){

                System.out.println("添加成功~");

            }else{

                System.out.println("添加失败!");

            }

        }catch(Exception e){

            e.printStackTrace();

        }finally{

            // 关闭资源

            Jdbcutils.close(null,preparedstatement,connection);

        }

    }

}

package com.transaction;

import com.music.JDBCUtils;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.util.Scanner;

public class Salary_test {

    public static void main(String[]args) {

        var ar = new Salary_test();

        ar.test();

    }

    public void test () {

        Scanner sc = new Scanner(System.in);

        System.out.print("转账金额:");

        Double salary = sc.nextDouble();

        Scanner sc1 = new Scanner(System.in);

        System.out.print("转账者:");

        String name = sc1.nextLine();

        System.out.print("收账者:");

        String name1 = sc1.nextLine();

        Connection connection = null;

        PreparedStatement preparedstatement = null;

        String sql = "update `salary` set salary = salary - ? where name = ?";

        String sql1 = "update `salary` set salary = salary + ? where name = ?";

        try{

            connection = JDBCUtils.getConnection();// 在默认情况下，Connection 是默认自动提交的

            // 将 connection 设置为不自动提交事务

            connection.setAutoCommit(false);// 开启了事务

            preparedstatement = connection.prepareStatement(sql);

            preparedstatement.setDouble(1,salary);

            preparedstatement.setString(2,name);

            preparedstatement.executeUpdate();

            // 程序报错...

            System.out.println(1/0);

            preparedstatement = connection.prepareStatement(sql1);

            preparedstatement.setDouble(1,salary);

            preparedstatement.setString(2,name1);

            int i = preparedstatement.executeUpdate();

            connection.commit();

            System.out.println(i > 0? "转账成功" : "转账失败");

        }catch(Exception e){

            // 这里我们可以进行回滚，即撤销执行的 SQL 操作

            // 默认回滚到事务开始的状态

            System.out.println("执行操作有错误,事务已经回滚");

            try{

                connection.rollback();

            }catch(Exception er){

                er.printStackTrace();

            }

            e.printStackTrace();

        }finally{

            JDBCUtils.close(connection,preparedstatement,null);

        }

    }

}

public void test () {

        Connection connection = null;

        PreparedStatement preparedstatement = null;

        String sql = "insert into `salary` values (?,?)";

        long start = System.currentTimeMillis();

        try{

            connection = JDBCUtils.getConnection();

            preparedstatement = connection.prepareStatement(sql);

            System.out.println("添加中...");

            for(int i = 0;i < 5000;i ++){

                preparedstatement.setString(1,"张三");

                preparedstatement.setDouble(2,1+i);

                preparedstatement.executeUpdate();

            }

            System.out.println("添加完毕");

            long pause = System.currentTimeMillis();

            System.out.println("执行用时:"+(pause - start));// 执行用时：8423

        }catch(Exception e){

            e.printStackTrace();

        }finally{

            JDBCUtils.close(connection,preparedstatement,null);

        }

    }

    public void test1 () {

        Connection connection = null;

        PreparedStatement preparedstatement = null;

        String sql = "insert into `salary` values (?,?)";

        long start = System.currentTimeMillis();

        try{

            connection = JDBCUtils.getConnection();

            preparedstatement = connection.prepareStatement(sql);

            System.out.println("添加中...");

            for(int i = 0;i < 5000;i ++){

                preparedstatement.setString(1,"张三");

                preparedstatement.setDouble(2,1+i);

                preparedstatement.addBatch();

                if(i == 4999){

                    preparedstatement.executeBatch();

                    preparedstatement.clearBatch();

                }

            }

            System.out.println("添加完毕");

            long pause = System.currentTimeMillis();

            System.out.println("执行用时:"+(pause - start));// 执行用时：954

        }catch(Exception e){

            e.printStackTrace();

        }

    }

package com.testconnection;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import java.beans.PropertyVetoException;

import java.io.FileInputStream;

import java.io.IOException;

import java.sql.Connection;

import java.sql.SQLException;

import java.util.Properties;

@SuppressWarnings({"all"})

public class C3P0_test {

    public static void main(String[]args) throws PropertyVetoException, SQLException, IOException {

        // 方式 1: 相关参数，在程序中指定 user,url,password 等

        ComboPooledDataSource combopooleddatasource = new ComboPooledDataSource();

        // 通过配置文件 re.Properties 获取相关连接的信息

        Properties properties = new Properties();

        properties.load(new FileInputStream("src//re.Properties"));

        // 读取相关的属性值

        String driver = properties.getProperty("driver");

        String url = properties.getProperty("url");

        String user = properties.getProperty("user");

        String password = properties.getProperty("password");

        // 给数据源 ComboPooledDataSource 设置相关参数

        // 注意：连接管理是由 ComboPooledDataSource 来管理

        combopooleddatasource.setDriverClass(driver);

        combopooleddatasource.setJdbcUrl(url);

        combopooleddatasource.setUser(user);

        combopooleddatasource.setPassword(password);

        // 设置初始化连接数

        combopooleddatasource.setInitialPoolSize(10);

        // 设置最大连接数

        combopooleddatasource.setMaxPoolSize(50);

        // 测试连接池的效率   测试对 MySQL 操作 5000 次

        System.out.println("连接成功...");

        long start = System.currentTimeMillis();

        for(int i = 0;i < 5000;i++){

            // 这个方法就是从 DataSource 接口实现

            Connection connection = combopooleddatasource.getConnection();

            connection.close();

        }

        long end = System.currentTimeMillis();

        //C3P0 5000 次操作 执行耗时：1002

        System.out.println("C3P0 5000 次操作 执行耗时:"+(end - start));

    }

}

@Test

    public void test () throws SQLException {

        // 创建 ComboPooledDataSource 对象 构造器中赋值连接的 named-config : Name

        ComboPooledDataSource combopooleddatasource = new ComboPooledDataSource("dkx_123");

        System.out.println("连接成功");

        long start = System.currentTimeMillis();

        for(int i = 0;i < 5000;i++){

            // 通过 ComboPooledDataSource 对象调用 getConnection 进行连接数据库

            Connection connection = combopooleddatasource.getConnection();

            // 关闭数据库连接，释放资源

            connection.close();

        }

        long end = System.currentTimeMillis();

        // 执行耗时：966

        System.out.println("执行耗时:"+(end - start));

    }

public class JdbcUtils {

    //c3p0 数据库连接池对象属性

    private static final ComboPooledDataSource ds = new ComboPooledDataSource();

    // 获取连接

    public static Connection getConnection() {

        try {

            return ds.getConnection();

        } catch (SQLException e) {

            throw new RuntimeException(e);

        }

    }

    // 释放资源

    public static void release(AutoCloseable... ios) {

        for (AutoCloseable io : ios) {

            if (io != null) {

                try {

                    io.close();

                } catch (Exception e) {

                    throw new RuntimeException(e);

                }

            }

        }

    }

    // 提交事务并释放资源

    public static void commitAndClose(Connection conn) {

        if (conn != null) {

            try {

                // 提交事务

                conn.commit();

                // 释放资源

                conn.close();

            } catch (SQLException e) {

                throw new RuntimeException(e);

            }

        }

    }

    // 回滚事务并释放资源

    public static void rollbackAndClose(Connection conn) {

        if (conn != null) {

            try {

                // 回滚事务

                conn.rollback();

                // 释放资源

                conn.close();

            } catch (SQLException e) {

                throw new RuntimeException(e);

            }

        }

    }

}

public class AccountDao {

    // 转出

    public void out(String outUser, int money) throws SQLException {

        String sql = "update account set money = money - ? where name = ?";

        Connection connection = JdbcUtils.getConnection();

        PreparedStatement pstm = connection.prepareStatement(sql);

        pstm.setInt(1, money);

        pstm.setString(2, outUser);

        pstm.executeUpdate();

        JdbcUtils.release(pstm, connection);

    }

    // 转入

    public void in(String inUser, int money) throws SQLException {

        String sql = "update account set money = money + ? where name = ?";

        Connection connection = JdbcUtils.getConnection();

        PreparedStatement pstm = connection.prepareStatement(sql);

        pstm.setInt(1, money);

        pstm.setString(2, inUser);

        pstm.executeUpdate();

        JdbcUtils.release(pstm, connection);

    }

}

public class AccountService {

    // 转账

    public boolean transfer(String outUser, String inUser, int money) {

        AccountDao ad = new AccountDao();

        try {

            // 转出

            ad.out(outUser, money);

            // 转入

            ad.in(inUser, money);

        } catch (SQLException e) {

            return false;

        }

        return true;

    }

}

public static void main(String[] args) {

   // 模拟数据：Jack 给 Rose 转账 100 元

   String outUser = "Jack";

   String inUser = "Rose";

   int money = 100;

   AccountService service = new AccountService();

   boolean result = service.transfer(outUser, inUser, money);

   if (result == false) {

      System.out.println("转账失败");

   } else {

      System.out.println("转账成功");

   }

}

package com.testconnection;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;

import java.io.FileInputStream;

import java.sql.Connection;

import java.util.Properties;

@SuppressWarnings({"all"})

public class Druid {

    public static void main(String[]args) throws Exception {

        //1. 加入 Druid.jar 包

        //2. 加入配置文件 druid.Propertis, 将该文件拷贝项目的 src 目录

        //3. 创建 Properties 对象，读取配置文件

        Properties properties = new Properties();

        properties.load(new FileInputStream("src//druid.Properties"));

        //4. 创建一个指定参数的数据库连接池

        DataSource druiddatasourcefactory = DruidDataSourceFactory.createDataSource(properties);

        long start = System.currentTimeMillis();

        for(int i = 0;i < 5000000;i++){

            Connection connection = druiddatasourcefactory.getConnection();

            connection.close();

        }

        long end = System.currentTimeMillis();

        System.out.println("Druid执行耗时:"+(end - start));//Druid 执行耗时：3629

        System.out.println("执行结束!");

    }

}

package com.testconnection;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import java.sql.Connection;

import java.sql.SQLException;

@SuppressWarnings({"all"})

public class C3P0_test {

    public static void main(String[] args) throws SQLException {

        ComboPooledDataSource combopooleddatasource = new ComboPooledDataSource("dkx_123");

        System.out.println("连接成功");

        long start = System.currentTimeMillis();

        for (int i = 0; i < 5000000; i++) {

            // 通过 ComboPooledDataSource 对象调用 getConnection 进行连接数据库

            Connection connection = combopooleddatasource.getConnection();

            // 关闭数据库连接，释放资源

            connection.close();

        }

        long end = System.currentTimeMillis();

        // 执行耗时：966

        System.out.println("执行耗时:" + (end - start));// 执行耗时：17491

    }

}

package com.druidtest;

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.Properties;

public class JDBCUtils_Druid {

    //        定义获取数据库连接对象

    private static DataSource druid;

    static {

        try{

            // 创建 Properties 类读取配置文件信息

            Properties properties = new Properties();

            // 读取指定位置的配置文件

            InputStream in = JDBCUtils_Druid.class.getClassLoader().getResourceAsStream("druid.Properties");

            properties.load(in);

            // 将读取到配置文件的信息赋值到 DataSource 对象中

            druid = DruidDataSourceFactory.createDataSource(properties);

        }catch(Exception e){

            throw new RuntimeException();

        }

    }

    // 定义连接方法返回 Connection 连接

    public static Connection getConnection () {

        try{

            return druid.getConnection();

        }catch(Exception e){

            throw new RuntimeException(e);

        }

    }

    // 关闭连接，如果没有需要关闭则赋值为 null

    public static void close(Connection connection, ResultSet resultset, PreparedStatement set){

        try{

            if(connection != null){

                connection.close();

            }

            if(resultset != null){

                resultset.close();

            }

            if(set != null){

                set.close();

            }

        }catch(Exception e){

            throw new RuntimeException(e);

        }

    }

}

package com.druidtest;

import java.sql.Date;

//Actor 对象对应 Demo 表

public class Actor {//Javabean,DoJO,Domain 对象

    // 定义表中对应的字段信息

    private Integer id;

    private String name;

    private String sex;

    private Date borndata;

    private String phone;

    public Actor(){}// 一定要给一个无参构造器 [底层反射需要]

    // 创建一个有参构造用于获取字段的信息

    public Actor(Integer id, String name, String sex, Date borndata, String phone) {

        this.id = id;

        this.name = name;

        this.sex = sex;

        this.borndata = borndata;

        this.phone = phone;

    }

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public Date getBorndata() {

        return borndata;

    }

    public void setBorndata(Date borndata) {

        this.borndata = borndata;

    }

    public String getPhone() {

        return phone;

    }

    public void setPhone(String phone) {

        this.phone = phone;

    }

    // 重写 toString 返回字符串类型的对象信息

    @Override

    public String toString() {

        return "牛马：{" +

                "id=" + id +

                ", name='" + name + '\'' +

                ", sex='" + sex + '\'' +

                ", borndata=" + borndata +

                ", phone='" + phone + '\'' +

                '}';

    }

}

package com.druidtest;

import java.sql.Connection;

import java.sql.Date;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.util.LinkedList;

import java.util.List;

public class Druidtest_two {

    public static void main(String[]args){

        Connection connection = null;

        PreparedStatement statement = null;

        ResultSet resultset = null;

        // 创建一个 List 集合对象用于存储 ResultSet 获取到的字段的信息，解决 ResultSet 复用问题

        List<Actor> list = new LinkedList<>();

        // 编写一个 SQL 语句

        String sql = "select * from Demo";

        try{//try 将可能存在的异常抛出

            // 通过 JDBCUtils_Druid 类调用 getConnecion 方法获取连接返回 Connection 对象

            connection = JDBCUtils_Druid.getConnection();

            // 创建 PreparedStatement 对象将 SQL 语句发送给数据库

            statement = connection.prepareStatement(sql);

            // 通过 PreparedStatement 对象调用 executeQuery 来获取返回的结果

            resultset = statement.executeQuery();

            while(resultset.next()){//resultset 调用 next 每次执行指针向下移动获取下一个信息，如果没有信息则返回 false

                // 通过调用 getXxx 获取对应的数据类型

                Integer id = resultset.getInt("id");

                String name = resultset.getString("name");

                String sex = resultset.getString("sex");

                Date date = resultset.getDate("borndata");

                String phone = resultset.getString("phone");

                // 把得到的 ResultSet 的记录，封装到 Actor 对象，放入到 List 集合中

                list.add(new Actor(id,name,sex,date,phone));

            }

            for(Actor i:list){

                System.out.print(i);

                // 通过封装可以完成随意取数据的效果

//                System.out.print(i.getId());

//                System.out.print(i.getName());

                System.out.println();

            }

        }catch(Exception e){

            e.printStackTrace();

        }finally{

            // 调用 JDBCUtils_Druid 的 close 方法传入需要关闭的连接对象，关闭流释放资源

            JDBCUtils_Druid.close(connection,resultset,statement);

        }

    }

}

package com.druidtest.fuxi;

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;