Java JDBC

一、介绍

　　JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用java语言编写的类和接口组成。
　　有了JDBC，向各种关系数据发送SQL语句就是一件很容易的事。换言之，有了JDBC API，就不必为访问Sybase数据库专门写一个程序，为访问Oracle数据库又专门写一个程序，或为访问Informix数据库又编写另一个程序等等，程序员只需用JDBC API写一个程序就够了，它可向相应数据库发送SQL调用。

二、JDBC 的开发步骤

1）注册驱动：主要告诉 JVM 我们的程序将要使用哪一种数据库
2）获取连接：使用 JDBC 中的类，获得数据库的连接对象 Connection
3）获得语句执行平台：通过 Connection 可以获取执行者对象，Statement、PreparedStatement.
4）执行 SQL 语句：使用执行者对象，向数据库中执行 SQL 语句，然后可以得到对应的接口，有单个结果，也可能有结果集 ResultSet。
5）处理结果
6）释放对象：关闭顺序：rs -> stmt 、ptmt -> conn

演示代码：

public static void main(String[] args) {
        // 提示用户输入用户名和密码
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入用户名:");
        String name = sc.nextLine();

        System.out.println("请输入密码:");
        String pwd = sc.nextLine();

        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {

            // 1. 加载驱动
            Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");

            // 2. 获取连接
            conn = DriverManager.getConnection("jdbc:sqlserver://localhost:1433;databaseName=testdb", "sa", "123456");

            // 3. 利用conn，创建一个可以执行SQL语句的对象
            String sql = "select * from userinfo where uname=? and upwd=?";
            pstmt = conn.prepareStatement(sql);

            // 执行Sql语句之前，先给“？”号赋值。
            pstmt.setString(1, name);
            pstmt.setString(2, pwd);

            // 执行查询，不需要再给SQL语句
            rs = pstmt.executeQuery();

            if (rs.next()) {// 有了
                System.out.println("登陆成功！");
            } else {
                System.out.println("登陆失败！");
            }
            while(rs.next()){//指针下移
                int uid = rs.getInt("uid");
                String uname = rs.getString("uname");
                String upwd = rs.getString("upwd");
                float umoney = rs.getFloat("umoney");
                
                System.out.println(uid+"	"+uname+"	"+upwd+"	"+umoney);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                rs.close();
                pstmt.close();
                conn.close();
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
    }

四、抽取 JDBC 工具类

 　　在实际开发中，我们经常会碰到一些重复的代码，比如在获取某些资源的时候，解析某些数据的时候，都是需要重复去做一些相似的动作，这个时候很有必要抽取这些重复的代码成一个工具类，方面后面的使用。

　　很明显，我们每次操作数据库的，都需要连接数据库和关闭数据库，所有我们可以把数据库的连接和关闭都给抽取出来，作为公共部分。
新建一个 JDBCUtil.java 类。

public class JDBCUtils {
    // 重构：一旦发现代码用起来不是很爽的时候，一直有重复动作，必须想把饭抽取出来一个新的
    public JDBCUtils() {
    }
 
    public static Connection conn;
 
    // 静态块：在类初始化之后，会加载一次
    // 一般情况，我们会将一些常用的数据，放在静态块中进行加载
    // 加载完成之后，后面如果想要用的话，直接就可以用
    // 优点是，只会创建一次，不会重复创建良妃性能
    static {
        try {
            // 1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 2.获取连接：数据库地址、用户名、密码 Connection
            String url = "jdbc:mysql://localhost:3306/test";
            String user = "root";
            String password = "root";
            conn = DriverManager.getConnection(url, user, password);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 获取 Connection 对象
     */
    public static Connection getConnection() {
        return conn;
    }
 
    /**
     * 释放资源
     */
    public static void close(Statement stmt, Connection conn) {
        // 思路：在关闭资源之前，先要判断，到底有没有用到这个资源
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
 
    public static void close(ResultSet rs, Statement stmt, Connection conn) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
 
}

改写上面的类：（可以发现抽出公共部分之后，以后每次写的代码都会大大减少）

@Test
public void fun2() throws Exception {
    // 1.获取数据库连接
    Connection conn = JDBCUtils.getConnection();
 
    // 2.准备 SQL 语句
    String sql = "select * from product";
    
    // 3.获取执行者对象
    Statement stmt = conn.createStatement();
 
    // 4.执行 SQL 语句
    ResultSet rs = stmt.executeQuery(sql);
 
    // 5.处理结果
    while (rs.next()) {
        int idStr = rs.getInt("id");
        String nameStr = rs.getString("name");
        double priceStr = rs.getDouble("price");
        String markStr = rs.getString("mark");
        System.out.println(idStr + "--" + nameStr + "--" + markStr);
    }
 
    // 6.关闭资源
    JDBCUtils.close(rs, stmt, conn);
}

五、SQL 的注入

SELECT * FROM product WHERE NAME = '伊利牛奶' AND price= 3.5
使用 PreparedStatement 对象，可以预防SQL 注入和提高 SQL 的预编译。

@Test
public void fun3() throws Exception {
    // 1.获取数据库连接
    Connection conn = JDBCUtils.getConnection();
 
    // 2. 获取执行者对象
    // 如果使用 Statement 的话，则有可能会被 SQL 注入破坏
    // Statement stmt = conn.createStatement();
    // 推荐使用 PreparedStatement，它是 Statement 的子类，
    // 可以预防 SQL 注入，而且还可以把我们的 SQL 语句进行预初始化
 
    // 3. 准备 SQL 语句
    String sql = "select * from product where NAME = ? and price = ?";
    PreparedStatement ptmt = conn.prepareStatement(sql);
    // 这里的 1和2 表示的 where 后面的第n个属性
    ptmt.setString(1, "伊利牛奶");
    ptmt.setDouble(2, 3.5);
 
    // 4. 执行 SQL 语句
    ResultSet rs = ptmt.executeQuery();
 
    // 5. 处理结果
    while (rs.next()) {
        int idStr = rs.getInt("id");
        String nameStr = rs.getString("NAME");
        String passStr = rs.getString("price");
        System.out.println(idStr + "--" + nameStr + "--" + passStr);
    }
 
    // 6. 关闭资源
    JDBCUtils.close(rs, ptmt, conn);
}

六、PreparedStatement 的简单使用

主要演示了“修改”功能，至于其他的功能，有时间再自己实践下。

@Test
public void fun4() throws Exception {
 
    // 1.获取数据库连接
    Connection conn = JDBCUtils.getConnection();
 
    // 2. 准备 SQL 语句
    String sql = "update product set name = ?, price = ? where id = ?";
 
    PreparedStatement ptmt = conn.prepareStatement(sql);
 
    ptmt.setString(1, "奥特曼");
    ptmt.setString(2, "49.8");
    ptmt.setInt(3, 1);
 
    // 3. 执行 SQL 语句
    // 此处的返回值是 int 类型，如果有一条数据发生改变的话，则返回 1
    int i = ptmt.executeUpdate();
 
    // 4. 处理结果
    if (i == 1) {
        System.out.println("恭喜你，修改成功了...");
    }
 
    // 6. 关闭资源
    JDBCUtils.close(ptmt, conn);
}

 七、封装数据

如果要封装数据的话，则需要新建一个对应的 JavaBean 类
如果要提供一个 JavaBean 的话，需要满足三个条件：、
1）实现序列化接口
2）提供字段
3）提供字段对应的 get 和 set 方法
注意： JavaBean 的命名，最好和对应的数据表一致。主要为了更好体现类与表的映射关系。

public class Product {
    private int id;
    private String NAME;
    private double price;
    private String mark;
    
    public Product(int id, String nAME, double price, String mark) {
        super();
        this.id = id;
        NAME = nAME;
        this.price = price;
        this.mark = mark;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getNAME() {
        return NAME;
    }
    public void setNAME(String nAME) {
        NAME = nAME;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public String getMark() {
        return mark;
    }
    public void setMark(String mark) {
        this.mark = mark;
    }
}

查询所有数据：

/**
 * 封装数据
 * @throws Exception
 */
@Test
public void fun5() throws Exception {
    
    // 1. 获取数据库连接
    Connection conn = JDBCUtils.getConnection();
    
    // 2. 准备 SQL 语句
    String sql = "select * from product";
    
    PreparedStatement ptmt = conn.prepareStatement(sql);
    
    // 3. 执行 SQL 语句
    ResultSet rs = ptmt.executeQuery();
    
    // 4. 创建一个集合，用来保存查询出来的对象实例
    // 菱形语法，在泛型中，用来指定集合中存储的内容类型
    List<Product> proList = new ArrayList<Product>();
    
    // 5. 处理结果
    while (rs.next()){
        // 5.1 获取目标对象的实例，可以通过有参构造器
        int id = rs.getInt("id");
        String name = rs.getString("name");
        double price = rs.getDouble("price");
        String mark = rs.getString("mark");
        Product pro = new Product(id, name, price, mark);
        proList.add(pro);
    }
    
    // 5.2 查看保存数据的集合
    for (Product pro : proList) {
        System.out.println("商品的名字是：" + pro.getNAME());
    }
    
    // 6. 关闭资源
    JDBCUtils.close(rs, ptmt, conn);
}

八、Properties 配置文件

　　在实际开发中，我们一般情况下，会把配置相关的信息，放在 xx.properties 中保存，并且使用。因为，以后代码有可能写的非常复杂，像一些不经常改动的东西，都建议抽取出来保存到配置文件中。当我们要用的时候，直接从配置文件中获取使用。当我们需要修改的时候，显示找到文件，然后就可以直接修改即可。很方便的。
　　一般情况下，都是写死的内容，不会经常改动的。

8.1 编写 jdbc.properties 文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test
user=root
password=root

8.2 重写 JDBCUtils.java

public class JDBCUtils2 {
    public JDBCUtils2() {
    }
 
    public static Connection conn;
 
    private static String driver;
    private static String url;
    private static String user;
    private static String password;
 
    static {
        try {
            // 0.加载配置文件，获取对应的信息
            readConfig();
            // 1.注册驱动
            Class.forName(driver);
            // 2.获取连接：数据库地址、用户名、密码 Connection
            conn = DriverManager.getConnection(url, user, password);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 用来加载配置文件
     * 
     * source folder 在部署之后，他的路径就是 bin 路径，也就是 classes 类资源路径
     * 
     * @throws IOException
     */
    public static void readConfig() throws IOException {
        // 1.找到文件，并且加载文件
        InputStream is = JDBCUtils2.class.getClassLoader().getResourceAsStream("jdbc.properties");
        System.out.println("is 的值：" + is);
 
        // 2.从文件中获取数据
        Properties pro = new Properties();
 
        // 3.通过输入流加载数据
        pro.load(is);
 
        // 4.当获取到数据之后，应该把数据赋值给上面的变量
        driver = pro.getProperty("driver");
        url = pro.getProperty("url");
        user = pro.getProperty("user");
        password = pro.getProperty("password");
    }
 
    /**
     * 获取 Connection 对象
     */
    public static Connection getConnection() {
        return conn;
    }
 
    /**
     * 释放资源
     */
    public static void close(Statement stmt, Connection conn) {
        // 思路：在关闭资源之前，先要判断，到底有没有用到这个资源
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
 
    public static void close(ResultSet rs, Statement stmt, Connection conn) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

九、整篇博客用到的 Java 代码打包地址：

https://github.com/yyzheng1729/JDBC