JDBC总结

什么是JDBC？
简单操作JDBC
注册驱动有两种方法
各个对象
制作简单的工具类
ORM
DAO

什么是JDBC？

JDBC（Java Data Base Connectivity），Java数据库连接。现在广泛使用的驱动标准有ODBC（Open Data Base Connectivity）和JDBC，JDBC是SUN公司在ODBC基础上制定出来的一套Java应用连接标准（接口）,操作所有关系型数据库的规则。像MySQL、Oracle、SQL Server等等数据库厂商来实现这些接口，为我们提供了jar包，我们使用这套接口（JDBC）来编程，真正执行的代码是驱动jar包中的实现类。

简单操作JDBC

导入jar包
注册驱动（初始化驱动）
连接数据库
编写SQL语句
获取可执行SQL语句的对象
执行SQL语句
获取数据，处理结果
关闭连接

注册驱动有两种方法

Class.forName("com.mysql.jdbc.Driver");
DriverManager.registDriver(new com.mysql.jdbc.Driver());

第一种方法只会注册一次驱动，看一下源码
```
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    public Driver() throws SQLException {
    }

    static {
        try {
            DriverManager.registerDriver(new Driver());
        } catch (SQLException var1) {
            throw new RuntimeException("Can't register driver!");
        }
    }
}
```
静态代码块只在类加载的时候执行一次，再静态代码块种已经执行了一次DriverManager.registerDriver(new Driver()，所以用Class.forName()这种只会加载一次。然而第二种方法会导致注册两次驱动，因为显示的注册一次，然后在创建new com.mysql.jdbc.Driver()时候，加载了这个类，静态代码块执行了，所以又注册了一次。而且这种注册方法过度依赖MySQL数据库的API，若没有MySQL开发包，则无法编译。

各个对象

DriverManager：驱动管理对象

功能1：注册驱动：告诉程序该使用哪一个数据库驱动jar（MySQL5之后的驱动jar包可以省略注册驱动的步骤，但是最好加上）
static void registerDriver(Driver driver): 注册与给定的驱动程序 DriverManager

功能2：获取数据库连接

static Connection getConnection(String url, String user, String password) ：获取数据库连接对象
```
*    url：指定连接的路径
 * 语法：jdbc:mysql://ip地址(域名):端口号/数据库名称

 	* 例子：jdbc:mysql://localhost:3306/db3
 * 细节：如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称
```
- user：用户名
- password：密码
Connection：数据库连接对象

功能：数据库连接对象

常用方法：
- 执行sql语句
  - Statement createStatement()
    - PreparedStatement prepareStatement(String sql)
  - 管理事务
    - void setAutoCommit(boolean autoCommit)
    - void commit()
    - void rollback()
Statement：执行sql的对象

功能：执行SQL语句对象，来执行sql语句
- boolean execute(String sql) ：可以执行任意的sql （不常用）
- int executeUpdate(String sql) ：执行DML（insert、update、delete）语句、DDL(create，alter、drop)语句。返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功返回值 > 0的则执行成功。
1. ResultSet executeQuery(String sql) ：执行DQL（select)查询语句
PreparedStatement：执行sql的对象（更安全且常用）
- 解决sql注入问题：使用PreparedStatement对象来解决
  - 预编译的SQL：参数使用?作为占位符
  - 步骤：
    - 导入驱动jar包mysql-connector-java-x.x.xx-bin.jar
    - 注册驱动
    - 连接数据库，获取数据库连接对象 Connection
    - 定义sql（注意：sql的参数使用？作为占位符。如：select * from user where username = ? and password = ?）
    - 获取执行sql语句的对象 PreparedStatement Connection.prepareStatement(String sql)
    - 给？赋值：方法： setXxx(参数1,参数2)
      
      * 参数1：？的位置编号从1 开始
```
 * 参数2：？的值
```
    - 执行sql，接受返回结果，不需要传递sql语句
    - 处理结果
    - 释放资源
- 实际开发中都会使用PreparedStatement来完成增删改查的所有操作，有如下优点：
  
  1. 可以防止SQL注入
  
  2. 效率更高
ResultSet：结果集对象,封装查询结果

常用方法：
- boolean next(): 游标向下移动一行，判断当前行是否是最后一行末尾(是否有数据)，如果是，则返回false，如果不是则返回true
- getXxx(参数):获取数据
  - Xxx：代表数据类型如： int getInt() , String getString()
    - 参数：
      1. int：代表列的编号,从1开始如： getString(1)
      2. String：代表列名称。如： getDouble("balance")
  - 注意：
    - 使用步骤：
      1. 游标向下移动一行
      2. 判断是否有数据
      3. 获取数据
由于next返回的是布尔值，因此我们可以用循环判断游标是否是最后一行末尾。

制作简单的工具类

由于要频繁的连接关闭数据库，所以我们把连接数据库和关闭数据库操作都放到一个工具类中去。

/**
 * @ClassName: JDBCUtil
 * @Description: 数据库连接工具类
 * @Author: LinZeLiang
 * @Date: 2020-09-01 21:03
 * @Version: 1.0.0
 */
public class JDBCUtil {

    private static String url;
    private static String username;
    private static String password;
    private static String driver;

    //这里将数据库的连接消息保存在jdbc.properties配置文件中，位置在src目录下，所以我们要导入获取这个配置文件中的信息，静态代码块仅在类加载到jvm中执行一次，这样子可以避免配置文件的多次读取
    static {
        try {
            //获取src路径下文件的方式：ClassLoader类加载器
            /*ClassLoader classLoader = JDBCUtil.class.getClassLoader();
            URL res = classLoader.getResource("jdbc.properties");
            String path = res.getPath();*/
            InputStream inputStream = JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties");

            //创建Properties集合类
            Properties pro = new Properties();
            //加载文件
            //pro.load(new FileReader(path));
            pro.load(inputStream);

            //获取数据且赋值
            url = pro.getProperty("url");
            user = pro.getProperty("user");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");
            Class.forName(driver);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 功能描述: 获取连接
     *
     * @param: void
     * @return: Connection
     * @Author: LinZeLiang
     * @Date: 2020-09-01
     */
    public static Connection getConnection() {
        try {
            return DriverManager.getConnection(url, username, password);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }


    /**
     * 功能描述: 释放资源
     *
     * @param: rs, stmt, conn
     * @return: void
     * @Author: LinZeLiang
     * @Date: 2020-09-01
     */
    public static void close(ResultSet rs, Statement stmt, Connection conn) {

        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

ORM

ORM = Object Relationship Database Mapping：对象和关系数据库的映射，就是用一个对象来封装数据库里的一条记录。

/**
 * @ClassName: ProductFind
 * @Description: TODO
 * @Author: LinZeLiang
 * @Date: 2020-08-31 22:14
 * @Version: 1.0.0
 */
public class ProductFind {
    public static void main(String[] args) {

        ProductFind test = new ProductFind();
        List<Product> all = test.findAll();
        System.out.println(all);
    }

    /**
     * 功能描述: 查询所有的Product对象
     *
     * @param: void
     * @return: List<Product>
     * @Author: LinZeLiang
     * @Date: 2020-08-31 22:34
     **/
    public List<Product> findAll() {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        List<Product> list = null;
        try {
            //初始化驱动、注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            DriverManager.registerDriver(new com.mysql.jdbc.Driver());
            //与数据库连接，获取连接对象
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/shop?characterEncoding=UTF-8",
                    "root", "root");
            //定义SQL语句
            String sql = "SELECT * FROM product";
            //获取执行SQL语句的对象
            stmt = conn.createStatement();
            //执行SQL语句
            rs = stmt.executeQuery(sql);
            Product product = null;
            list = new ArrayList<>();
            while (rs.next()) {
                product = new Product();
                product.setProduct_id(rs.getString("product_id"));
                product.setProduct_name(rs.getString("product_name"));
                product.setProduct_type(rs.getString("product_type"));
                product.setSale_price(rs.getInt("sale_price"));
                product.setPurchase_price(rs.getInt("purchase_price"));
                product.setRegist_date(rs.getDate("regist_date"));
                list.add(product);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }

            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }

            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
        return list;
    }
}

class Product {
    private String product_id;
    private String product_name;
    private String product_type;
    private int sale_price;
    private int purchase_price;
    private Date regist_date;

    public String getProduct_id() {
        return product_id;
    }

    public void setProduct_id(String product_id) {
        this.product_id = product_id;
    }

    public String getProduct_name() {
        return product_name;
    }

    public void setProduct_name(String product_name) {
        this.product_name = product_name;
    }

    public String getProduct_type() {
        return product_type;
    }

    public void setProduct_type(String product_type) {
        this.product_type = product_type;
    }

    public int getSale_price() {
        return sale_price;
    }

    public void setSale_price(int sale_price) {
        this.sale_price = sale_price;
    }

    public int getPurchase_price() {
        return purchase_price;
    }

    public void setPurchase_price(int purchase_price) {
        this.purchase_price = purchase_price;
    }

    public Date getRegist_date() {
        return regist_date;
    }

    public void setRegist_date(Date regist_date) {
        this.regist_date = regist_date;
    }

    @Override
    public String toString() {
        return "Product{" +
                "product_id='" + product_id + '\'' +
                ", product_name='" + product_name + '\'' +
                ", product_type='" + product_type + '\'' +
                ", sale_price=" + sale_price +
                ", purchase_price=" + purchase_price +
                ", regist_date=" + regist_date +
                '}';
    }
}

DAO

DAO=DataAccess Object：数据访问对象。运用了ORM中的思路，把数据库相关的操作都封装在这个类里面，其他地方看不到JDBC的代码。