[Mysql]JDBC篇, DAO, DBUtils, 批处理, 数据库池

public interface JdbcInterface {
    // 连接
    Object getConnetcion();
    // crud
    void crud();
    // 关闭连接
    void close();
}
class MysqlToJdbc implements JdbcInterface {
    @Override
    public Object getConnection() {
        System.out.println("得到Mysql的连接");
        return null;
    }
    @Override
    public void crud() {
        System.out.println("完成了Mysql的crud功能");
    }
    @Override
    public void close() [
        Syste.out.println("完成了Mysql的关闭功能");
    }
}
class OracleToJdbc implements JdbcInterface {
    @Override
    public Object getConnection() {
        System.out.println("得到Oracle的连接");
        return null;
    }
    @Override
    public void crud() {
        System.out.println("完成了Oracle的crud功能");
    }
    @Override
    public void close() [
        Syste.out.println("完成了Oracle的关闭功能");
    }
}
public class Test {
    public static void main(String[] args) {
        JdbcInterface jdbc = new MysqlToJdbc();
        jdbc.getConnection();
        jdbc.crud();
        jdbc.close();
        System.out.println("+++++++++++++++++++++++++++++++");
        jdbc = new OracleToJdbc();
        jdbc.getConnection();
        jdbc.crud();
        jdbc.close();
    }
}

// 注册驱动(老版写法认识即可, 后面介绍新版写法)
com.mysql.cj.jdbc.Driver driver = new com.mysql.cj.jdbc.Driver();
// 类加载(在新版中, 可不写, 但是为了代码可读性和安全性尽量写上)
Class.forName("com.mysql.cj.jdbc.Driver");
// 注意上面参数是一个字符串, 字符串可以写到xxx.properties文件中
// 获取Mysql的连接
String url = "jdbc:mysql://localhost:3306/your_database_name";
Properties properties = new Properties();
properties.setProperty("user", "XXXX");
properties.setProperty("password", "XXXX");
Connection connect = driver.connect(url, properties);
// 获取数据库操作对象
Statement statement = connect.createStatement();
// 执行SQL
String sql = "insert into XXXX values('XXXX', 'XXXX', XXXX)";
int rows = statement.executeUpdate(sql); // 返回值是:影响数据库中的记录条数
// 处理查询结果集(有上一步才有这一步)
// 对ResultSet的处理
// 释放资源
statement.close();
connect.close();

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
Properties properties = new Properties();
// 引入了配置文件
properties.load(new FileInputStream("src\\mysql.properties"));
​
String url = properties.getProperty("url");
String user = properties.getProperty("user");
String password = properties.getProperty("password");
String driver = properties.getProperty("driver");
​
// 加载驱动可以不写但建议写一下
Class.forName(driver);
​
// 得到连接
Connection connection = DriverManager.getConnection(url, user, password);
// 创建Statement对象并执行SQL查询：
Statement statement = connection.createStatement();
String sql = "SELECT * FROM mytable";
ResultSet resultSet = statement.executeQuery(sql);
// 处理查询结果集
while (resultSet.next()) {
    int id = resultSet.getInt("id");
    String name = resultSet.getString("name");
    // 其他字段...
    // 处理数据
    System.out.println("ID: " + id + ", Name: " + name);
}
// 释放资源
java
resultSet.close();
statement.close();
connection.close();

public class JDBCUtils {
    //定义相关的属性(4个), 因为只需要一份，因此，我们做出static
    private static String user; //用户名
    private static String password; //密码
    private static String url; //url
    private static String driver; //驱动名
    //在static代码块去初始化
    static {
        try {
            Properties properties = new Properties();
            properties.load(new FileInputStream("src\\mysql.properties"));
            //读取相关的属性值
            user = properties.getProperty("user");
            password = properties.getProperty("password");
            url = properties.getProperty("url");
            driver = properties.getProperty("driver");
            Class.forName(driver);
        } catch (Exception e) {
            //在实际开发中，我们可以这样处理
            //1. 将编译异常转成 运行异常
            //2. 调用者，可以选择捕获该异常，也可以选择默认处理该异常，比较方便.
            throw new RuntimeException(e);
        }
    }
    //连接数据库, 返回Connection
    public static Connection getConnection() {
        try {
            return DriverManager.getConnection(url, user, password);
        } catch (SQLException e) {
            //1. 将编译异常转成 运行异常
            //2. 调用者，可以选择捕获该异常，也可以选择默认处理该异常，比较方便.
            throw new RuntimeException(e);
        }
    }
    //关闭相关资源
    /*
        1. ResultSet 结果集
        2. Statement 或者 PreparedStatement
        3. Connection
        4. 如果需要关闭资源，就传入对象，否则传入 null
     */
    public static void close(ResultSet set, Statement statement, Connection connection) {
        //判断是否为null
        try {
            if (set != null) {
                set.close();
            }
            if (statement != null) {
                statement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException e) {
            //将编译异常转成运行异常抛出
            throw new RuntimeException(e);
        }
    }
}

Connection conn = DBUtil.getConnection();
​
String sql = "select ename, job, sal from emp where job = ? for update";
ps = conn.prepareStatement(sql);
ps.setString(1, "MANAGER");
re = ps.executeQuery();
while(re.next()) {                     
 System.out.println(rs.getString("ename")+","+rs.getString("jon")+","+rs.getDouble("sal"));
}
​
conn.setAutoCommit(false);
comm.commit();

actors.add(new Actor(id, name, sex, borndate, phone));

代码解读
//(1) query 方法就是执行 sql 语句，得到 resultset ---封装到 --> ArrayList 集合中
//(2) 返回集合
// 以下是参数解释
//(3) connection: 连接
//(4) sql : 执行的 sql 语句
//(5) new BeanListHandler<>(Actor.class): 在将 resultset -> Actor 对象 -> 封装到 ArrayList
// 底层使用反射机制 去获取 Actor 类的属性，然后进行封装
//(6) 1 就是给 sql 语句中的? 赋值，可以有多个值，因为是可变参数 Object... params
//(7) 底层得到的 resultset ,会在 query 关闭, 关闭 PreparedStatment
//以上底层代码你都看过, 不记得就去再看一遍
//     分析 queryRunner.query 方法:
public <T> T query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) throws SQLException {
    PreparedStatement stmt = null;//定义 PreparedStatement
    ResultSet rs = null;//接收返回的 ResultSet
    Object result = null;//返回 ArrayList
    try {
        stmt = this.prepareStatement(conn, sql);//创建 PreparedStatement
        this.fillStatement(stmt, params);//对 sql 进行 ? 赋值
        rs = this.wrap(stmt.executeQuery());//执行 sql,返回 resultset
        result = rsh.handle(rs);//返回的 resultset --> arrayList[result] [使用到反射，对传入 class 对象处理]
    } catch (SQLException var33) {
        this.rethrow(var33, sql, params);
    } finally {
        try {
            this.close(rs);        //关闭 resultset
        } finally {
            this.close((Statement) stmt);        //关闭 preparedstatement 对象
        }
    }
    return result;
}