1、操作和访问数据库

数据库连接被用于向数据库服务器发送命令和 SQL 语句，并接受数据库服务器返回的结果。其实一个数据库连接就是一个Socket连接。

在 java.sql 包中有 3 个接口分别定义了对数据库的调用的不同方式：

（1）Statement：用于执行静态 SQL 语句并返回它所生成结果的对象。

（2）PrepatedStatement：SQL 语句被预编译并存储在此对象中，可以使用此对象多次高效地执行该语句。

（3）CallableStatement：用于执行 SQL 存储过程。

2、使用Statement操作数据表的弊端

（1）通过调用 Connection 对象的 createStatement() 方法创建该对象。该对象用于执行静态的 SQL 语句，并且返回执行结果。

（2）Statement 接口中定义了下列方法用于执行 SQL 语句：

int excuteUpdate(String sql)：执行更新操作INSERT、UPDATE、DELETE
ResultSet executeQuery(String sql)：执行查询操作SELECT

（3）但是使用Statement操作数据表存在弊端：

• 问题1：存在拼串操作，繁琐；
• 问题2：存在SQL注入问题。

（4）SQL 注入是利用某些系统没有对用户输入的数据进行充分的检查，而在用户输入数据中注入非法的 SQL 语句段或命令（如：select name, password from user_info where name=‘a’ or 1 = ’ and password = ’ or ‘1’ = ‘1’） ，从而利用系统的 SQL 引擎完成恶意行为的做法。

（5）对于 Java 而言，要防范 SQL 注入，只要用 PreparedStatement(从Statement扩展而来) 取代 Statement 就可以了。

（6）代码演示：

jdbc.properties文件：

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

JdbcUtils.java类：

import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * @Description 操作数据库的工具类
 */
public class JdbcUtils {
    /**
     * 获取数据库的连接
     *
     * @return 数据库的连接实例
     * @throws Exception 异常信息
     */
    public static Connection getConnection() throws Exception {
        // 1.读取配置文件中的4个基本信息
        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");
        Properties pros = new Properties();
        pros.load(is);

        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        String url = pros.getProperty("url");
        String driverClass = pros.getProperty("driverClass");

        // 2.加载驱动
        Class.forName(driverClass);

        // 3.获取连接
        Connection conn = DriverManager.getConnection(url, user, password);
        return conn;
    }

    /**
     * 关闭连接和Statement
     */
    public static void closeResource(Connection conn, Statement ps) {
        try {
            if (ps != null) {
                ps.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 关闭连接、Statement和ResultSet
     */
    public static void closeResource(Connection conn, Statement ps, ResultSet rs) {
        try {
            if (ps != null) {
                ps.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if (rs != null) {
                rs.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

测试类StatementTest.java代码：

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Statement;
import java.util.Scanner;

/**
 * Statement测试
 *
 * @author Administrator
 */
public class StatementTest {
    /**
     * 使用Statement的弊端：需要拼写sql语句，并且存在SQL注入的问题
     */
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        System.out.print("用户名：");
        String name = scan.nextLine();
        System.out.print("密  码：");
        String password = scan.nextLine();

        String sql = "select name, password from user_info where name = '" + name + "' and password = '" + password + "'";
        User user = getData(sql, User.class);
        if (user != null) {
            System.out.println("登陆成功!");
        } else {
            System.out.println("用户名或密码错误！");
        }
    }

    /**
     * 使用Statement实现对数据表的查询操作
     *
     * @param sql   静态sql
     * @param clazz 对象类
     * @param <T>   返回值类型
     * @return 查询结果
     */
    public static <T> T getData(String sql, Class<T> clazz) {
        T t;
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        try {
            // 1.获取连接
            conn = JdbcUtils.getConnection();
            // 2.创建Statement实例
            st = conn.createStatement();
            // 3.执行SQL获取结果
            rs = st.executeQuery(sql);

            // 获取结果集的元数据
            ResultSetMetaData rsmd = rs.getMetaData();
            // 获取结果集的列数
            int columnCount = rsmd.getColumnCount();

            if (rs.next()) {
                t = clazz.newInstance();
                for (int i = 0; i < columnCount; i++) {
                    // 1. 获取列的别名
                    String columnName = rsmd.getColumnLabel(i + 1);

                    // 2. 根据列名获取对应数据表中的数据
                    Object columnVal = rs.getObject(columnName);

                    // 3. 将数据表中得到的数据，封装进对象
                    Field field = clazz.getDeclaredField(columnName);
                    field.setAccessible(true);
                    field.set(t, columnVal);
                }
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.closeResource(conn, st, rs);
        }
        return null;
    }
}

运行程序，在控制台输入如下信息：

用户名：a' or 1 = 
密  码： or '1' = '1

看程序执行结果却是登录成功：

查看数据库数据，并没有录入的用户及密码的数据，这就引发了SQL注入问题。

3、PreparedStatement的使用

3.1、PreparedStatement介绍

• 可以通过调用 Connection 对象的 preparedStatement(String sql) 方法获取 PreparedStatement 对象；

• PreparedStatement 接口是 Statement 的子接口，它表示一条预编译过的 SQL 语句；

• PreparedStatement 对象所代表的 SQL 语句中的参数用问号(?)来表示，调用 PreparedStatement 对象的 setXxx() 方法来设置这些参数。setXxx() 方法有两个参数，第一个参数是要设置的 SQL 语句中的参数的索引(从 1 开始)，第二个是设置的 SQL 语句中的参数的值。

3.2、PreparedStatement与Statement比较

• PreparedStatement代码的可读性和可维护性更强；

• PreparedStatement 能最大可能提高性能：

  • DBServer会对PreparedStatement语句提供性能优化。因为预编译语句有可能被重复调用，所以语句在被DBServer的编译器编译后的执行代码被缓存下来，那么下次调用时只要是相同的预编译语句就不需要编译，只要将参数直接传入编译过的语句执行代码中就会得到执行。
  • 在statement语句中，即使是相同操作但因为数据内容不一样，所以整个语句本身不能匹配，没有缓存语句的意义，事实是没有数据库会对普通语句编译后的执行代码缓存，这样每执行一次都要对传入的语句编译一次，效率低下。

• PreparedStatement 可以防止 SQL 注入。

3.3、使用PreparedStatement实现查询

测试类PreparedStatementTest.java代码：

import java.lang.reflect.Field;
import java.sql.*;
import java.util.Scanner;

/**
 * PreparedStatement测试
 */
public class PreparedStatementTest {
    /**
     * 使用PreparedStatement解决SQL注入的问题
     */
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        System.out.print("用户名：");
        String name = scan.nextLine();
        System.out.print("密  码：");
        String password = scan.nextLine();

        String sql = "select name, password from user_info where name = ? and password = ?";
        User user = getData(User.class, sql, name, password);
        if (user != null) {
            System.out.println("登陆成功!");
        } else {
            System.out.println("用户名或密码错误！");
        }
    }

    /**
     * 使用PreparedStatement实现对数据表的查询操作
     *
     * @param sql   静态sql
     * @param clazz 对象类
     * @param <T>   返回值类型
     * @return 查询结果
     */
    public static <T> T getData(Class<T> clazz, String sql, Object... args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            // 1.获取数据库连接
            conn = JdbcUtils.getConnection();
            // 2.预编译sql语句，得到PreparedStatement对象
            ps = conn.prepareStatement(sql);
            // 3.填充占位符
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }
            // 4.执行executeQuery(),得到结果集：ResultSet
            rs = ps.executeQuery();

            // 5.得到结果集的元数据：ResultSetMetaData
            ResultSetMetaData rsmd = rs.getMetaData();
            // 6.1通过ResultSetMetaData得到columnCount,columnLabel；通过ResultSet得到列值
            int columnCount = rsmd.getColumnCount();
            if (rs.next()) {
                T t = clazz.newInstance();
                for (int i = 0; i < columnCount; i++) {// 遍历每一个列
                    // 获取列值
                    Object columnVal = rs.getObject(i + 1);
                    // 获取列的别名:列的别名，使用类的属性名充当
                    String columnLabel = rsmd.getColumnLabel(i + 1);
                    // 6.2使用反射，给对象的相应属性赋值
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columnVal);
                }
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 7.关闭资源
            JdbcUtils.closeResource(conn, ps, rs);
        }
        return null;
    }
}

运行程序，在控制台输入如下信息（同使用Statement时同样的输入）：

用户名：a' or 1 = 
密  码： or '1' = '1

看程序执行结果是用户名或密码错误！：

输入正确的用户名和密码，则提示登录成功：

即使用PreparedStatement成功的解决了SQL注入问题。

3.4、使用PreparedStatement实现增、删、改

测试代码如下：

package com.jdbc.demo;

import org.junit.Test;

import java.lang.reflect.Field;
import java.sql.*;
import java.util.Scanner;

/**
 * PreparedStatement测试
 */
public class PreparedStatementTest {
    /**
     * PreparedStatement更新测试
     */
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        System.out.print("用户名：");
        String name = scan.nextLine();
        System.out.print("新密码：");
        String password = scan.nextLine();

        String sql = "update user_info set password=? where name=?";
        update(sql, password, name);
        System.out.println("数据更新成功!");
    }

    /**
     * 通用的更新（增、删、改）操作
     */
    public static void update(String sql, Object... args) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            // 1.获取数据库的连接
            conn = JdbcUtils.getConnection();

            // 2.获取PreparedStatement的实例 (或：预编译sql语句)
            ps = conn.prepareStatement(sql);
            // 3.填充占位符
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }

            // 4.执行sql语句
            ps.execute();
        } catch (Exception e) {

            e.printStackTrace();
        } finally {
            //5.关闭资源
            JdbcUtils.closeResource(conn, ps);
        }
    }
}

测试结果：

查看数据库已经更新成功：

4、ResultSet与ResultSetMetaData

4.1、ResultSet

• 查询需要调用PreparedStatement 的 executeQuery() 方法，查询结果是一个ResultSet 对象；

• ResultSet 对象以逻辑表格的形式封装了执行数据库操作的结果集，ResultSet 接口由数据库厂商提供实现；

• ResultSet 返回的实际上就是一张数据表。有一个指针指向数据表的第一条记录的前面；

• ResultSet 对象维护了一个指向当前数据行的游标，初始的时候，游标在第一行之前，可以通过 ResultSet 对象的 next() 方法移动到下一行。调用 next()方法检测下一行是否有效。若有效，该方法返回 true，且指针下移。相当于Iterator对象的 hasNext() 和 next() 方法的结合体；

• 当指针指向一行时, 可以通过调用 getXxx(int index) 或 getXxx(int columnName) 获取每一列的值。

4.2、ResultSetMetaData

• 可用于获取关于 ResultSet 对象中列的类型和属性信息的对象；

• ResultSetMetaData meta = rs.getMetaData();

  • getColumnName(int column)：获取指定列的名称；

  • getColumnLabel(int column)：获取指定列的别名；

  • getColumnCount()：返回当前 ResultSet 对象中的列数；

  • getColumnTypeName(int column)：检索指定列的数据库特定的类型名称；

  • getColumnDisplaySize(int column)：指示指定列的最大标准宽度，以字符为单位；

  • isNullable(int column)：指示指定列中的值是否可以为 null；

  • isAutoIncrement(int column)：指示是否自动为指定列进行编号，这样这些列仍然是只读的。