当前考虑的是使用Java操作MySQL
MySQL的自身是使用C或C++来编写的

如果使用其他语言操作数据库？
数据库服务器是本体，通过代码写的程序，调用MySQL的API实现的是一个客户端，
其他编程语言访问数据库，就只要按照MySQL服务器的要求，构造出对应的网络请求就行了

本质上是在实现一个MySQL的客户端
MySQL的客户端有很多（只要能按照人家MySQL约定的网络请求的格式来构造请求）

MySQL Workbench就是官方的一个图形化客户端程序
image.png
Navicat等第三方的图形化客户端程序

连接Connection ！= 链接Link

总归下来还是SQL语言，就是换个地方敲

JDBC操作

通过Java来操作MySQL
得先得到MySQL的API
可以在MySQL的官网上找到
可惜 自从被Olrea收购了就很难下载
可以去一些其他的“中央仓库”找到相关的API

此驱动不是指平时日常生活中·说的驱动，硬件驱动（也是一个软件，是让操作系统能够通过这个硬件驱动程序向硬件发号施令） 但是术语同样是，driver——>驱动 而下载下来的.jar文件，则是一个压缩文件（同zip、7z之类），针对java的压缩包

Java操作数据库的
java为了简化操作

封装
数据库种类很多，每个数据库都会提供一组API，不同的数据库提供的API还不一样，只需要关注JDBC提供的API即可，JDBC在底层把不同的数据库的接口给统一起来了
其实，所谓JDBC编程就是在底层操作MySQL客户端

操作

  1. 将jar包拷贝到项目的某个目录里
  2. 右键该目录，add as library

后续就可以访问到该jar包中的类了

MySQL是 客户端 和 服务器 结构

但是不是所有的数据库都是这样的 不是！SQL Server Oracle也是这样的，但是SQLite这个数据库就只有客户端

  1. 创建一个数据源
  2. 给数据源对象设置一些参数
    1. 数据库服务器的ip地址
    2. 数据库服务器的端口号
    3. 访问的数据库名（操作这个数据库服务器上面的哪个数据集合）
    4. 用户名
    5. 密码

  3. ```java import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;

import javax.sql.DataSource; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.SQLException;

/**

  • Created with IntelliJ IDEA
  • Description:
  • User:王瀚晨
  • Date:2021-06-01

  • Time: 21:13 */ public class TestJDBC { public static void main(String[] args) throws SQLException {

    1.  //1.先和数据库建立连接
    2.  // a.创建一个数据源（DataSource）
    3.  DataSource dataSource = new MysqlDataSource();
    4.  // b.给数据源设置一些属性（为了告诉代码，数据库服务器在哪呢）
    5.  //向下转型,一般习惯这么写，有一个好处就是，如果未来需要换一个数据库，改动就会更小
    6.  //可能性很低奥，只能说java这个圈子的人都魔怔了，过早优化是万恶之源
    7.  ((MysqlDataSource) dataSource).setUrl("jdbc:mysql://127.0.0.1:3306/shop?characterEncoding=utf8&useSSL=true");
    8.  ((MysqlDataSource) dataSource).setUser("root");
    9.  ((MysqlDataSource) dataSource).setPassword("123456");
    10.  // c.通过getConnection方法来和服务器建立连接
    11.  //这里大概率回失败,main方法抛出异常
    12.  Connection connection = dataSource.getConnection();
    14.  //2.拼装SQL语句——>语法与SQL一致
    16.  //插入数据  注意此处的 ; 加不加都可以
    17.  String sql = "insert into exam values(10,'张小辉',60,70,80)";
    18.  //实际上需要的是一个 语句对象
    19.  //PreparedStatement会帮助我们很方便的动态的构造出一个SQL 来
    20.  PreparedStatement statement = connection.prepareStatement(sql);
    22.  //3.执行SQL语句，上边只是给准备好了语句，还没开始呢
    23.  //这里执行的是insert语句，尽管是insert但是使用executeUpdate来完成
    24.  //包括delete 和 update 也是使用executeUpdate 来完成
    25.  //如果当前执行的是select 语句 ， 使用executeQuery来完成
    26.  //此处的int ret 表示的是影响到了几行
    27.  int ret = statement.executeUpdate();
    28.  System.out.println("ret = "+ ret);
  1.     //4.收尾工作——>释放前边申请到的资源
  2.     /**
  3.      * 就算不释放，影响也不大！但最好还是手动释放
  4.      * 如果没有手动释放的话，可能会出现问题
  5.      * 容易出现问题的情况：短时间内，反复进行建立连接/创建语句
  6.      * 原因：MySQL服务器同一时间能处理过来的链接数目是有限的
  7.      * 如果不是短时间内高很多链接，在一个长跨度的时间内，反复连接，就不会出现问题
  8.      *
  9.      * 此处手动释放的及时性要高于等待垃圾回收机制自动释放~~
  10.      */
  12.     //例如：用于连接的connection
  13.     //这里考虑到一个顺序问题，遵循先进后出
  14.     //先申请的，后释放
  15.     statement.close();
  16.     connection.close();
  18. }

}

  1. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/700185/1622721329467-7fa91831-bbd9-4d62-b9d0-b7f8c3667b35.png#align=left&display=inline&height=280&margin=%5Bobject%20Object%5D&name=image.png&originHeight=280&originWidth=451&size=16073&status=done&style=none&width=451)
  3. 手动输入insert
  4. ```java
  5. import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
  7. import javax.sql.DataSource;
  8. import java.sql.Connection;
  9. import java.sql.PreparedStatement;
  10. import java.sql.SQLException;
  11. import java.util.Scanner;
  13. /**
  14.  * Created with IntelliJ IDEA
  15.  * Description:
  16.  * User:王瀚晨
  17.  * Date:2021-06-01
  18.  * Time: 21:13
  19.  */
  20. public class TestJDBC {
  21.     public static void main(String[] args) throws SQLException {
  22.         //1.先和数据库建立连接
  23.         // a.创建一个数据源（DataSource）
  24.         DataSource dataSource = new MysqlDataSource();
  25.         // b.给数据源设置一些属性（为了告诉代码，数据库服务器在哪呢）
  26.         //向下转型,一般习惯这么写，有一个好处就是，如果未来需要换一个数据库，改动就会更小
  27.         //可能性很低奥，只能说java这个圈子的人都魔怔了，过早优化是万恶之源
  28.         ((MysqlDataSource) dataSource).setUrl("jdbc:mysql://127.0.0.1:3306/shop?characterEncoding=utf8&useSSL=true");
  29.         ((MysqlDataSource) dataSource).setUser("root");
  30.         ((MysqlDataSource) dataSource).setPassword("123456");
  31.         // c.通过getConnection方法来和服务器建立连接
  32.         //这里大概率回失败,main方法抛出异常
  33.         Connection connection = dataSource.getConnection();
  35.         //手动输入
  36.         Scanner sc = new Scanner(System.in);
  37.         int id = sc.nextInt();
  38.         String name = sc.next();
  39.         int chinese = sc.nextInt();
  40.         int math = sc.nextInt();
  41.         int english = sc.nextInt();
  44.         //2.拼装SQL语句——>语法与SQL一致
  46.         //插入数据  注意此处的 ; 加不加都可以
  47.         String sql = "insert into exam values(?,?,?,?,?)";
  49.         //实际上需要的是一个 语句对象
  50.         //PreparedStatement会帮助我们很方便的动态的构造出一个SQL 来
  51.         PreparedStatement statement = connection.prepareStatement(sql);
  52.         statement.setInt(1,id);
  53.         statement.setString(2,name);
  54.         statement.setInt(3,chinese);
  55.         statement.setInt(4,math);
  56.         statement.setInt(5,english);
  57.         //3.执行SQL语句，上边只是给准备好了语句，还没开始呢
  58.         //这里执行的是insert语句，尽管是insert但是使用executeUpdate来完成
  59.         //包括delete 和 update 也是使用executeUpdate 来完成
  60.         //如果当前执行的是select 语句 ， 使用executeQuery来完成
  61.         //此处的int ret 表示的是影响到了几行
  62.         int ret = statement.executeUpdate();
  63.         System.out.println("ret = "+ ret);
  66.         //4.收尾工作——>释放前边申请到的资源
  67.         /**
  68.          * 就算不释放，影响也不大！但最好还是手动释放
  69.          * 如果没有手动释放的话，可能会出现问题
  70.          * 容易出现问题的情况：短时间内，反复进行建立连接/创建语句
  71.          * 原因：MySQL服务器同一时间能处理过来的链接数目是有限的
  72.          * 如果不是短时间内高很多链接，在一个长跨度的时间内，反复连接，就不会出现问题
  73.          *
  74.          * 此处手动释放的及时性要高于等待垃圾回收机制自动释放~~
  75.          */
  77.         //例如：用于连接的connection
  78.         //这里考虑到一个顺序问题，遵循先进后出
  79.         //先申请的，后释放
  80.         statement.close();
  81.         connection.close();
  83.     }
  84. }

image.png

注意：

  1. 手动拼装SQL不安全!! 为啥呢？
    1. 假设用户的名字形如，name = 'asd';drop database shop;——>SQL注入攻击
    2. 因此使用，PrepareStatement，人家里面的setXXX方法内部做了充分的校验，能够及时的识别出这种SQL注入攻击

查找

  1. import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
  3. import javax.sql.DataSource;
  4. import java.sql.Connection;
  5. import java.sql.PreparedStatement;
  6. import java.sql.ResultSet;
  7. import java.sql.SQLException;
  9. /**
  10.  * Created with IntelliJ IDEA
  11.  * Description:
  12.  * User:王瀚晨
  13.  * Date:2021-06-03
  14.  * Time: 20:00
  15.  */
  16. //使用JDBC查找数据
  17. public class TestJDBC2 {
  18.     public static void main(String[] args) throws SQLException {
  19.         //1.和数据库建立连接
  20.         //创建数据源
  21.         DataSource dataSource = new MysqlDataSource();
  22.         //给数据源设置。一些属性
  23.         ((MysqlDataSource) dataSource).setUrl("jdbc:mysql://127.0.0.1:3306/shop?characterEncoding=utf8&useSSL=true");
  24.         ((MysqlDataSource) dataSource).setUser("root");
  25.         ((MysqlDataSource) dataSource).setPassword("123456");
  26.         //建立连接,选java.sql的选项
  27.         Connection connection = dataSource.getConnection();
  29.         //拼接SQL语句
  30.         String sql = "select * from exam";
  31.         PreparedStatement statement = connection.prepareStatement(sql);
  32.         //执行SQL语句   查询语句其实会得到一个临时表
  33.         //所以通过RsultSet就能够获取到需要的表格中的数据
  34.         ResultSet resultSet = statement.executeQuery();
  35.         //通过ResultSet获取到结果内容，遍历结果集合
  36.         //注意这里不同于sc.hasNext()
  37.         //每次调用next就类似于i++的操作一样
  38.         //会先获取到当前的记录，并同时把下标后移
  39.         //当整个结果集合遍历完毕后，next会返回false，遍历结束
  40.         while(resultSet.next()){
  41.             //可以获取到当前记录（当前行的每一列）
  42.             //必须保证列名相匹配
  43.             int id = resultSet.getInt("id");
  44.             String name = resultSet.getString("name");
  45.             double chinese = resultSet.getDouble("chinese");
  46.             double math = resultSet.getDouble("math");
  47.             double english = resultSet.getDouble("english");
  48.             System.out.println(id+","+name+","+chinese+","+math+","+english);
  49.         }
  51.         //释放
  52.         resultSet.close();
  53.         statement.close();
  54.         connection.close();
  55.     }
  56. }

image.png

注意：

  1. 请求彼此之间共用一个DataSource即可，当然不是说不能创建多份，只是没必要
  2. 假设如果当前的服务器收到的请求数量很多，随之创建的Connection对象也很多，那么ResultSet和PrepareStatement也会变多
  3. 但是Connection创建的开销远远比创建ResultSet和PrepareStatement更大
  4. 实际上，我们使用的DataSource，getConnection并不一定每次调用都创建新的连接对象
    1. 目的就是因为简例连接过程开销太大了，能省则省
    2. 同时又不能把Connection像DataSource一样只搞一份
    3. 因此引出了，数据库连接池的概念
  5. 诸如DataSource这样的对象我们希望只有一份，之创建一个实例就可以了
    1. 通过单例模式，来保证DataSource只有一个实例

单例模式：
是一种设计模式——>例如棋谱
计算机先人们，针对一些经典的场景，设计了一些解决方案

池的概念pool 在计算机中是一个非常广泛使用的概念 进程池、线程池、内存池……

单例模式

线程安全版本的单例模式——>待学习！！

  1. import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
  3. import javax.sql.DataSource;
  5. public class DBUtil {
  6.     //类成员 vs 实例成员
  7.     private static DataSource dataSource = null;
  9.     //后面再写代码的时候都不适用DataSource直接new了
  10.     //而是通过下面的getDataSource（）方法来获取这个实力
  11.     public static DataSource getDataSource(){
  12.         if(dataSource == null){
  13.             dataSource=  new MysqlDataSource();
  14.             ((MysqlDataSource) dataSource).setUrl("");
  15.             ((MysqlDataSource) dataSource).setUser("");
  16.             ((MysqlDataSource) dataSource).setPassword("");
  17.         }
  18.         return dataSource;
  19.     }
  20. }
  1. 操作数据库
  2. 增加数据
  3. 删除数据
  4. 修改数据
  5. 查询数据
  6. 约束
  7. 设计表的方法
  8. 更加复杂的查找——聚合查询，多表查询，子查询
  9. 索引/事务
  10. JDBC编程

注意：
throw是一定会抛出异常
throws是可能会抛出异常
抛出异常，要把close放到finally中，保证其被执行

这时需要了解进程：

  1. 进程不同于可执行文件，可执行文件只是在磁盘上，双击才跑起来，此时在操作系统中就出现了一个对应的进程
  2. 进程包含了一系列相关联的资源（内存、文件资源、CPU……）
  3. 一旦进程被销毁，此时相关的资源也就被回收了
  4. 在代码中，通过colse方法关闭连接，这是一种比较温和的回收资源的方式
  5. 如果直接干掉进程，这是一种比较激烈的回收资源的方式
  6. 实际开发中，进程不是说干掉就能干掉的事情，因为在工作中，涉及到的很多程序对应的进程是一个“服务器进程”