1、JDBC概述

a、Java DataBase Connectivity Java 数据库连接技术
b、顾名思义：就是用过java语言操作数据库，操作表中的数据
c、是官方定义的一套操作所有关系型数据库的规则（接口）
1、在java中想要访问数据库只能通过JDBC
2、JDBC是java访问数据的基础，其他数据访问技术都是对JDBC的封装（hb，mb）
3、JDBC是为了访问不同的数据库，提供了一种同一的访问方式
4、JDBC本身是java连接数据库的一个标准，是进行数据库连接的抽象层，接口的实现由各大厂商来实现
实现步骤：

  1. 1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
  2.     1.复制mysql-connector-java-5.1.37-bin.jar到项目的lib目录下
  3.     2.右键-->Add As Library
  4. 2. 注册驱动(安装驱动)
  5. 3. 获取数据库连接对象 Connection
  6. 4. 定义sql
  7. 5. 获取执行sql语句的对象 Statement
  8. 6. 执行sql，接受返回结果
  9. 7. 处理结果
  10. 8. 释放资源

2、JDBC api介绍

DriverManager：

注册驱动：

  1. 使用registerDriver注册驱动
  2.     static void registerDriver(Driver driver);
  3.   registerDriver(new Driver());
  4. 使用反射注册驱动
  5.     Class.forName("com.mysql.jdbc.Driver");

获取数据库连接：

  1. static Connection getConnection(String url,String user,String password)
  3. url:
  4.     指定连接的路径
  5.     jdbc:mysql://localhost:3306/数据库名称
  6.       若是连接本地则可简写：jdbc:mysql:///数据库名
  7. user：
  8.     用户名
  9. password：
  10.     密码

Connection：

获取sql语句执行对象和事务管理对象
1、点一个Statement对象，用于将SQL语句发送到数据库
2、点一个PreparedStatement，用于将参数化的SQL语句发送到数据库
事务管理：
1、点一个setAutoCommit（false）设置成手动提交
2、点一个commit（）提交事务
3、点一个rollback（）回滚事务

Statement：

用于执行静态SQL语句并返回其生成的结果的对象
1、点一个execute（sql），可执行任意的sql语句
2、点一个executeUpdate（sql），执行DML（insert，update，delete）语句，DDL（create,alter,drop）语句
3、点一个executeQuery（sql），执行DQL（select）语句

ResultSet：

表示数据库结果集的数据表，通常通过执行查询数据库的语句生成
1、点一个next（），将光标向前移一位，返回值为true代表有数据，false代表没数据
2、点一个getXxx（i）,若i是整数则代表获取该列的值，若是字符串，则获取该字符串命名的列的值
3、点一个getObject（列名），根据列名获取所有列的类型的值

3、CRUD操作

编写步骤：

  1. 1、注册驱动
  2. 2、建立连接
  3. 3、编写sql
  4. 4、获取sql执行对象
  5. 5、执行sql对象并返回结果
  6. 6、处理结果
  7. 7、释放资源

添加数据：

  1. public class JDBCInsert {
  2.     public static void main(String[] args) throws Exception {
  3.         // 1.注册驱动
  4.         Class.forName("com.mysql.jdbc.Driver");
  5.         // 2.建立连接
  6.         Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/db2", "root", "root");
  7.         // 3.编写sql（在java编写sql 结尾；可以省略）
  8.         String sql = "insert into account values(4,'lucy',1000)";
  9.         // 4.获取sql执行对象
  10.         Statement statement = connection.createStatement();
  11.         // 5.执行sql并返回结果
  12.         int i = statement.executeUpdate(sql);
  13.         // 6.处理结果
  14.         System.out.println(i);
  15.         // 7.释放资源
  16.         statement.close();
  17.         connection.close();
  18.     }
  19. }

修改数据：

  1. public class JDBCUpdate {
  2.     public static void main(String[] args) throws Exception {
  3.         // 1.注册驱动
  4.         Class.forName("com.mysql.jdbc.Driver");
  5.         // 2.建立连接
  6.         Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/db2", "root", "root");
  7.         // 3.编写sql
  8.         String sql = "update account set name = '松岛枫' where id = 4";
  9.         // 4.获取sql执行对象
  10.         Statement statement = connection.createStatement();
  11.         // 5.执行sql并返回结果
  12.         int i = statement.executeUpdate(sql);
  13.         // 6.处理结果
  14.         if (i>0) {
  15.             System.out.println("修改成功");
  16.         }else{
  17.             System.out.println("修改失败");
  18.         }
  19.         // 7.释放资源
  20.         statement.close();
  21.         connection.close();
  22.     }
  23. }

删除数据：

  1. public class JDBCDelete {
  2.     public static void main(String[] args) throws Exception {
  3.         // 1.注册驱动
  4.         Class.forName("com.mysql.jdbc.Driver");
  5.         // 2.建立连接
  6.         Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/db2", "root", "root");
  7.         // 3.编写sql
  8.         String sql = "delete from account where id = 4";
  9.         // 4.获取sql执行对象
  10.         Statement statement = connection.createStatement();
  11.         // 5.执行sql并返回结果
  12.         int i = statement.executeUpdate(sql);
  13.         // 6.处理结果
  14.         if (i>0) {
  15.             System.out.println("修改成功");
  16.         }else{
  17.             System.out.println("修改失败");
  18.         }
  19.         // 7.释放资源
  20.         statement.close();
  21.         connection.close();
  22.     }
  23. }

查询数据：

  1. package com.smiledog.domain;
  3. public class Account {
  4.     private int id;
  5.     private String name;
  6.     private Double money;
  8.     // 有参无参构造....
  9.     // get和set方法....
  10.     // toString()...
  11. }
  12. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  13. public class JDBCQuery{
  15.     public static void main(String[] args) throwes Exception{
  16.         ArrayList<Account> list = new ArrayList<>();
  18.         // 1.注册驱动
  19.         Class.forName("com.mysql.jdbc.Driver");
  20.         // 2.建立连接
  21.         Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/day23", "root", "root");
  22.         // 3.编写sql
  23.         String sql = "select * from account";
  24.         // 4.获取sql执行对象
  25.         Statement statement = connection.createStatement();
  26.         // 5.执行sql并返回结果
  27.         ResultSet resultSet = statement.executeQuery(sql);
  28.         // 6.处理结果
  29.         Account account = null;
  30.         while (resultSet.next()) {
  31.             // 获取数据
  32.             int id = resultSet.getInt("id");
  33.             String name = resultSet.getString("name");
  34.             double money = resultSet.getDouble("money");
  36.             account = new Account();
  37.             account.setId(id);
  38.             account.setName(name);
  39.             account.setMoney(money);
  41.             list.add(account);
  42.         }
  43.         // 7.释放资源
  44.         resultSet.close();
  45.         statement.close();
  46.         connection.close();
  49.         // 遍历集合代码省略............
  50.     }
  51. }

4、JDBC工具类编写

工具类呢，就是把一些重复的代码提取出来，能提取多少提取多少，整合到一个类里边，合理的编排，定义方法供外界调用。
不改变的代码可以提取，一致变得代码也可以提取，把一些一直改变的数据整合到一个集合里，改动代码只需要改动集合里的代码就行了，比如（properties集合）
JDBC工具类：

  1. package com.smiledog.jdbc.demo.Util;
  2. /*
  3.     @ClassName Util
  4.     @Author SmILeDog
  5.     @Date 2021/5/20
  6.     @Time 14:44
  7. */
  9. import java.io.InputStream;
  10. import java.sql.*;
  11. import java.util.Properties;
  13. public class JDBCUtil {
  14.     private JDBCUtil() {
  15.     }
  16.     private static Connection conn;     //数据库连接对象
  17.     private static Statement stat = null;   //sql执行对象
  18.     private static String driver = null;    //驱动对象
  19.     private static String url = null;       //数据库连接信息
  20.     private static String user = null;      //数据库用户名
  21.     private static String password = null;  //数据库用户名密码
  22.     private static String sql = null;       //待执行的增删改的sql语句
  23.     private static String querysql = null;       //待执行的查询sql语句
  24.     static{
  25.         try {
  26.             //读取配置文件
  27.             Properties pro = new Properties();
  29.             //方法一：直接读取配置文件
  30.             // pro.load(new FileReader("day01_jdbc\\src\\jdbc.properties"));
  32.             // 方法一：使用类加载器，进行读取配置文件
  33.             InputStream is = JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties");
  34.             //方法三：java提供的专门获取jdbc配置文件的类
  35.             //ResourceBundle jdbc = ResourceBundle.getBundle("jdbc");
  37.             pro.load(is);   //读取配置文件
  39.             driver = pro.getProperty("driverName"); //读取驱动
  40.             url = pro.getProperty("url");       //读取url
  41.             user = pro.getProperty("user");      //读取同户名
  42.             password = pro.getProperty("password"); //读取密码
  43.             sql = pro.getProperty("sql");       //读取增删改的sql语句
  44.             querysql = pro.getProperty("querysql"); //读取查询的sql语句
  46.             Class.forName(driver);      //注册驱动
  47.             conn = DriverManager.getConnection(url, user, password); //获取数据库连接对象
  48.             //想想，没必要再搞这个了，上边获取到conn了，直接可以在那边获取就
  49.             //stat = conn.createStatement();  //获取sql语句执行对象
  51.         } catch (Exception e) {
  52.             e.printStackTrace();
  53.         }
  54.     }
  56.     public static Connection getConnection(){
  57.         return conn;
  58.     }
  59.     //获取sql执行对象
  60.     //public static Statement getStatement(){
  61.     //    return stat;
  62.     //}
  63.     //获取增删改sql执行语句
  64.     public static String getSql(){
  65.        return sql;
  66.     }
  67.     //获取查询的sql执行语句
  68.     public static String getQuerySql(){
  69.         return querysql;
  70.     }
  71.     //获取释放资源
  72.     public static void getClose(Connection conn, Statement stat, ResultSet res){
  73.        if(stat != null){
  74.            try {
  75.                stat.close();
  76.            } catch (SQLException e) {
  77.                e.printStackTrace();
  78.            }
  79.        }
  80.         if(conn != null){
  81.             try {
  82.                 conn.close();
  83.             } catch (SQLException e) {
  84.                 e.printStackTrace();
  85.             }
  86.         }
  87.         if(res != null){
  88.             try {
  89.                 res.close();
  90.             } catch (SQLException e) {
  91.                 e.printStackTrace();
  92.             }
  93.         }
  94.     }
  95. }
  96. ~~~~~~~~~~~~~~jdbc.properties~~~~~~~~~~~~~~~~~
  97. driverName=com.mysql.jdbc.Driver
  98. url=jdbc:mysql://localhost:3306/库名?characterEncoding=utf-8
  99. user=root
  100. password=1234
  101. sql=s增删改sql语句;
  102. querysql=查询语句;

5、事务操作

一个包含多个步骤的业务操作，如果这个业务操作被事务管理，则这多个步骤要么同时成功，要么同时失败
使用Connection对象来管理事务
1、开启事务
点一个setAutoCommit（）事务，设置为false，即开始事务
注意：在执行sql之前开启事务
2、提交事务
点一个commit（），提交事务
注意：当所有的sql语句都执行完提交事务
3、回滚事务
点一个rollback（），回滚事务
注意：在catch中回滚事务
JDBC事务演示：

  1. public class JDBCTX{
  2.    public static void mian(String[] args){
  3.         Connection connection = null;
  4.         Statement statement = null;
  5.         try {
  6.             // 1.获取连接【JdbcUtils工具类】
  7.             connection = JdbcUitls.getConnection();
  8.             // 2.开启事务
  9.             connection.setAutoCommit(false);
  10.             tatement = connection.createStatement();
  11.             // 3.罗志祥扣钱
  13.             // 机器故障
  14.             // 4.蝴蝶姐加钱
  15.             // 5.提交事务
  16.             connection.commit();
  17.         } catch (Exception e) {
  18.             try {
  19.                 // 6.回滚事务
  20.                 connection.rollback();
  21.             } catch (SQLException e1) {
  22.                 e1.printStackTrace();
  23.             }
  24.         } finally {
  25.             // 7.释放资源
  26.             JdbcUitls.close(statement, connection);
  27.         }
  28.    }
  29. }

6、用户登录案例

案例需求：
1、通过键盘录入用户名和密码
2、判断用户是否登录成功
数据准备：

  1. CREATE TABLE USER(
  2.     id INT PRIMARY KEY AUTO_INCREMENT, -- 主键ID
  3.     username VARCHAR(32), -- 用户名
  4.     PASSWORD VARCHAR(32)  -- 密码
  5. );
  7. -- 添加数据
  8. INSERT INTO USER VALUES(NULL,'zhangsan','123');
  9. INSERT INTO USER VALUES(NULL,'lisi','234');

代码实现：

  1. package com.smiledog.jdbc.test;
  2. /*
  3.     @ClassName LoginTest
  4.     @Author SmILeDog
  5.     @Date 2021/5/20
  6.     @Time 19:21
  7. */
  9. import com.smiledog.jdbc.test.Util.JDBCUtil;
  11. import java.sql.Connection;
  12. import java.sql.ResultSet;
  13. import java.sql.SQLException;
  14. import java.sql.Statement;
  15. import java.util.Scanner;
  17. public class LoginTest {
  18.     public static void main(String[] args) throws SQLException {
  19.         boolean b = false;
  20.         Scanner sc = new Scanner(System.in);
  21.         System.out.println("请输入用户名：");
  22.         String uname = sc.nextLine();
  23.         System.out.println("请输入密码：");
  24.         String pwd = sc.nextLine();
  25.         Connection conn = JDBCUtil.getConnection();
  26.         Statement stat = conn.createStatement();
  27.         ResultSet res = stat.executeQuery(JDBCUtil.getQuerySql());
  28.         while (res.next()) {
  29.             String username = res.getString("username");
  30.             String password = res.getString("password");
  31.             if (username.equals(uname) && password.equals(pwd)){
  32.                 b = true;
  33.             }
  34.         }
  35.         if (b){
  36.             System.out.println("登录成功！");
  37.         }else{
  38.             System.out.println("用户名或密码错误！");
  39.         }
  40.         JDBCUtil.getClose(conn,stat,res);
  41.     }
  42. }