本文主要是介绍MySQL知识点大全！！，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1.初识数据库

1. 数据库（DB，database）

2. 概念：数据仓库，安装在操作系统上的一款软件

3. 作用：存储管理数据

4. 分类：

   1. 关系型数据库（SQL）：
      • MySQL，Oracle，Sql Server，DB2，SQLlite
      • 通过表和表之间，行和列之间的关系进行数据的存储
   2. 非关系型数据库(NoSQL not only) ：
      • Redis，MongDB
      • 非关系数据库，对象存储，通过对象自身的属性决定

5. DBMS（数据库管理系统）：

   • 数据库的管理软件，科学有效的管理数据，维护和获取数据
   • MySQL，数据库管理系统

6. 下载安装MySQL数据库

7. 下载安装数据库可视化工具Navicat

8. 连接数据库（命令行）：

   1. 打开cmd
   2. 跳转到mysql的bin目录
   3. 输入mysql -uroot -p
   4. 输入密码
   5. exit退出

9. 数据库一些命令：

   --注：每个sql语句结束都要用分号结尾
   
   flush privilege; --刷新权限
   
   show databases; --查看所有数据库
   
   use 数据库名; --使用数据库
   Database changed
   
   
   show tables; --查看数据库中所有的表
   
   describe student; --查看表的信息
   
   create database test_db; --创建数据库
   
   
   

2. 操作数据库

操作数据库》操作数据库中的表》操作表中的信息

1. 操作数据库：

   1. 操作数据库：

      CREATE DATABASE [if not exists] shcool;
      

   2. 删除数据库：

      drop database [if exists] lpjsql;
      

   3. 使用数据库：

      use db_yq;
      

   4. 查看数据库：

      show DATABASES;
      

2. 操作数据库表：

   1. 数据库列的类型：

      • 数值：

        tinyint 	--十分小的整数|1个字节
        smallint	--较小的整数|2个字节
        mediumint	--中等大小的整数|3个字节
        int			--标准的整数|4个字节|常用
        bigint		--较大的整数|8个字节
        float		--单精度浮点数|4个字节
        double		--多精度浮点数|8个字节
        decimal		--字符串形式的浮点数|用于金融计算
        

      • 字符串：

        char		--固定大小的字符串|0~255
        varchar		--可变长字符串|0~65535|常用
        tinytext	--微型文本|0~2^8-1
        text		--文本串|0~2^16-1|保存大文本
        

      • 时间和日期：

        date		--YYYY-MM-DD|日期
        time		--HH:mm:ss|时间
        datetime	--YYYY-MM-DD HH:mm:ss|最常用的时间格式
        timestamp	--时间戳|1970.1.1到现在的毫秒数|较为常用
        year		--年份
        

      • null：

        --没有值，未知，注意不要使用null进行运算，因为结果一定为null
        

3. 数据库的字段属性（重点）：

   1. unsigned （无符号的整数 声名该列不能为负数）
   2. zerofill（0填充 不足的位数用0填充 1 001）
   3. auto_increment（ 自增，自动在上一条记录的基础上+1（默认） 通常用来设计唯一的主键 必须是整数 可自定义设计主键的自增起始值和步长）
   4. NULL NOT NULL（非空 ，假设不赋值就会报错）
   5. default '默认值'（默认 ，设置默认值）（navicat设置字符默认值时需要加引号）

4. 拓展：做项目时，每个表设计时都应该具有的五个字段：

   1. id 主键
   2. ‘version’ 乐观锁 版本号
   3. is_delete 伪删除
   4. gmt_create 创建时间
   5. gmt_update 修改时间

5. 注：在数据库中int的长度并不影响数据的存储精度，长度只是和显示有关

6. 创建数据库表：

   create table if not exists ‘studnet’ (
   `id` int(4) not null auto_increment COMMENT '学号',
   `name` VARCHAR(20) not NULL DEFAULT '匿名' COMMENT '姓名',
   `psd` VARCHAR(20) not NULL DEFAULT '123456' COMMENT '密码',
   `sex` VARCHAR(2) not NULL DEFAULT '男' COMMENT '性别',
   `birthda` datetime DEFAULT null COMMENT '出生日期',
   `address` VARCHAR(100) DEFAULT null COMMENT '家庭住址',
   `email` VARCHAR(18) DEFAULT null COMMENT '邮箱',
   PRIMARY key(`id`)
   );
   
   
   show create table studnet; --查看表的创建语句
   desc studnet;--查看表的结构
   --注：use 数据库之后，相关操作比如创建表是在该数据库下创建
   

7. 数据表的类型：

   1. 数据引擎：

      	MyISAM	InnoDB
      事务支持	不支持	支持
      数据行锁定	不支持	支持
      外键约束	不支持	支持
      全文索引	支持	不支持
      表空间大小	较小	较大，约为倍

      常规使用操作：

      • MyISAM：节约空间，速度较快
      • InnoDB：安全性高，支持事务，多表多用户操作

      物理存储位置：所有数据库文件都存在data目录下，本质上还是文件存储

      • MySQL引擎在物理上文件的区别而：

        • .MySQL（server）创建并管理的数据库文件：

          • .frm文件：存储数据表的框架结构，文件名与表名相同，每个表对应一个同名frm文件，与操作系统和存储引擎无关，即不管MySQL运行在何种操作系统上，使用何种存储引擎，都有这个文件。

          • 除了必有的.frm文件，根据MySQL所使用的存储引擎的不同（MySQL常用的两个存储引擎是MyISAM和InnoDB），存储引擎会创建各自不同的数据库文件。

            1. MyISAM数据库表文件：

               1. .MYD文件：即MY Data，表数据文件
               2. .MYI文件：即MY Index，索引文件

            2. InnoDB数据库文件（即InnoDB文件集，ib-file set）：

               1. ibdata1等：系统表空间文件，存储InnoDB系统信息和用户数据库表数据和索引，所有表共用
               2. .ibd文件：单表表空间文件，每个表使用一个表空间文件（file per table），存放用户数据库表数据和索引
               3. 日志文件： ib_logfile0、ib_logfile1

8. 数据库表的字符集编码：不设置的话会使用默认的编码

9. 修改删除表：

   1. 修改表：

      ALTER table studnet RENAME as student --修改表名
      
      --增加表的字段
      ALTER TABLE test1 add age int(10) not null COMMENT '年龄'
      
      --修改约束和字段类型，不能重命名
      ALTER TABLE test1 MODIFY age VARCHAR(11);
      
      --不能单独修改字段类型和约束，但是可以在重命名时设置字段类型约束
      ALTER TABLE test1 CHANGE age age1 int(2);
      
      --删除表的字段
      ALTER TABLE test1 drop age;
      

   2. 删除表：

      drop table if exists test1;
      

      注：所有的删除或者创建操作尽量加上判断条件

3.MySQL数据管理

1. 外键（了解）：数据库中直接设立外键都是数据库级别的外键，不建议使用（避免数据库过多造成困扰）。

   • 最佳实现：数据库就是单纯的表，只用来存储数据，当有多张表进行操作时或者想使用外键建议使用程序实现。

2. DML语言（掌握）：

   1. insert：

      --方法一：直接插入一整条记录
      insert into 表名 values(全部列值，且一一对应);
      --方法二：对应列插入值
      insert into 表名(字段1，字段2...) values(字段值1,字段值2,...);
      --一次性插入多个记录
      INSERT into 表名(字段1，字段2...) VALUES (字段值1,字段值2,...)，(字段值1,字段值2,...),...;
      

   2. update：

      update 表名 set 字段名=字段值[,字段名=字段值,...] [where ...]
      --注1：如果没有条件限定，会直接修改全部记录的对应字段值
      --注2：字段值不仅可以是常量，也可以是变量，比如常用的时间函数
      

   3. delete：

      delete from 表名;--删除整个表所有数据
      delete from 表名 where ...;--删除指定数据
      
      --补充
      --完全清空一个数据库表，表的结构和索引约束不会变
      truncate table 表名;
      
      --两种方式的区别
      --相同点：都能删除数据且不会删除表
      --不同点：
         --truncate：自增会归零
         --delete：不影响自增
         
      --拓展：delete 删除数据时，如果重启数据库，那么
           --InnoDB：自增列会从1开始(存在内存中的，断电即失)
           --MySAM：继续从上一个自增量开始(存在文件中的，不会丢失)
      

3. DQL语言（查询数据）：

   1. 别名：字段名 as 新名字；表名 as 新名字；或者直接：字段名 新名字；表名 新名字；

   2. 拼接字符串：Concat(a,b,c,...)

      SELECT CONCAT('名字：',number,'寝室') as '寝室号' , CONCAT('楼：',building_name) as  '所属楼层'   from room;
      

   3. 去重：distinct（将查询中的重复结果只显示一条）

      SELECT DISTINCT room_id FROM student;
      

   4. 特殊作用：

      SELECT VERSION();--查询版本号
      SELECT 123*223;--查询计算结果
      

   注：数据库中的表达式：文本值，列，null，函数，计算表达式，系统变量，而

   select 表达式 from 表

   5. where条件语句：

      1. 常用运算符：

         1. 逻辑运算符：

            运算符	含义
            AND 或者 &&	逻辑与，含义为“并且”。当所有操作数均为非零值且不为 null 时，返回值为 1；当一个或多个操作数为 0 时，返回值为 0；其余情况返回值为 null
            OR 或者 ||	逻辑或，含义为“或者”。当所有操作数均不为 null 且任意一个操作数为非零时，返回值为 1，否则为 0；当有操作数为 null，且存在另一个操作数为非零时，返回值为 1，否则为 null；当所有操作数均为 null 时，返回值为 null
            NOT 或者 !	逻辑非，含义为“取反”。当操作数为 0 时，返回值为 1；当操作数为非零时，返回值为 0；当操作数为 null 时，返回值为 null

         2. 比较运算符：

            运 算 符	含 义
            =	等于
            <=>	安全等于，可以比较 null
            <> 或 !=	不等于
            >=	大于等于
            <=	小于等于
            >	大于
            <	小于

         3. 算术运算符：

            运 算 符	含 义
            +	加法运算
            -	减法运算
            *	乘法运算
            /	除法运算，返回商
            %	求余运算，返回余数

         4. 模糊查询：

            运算符	含义
            IS NULL	判断一个值是否为 null
            IS NOT NULL	判断一个值是否不为 null
            BETWEEN AND	在什么和什么之间
            LIKE	匹配
            in	a in (a1,a2,a3,...),如果a在a1,a2,a3之间存在，那么为真

            注1：like与%（0~任意个字符）和_（一个字符）结合使用，且不一定要是字符类型才可以使用，数字类型也可以加上引号使用

            select id from student where id like '%2%';
            

            注2：in()必须指定的是确定的值，使用%或者_不行，确定值的表达式也可以

            select id from student where id in (7,8,9,10,1+11);
            

   6. 联表查询：

      1. 

      2. 两种连接表的查询：

         1. 等值查询：where
         2. 联表查询：join...on

      3. 联表查询：

         1. inner join：内连接，特点是查询出来的结果是两个表都有的部分

            --如a表有1,2,3,4，b表有2,3,4,5,那么查询的结果包含2,3,4
            SELECT s.room_id,r.id,s.name,r.building_name from student s INNER JOIN room r on s.room_id=r.id;
            

         2. left join：

            1. 左连接：

               --如a表有1,2,3,4，b表有2,3,4,5,那么查询的结果包含1,2,3,4
               SELECT s.room_id,r.id,s.name,r.building_name from student s LEFT  JOIN room r on s.room_id=r.id;
               

            2. 左外连接：

               --如a表有1,2,3,4，b表有2,3,4,5,那么查询的结果包含1
               SELECT s.room_id,r.id,s.name,r.building_name from student s LEFT  JOIN room r on s.room_id=r.id where r.building_name is null;
               

         3. right join：

            1. 右连接：

               --如a表有1,2,3,4，b表有2,3,4,5,那么查询的结果包含2,3,4,5
               SELECT s.room_id,r.id,s.name,r.building_name from student s RIGHT JOIN room r on s.room_id=r.id 
               

            2. 右外连接:

               --如a表有1,2,3,4，b表有2,3,4,5,那么查询的结果包含5
               SELECT s.room_id,r.id,s.name,r.building_name from student s RIGHT JOIN room r on s.room_id=r.id where s.room_id is null; 
               

         4. 全连接（mysql不支持全连接）

         5. 三个及以上的多表查询：

            select r.*,s.`寝室人数`,e.* from room r left join (SELECT count(*) as '寝室人数',room_id as id from student GROUP BY room_id) as s on r.id=s.id RIGHT JOIN `repair` e on r.id=e.room_id
            --注：直接先两表查询，然后接着两表查询的结果后面再连接表
            

         6. 联表查询+子查询;

            select r.*,s.`寝室人数` from room r left join (SELECT count(*) as '寝室人数',room_id as id from student GROUP BY room_id) as s on r.id=s.id
            --注：在s.`寝室人数`处使用字符时应该使用`而不是引号
            

         7. 自连接（了解）：将一张表看成两张表进行连接查询

   7. 分页和排序：

      1. order by(排序)：

         1. desc（降序）：

            order by 字段 DESC
            

         2. asc（升序）：

            order by 字段 ASC
            

      2. limit（分页）：

         LIMIT 数据起始位置,页面数量
         

   8. 子查询：

      select room.id,`repair`.`describe`,student.`name` from student,room,`repair` WHERE student.room_id=(SELECT id FROM room WHERE number=2624) and `repair`.room_id=(SELECT id FROM room WHERE number=2624) and room.number=2624
      

   9. 分组和过滤（当分组后还有条件时，可以使用having）：

      select room_id FROM student GROUP BY room_id having COUNT(*) = 2
      

      注：（select ...）可以当做一个表，可以跟在from后面，也可以跟在连接查询后面，同时在查询的时候新生成的表都要设置别名。

4.mysql函数：

参考网站：https://www.jb51.net/article/226393.htm

1. 常用函数：

   1. length(str)：获取参数值的字节个数；

      对于utf8字符集来说，一个英文占1个字节；一个中文占3个字节；

      对于gbk字符集来说，一个英文占1个字节；一个中文占2个字节；

   2. concat(str1,str2,…)：拼接字符串；

   3. upper(str)：将字符中的所有字母变为大写；

   4. lower(str) ：将字符中所有字母变为小写；

   5. instr(str,要查找的子串) ：返回子串第一次出现的索引，如果找不到，返回0； 当查找的子串存在于字符串中：返回该子串在字符串中【第一次】出现的索引。当查找的子串不在字符串中：返回0。

   6. trim(str)：去掉字符串前后的空格； 该函数只能去掉字符串前后的空格，不能去掉字符串中间的空格。

   7. lpad(str,len,填充字符)：用指定的字符，实现对字符串左填充至指定长度；

   8. rpad(str,len,填充字符)：用指定的字符，实现对字符串右填充至指定长度

   9. replace(str,子串,另一个字符串)：将字符串str中的字串，替换为另一个字符串；

   10. round(x,[保留的位数]) ：四舍五入

   11. ceil(x)：向上取整

   12. floor(x)：向下取整

   13. mod(被除数,除数) ：取余

   14. now() ：返回系统当前的日期和时间；

   15. curdate() ：只返回系统当前的日期，不包含时间；

   16. curtime() ：只返回系统当前的时间，不包含日期；

   17. 获取日期和时间中年、月、日、时、分、秒；

       获取年份：year()；

       获取月份：month()；

       获取日：day()；

       获取小时：hour()；

       获取分钟：minute()；

       获取秒数：second()；

   18. weekofyear() ：获取当前时刻所属的周数；

   19. quarter() ：获取当前时刻所属的季度；

2. 聚合函数：

   1. count（）：计数
   2. sum（）：求和
   3. avg（）：平均值
   4. max（）：最大值
   5. min（）：最小值

   注：

   1. sum()函数和avg()函数对于字符串类型、日期/时间类型的计算都没有太大意义。因此，sum()函数和avg()函数，我们只用来对小数类型和整型进行求和

   2. max()和min()中传入的是"整型/小数类型"，计算的是数值的最大值和最小值。max()和min()中传入的是"日期类型"，max()计算的最大值是离我们最近的那个日期，min()计算的最小值是离我们最远的那个日期，这个可以记一下。max()和min()中传入的是字符串类型，max()计算的最大值是按照英文字母顺序显示的，min()计算的最小值也是按照英文字母顺序显示的，意义不太大。

   3. 当某个字段列中没有null值，则"count(列字段)=count()。"
      当某个字段列中有null值，则"count(列字段)<count()。"
      因此，假如你想统计的是整张表的行数，请用count(*)。

      另可参考：https://blog.csdn.net/qq_41711758/article/details/116258290

3. 拓展（MD5加密）：

   --数据库中使用MD5函数加密
   INSERT into `repair` (id,`describe`,room_id) VALUES (15,md5('2624'),2)
   

5.事务

1. 什么是事务;

   经典例子：

   转账：

   操作: 张三和李四各自的账号都是1000元；张三向李四转账100元

   组成单元: 张三钱-100, 李四钱+100

   操作成功: 张三钱900,李四钱1100

   操作失败: 张三钱1000,李四钱1000

   不可能发生: 张三钱900,李四钱1000;或者 战三钱1000,李四钱1100

2. 事务特性：

   1. 原子性：要么都成功，要么都失败,即不会出现钱转出去了但是没有收到的情况，即转钱和收钱两个操组合作为一个不可拆分的操作
   2. 一致性:事务前后数据完整性一致，比如转钱转钱一共2000，那么转钱之后一共也是2000
   3. 持久性-----事务提交：事务提交后不可逆，被持久化保存到数据库中
   4. 隔离性：多个事务之前是相互隔离的，互不影响。数据库允许多个并发同时对其数据进行读写和修改，隔离性可以防止多个事务并发执行时由于交叉执行而导致的数据不一致。
      比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。
   5. 隔离造成的一些问题：
      1. 脏读：一个事务读取了另外一个事务未提交的数据
      2. 不可重复读：在一个事务内读取表中某一行数据多次读取结果不一致（不一定是错误，可能是场合不对）
      3. 虚读（幻读）：在一个事务内读取到了别的事务插入的数据，导致前后读取不一致

3. 数据库实现事务：

   1. mysql是默认开启事务自动提交的

      set autocommit =0; --关闭事务
      set autocommit =1; --开启事务，默认
      

   2. 手动实现事务步骤：

      --第一步：关闭事务
      set autocommit =0;
      
      --第二步：开始一个事务
      START TRANSACTION;  --标记一个事务的开始，这个之后的sql语句都算一个事务
      
      --第三步：sql语句执行
      
      --第四步：提交或者回滚
      commit  --提交：持久化，事务成功
      ROLLBACK  --回滚：回到之前的状态，一旦被提交就持久化了无法回滚
      
      --第五步：事务结束
      set autocommit =1;  --开启事务提交
      
      --了解：
      SAVEPOINT 保存点名 --设置一个事务保存点
      ROLLBACK to SAVEPOINT 保存点名 --回滚到保存点名
      RELEASE SAVEPOINT 保存点名 --撤销保存点，一个事务可以有多个保存点
      

6.索引

1. 定义：索引是帮助mysql高效获取数据的一种数据结构

2. 分类：

   1. 主键索引（primary）：
      • 唯一标识，不可重复，只能存在一个主键
   2. 唯一索引（unique）：
      • 避免重复的列出现，唯一索引可以重复，多个列都可以标识为唯一索引
   3. 常规索引（key/index）：
      • 默认的，使用index或者key设置
   4. 全文索引（FullText）：
      • 快速定位数据

3. 使用：

   1. 在创建表的时候增加索引

   2. 创建完毕后，增加索引：

      1. ALTER TABLE 表名 add 索引类型 索引名 (列名1,列名2，列名3，...)

         --查看对应表的索引
         show index from student
          --增加一个全文索引
          ALTER TABLE student add FULLTEXT index `student_name` (`name`)
          --EXPLAIN:分析sql执行的状况
          EXPLAIN SELECT * FROM student  --非全文索引
         

      2. create 索引类型 索引名 on 表 （列名）

          CREATE UNIQUE INDEX `student_name` on student (name)
         

   3. 删除索引：DROP INDEX index_name ON table_name

       drop index `student_name` on student 
      

4. 索引原则：

   1. 索引不是越多越好
   2. 不要对经常变动的数据加索引
   3. 小数据量的表不需要加索引
   4. 索引一般加在常用来查询的字段

5. 索引的数据结构和原理：

   参考链接：http://blog.codinglabs.org/articles/theory-of-mysql-index.html

6. mysql优化：参考链接：参考链接;https://blog.csdn.net/jiadajing267/article/details/81269067

7.数据库的备份和用户管理

1. 备份：

   1. 方式：

      • 直接拷贝物理文件（data）

      • 直接在可视化工具里面导出导入

      • 使用命令行导出:在Bin目录下

        --导出
        --mysqldump -h主机 -u用户名 -p密码 数据库 [表1 表2 表3] >位置 
        mysqldump -hlocalhost -uroot -p18227022334a mysql user >D:/mysql_user.sql
        
        --导入
        --登录的情况下，切换到对应数据库
        --source 文件
        source D:/mysql_user.sql
        --未登录的情况下
        --mysql -u用户名 -p密码 库名 [表名]< 文件
        mysql -uroot -p18227022334a mysql user< D:/mysql_user.sql
        

2. 用户管理：

   1. navicat操作：
      

   2. sql命令操作：

      用户表：mysql数据库下的user表

      --创建用户:
      CREATE user 用户名 IDENTIFIED by 密码
      
      --修改密码
      ALTER USER 用户名@Host IDENTIFIED WITH mysql_native_password BY 密码
      
      --用户重命名
      RENAME user 用户名@Host to 新用户名@新Host
      
      --用户授权
      grant all privileges on *.* to 用户名@Host with grant option;
      
      --查询权限
      --撤销权限
      
      --删除用户
      DROP user 用户名@Host
      

8.规范数据库设计

1. 三大范式：

   1. 第一范式（1NF）：原子性：保证每一列不可再分
   2. 第二范式（2NF）：满足第一范式前提下，每张表只集中于一件事（比如姓名，性别，年龄，课程名称，课程成绩这张表就不满足第二范式，应该拆分为姓名，性别，年龄和姓名，课程名称，课程成绩两张表）
   3. 第三范式（3NF）：满足第二范式的前提下，确保数据表中每一列数据都跟主键直接相关，不能间接相关

2. 规范性和性能问题：

   阿里内部规定关联查询的表表的超过三张

   • 从成本和用户体验方面来说，性能更加重要
   • 在考虑性能问题的同时应该适当考虑下规范性
   • 可以故意增加一些冗余字段（从多表查询变成单表查询）
   • 故意增加一些计算列（从大数据量变为小数据量的查询：索引）

9.JDBC

1. 导入数据库驱动

2. jdbc：Java数据库连接，（Java Database Connectivity，简称JDBC）是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口应用程序接口，提供了诸如查询和更新数据库中数据的方法，我们通常说的JDBC是面向关系型数据库的。

3. 操作数据库步骤：

   1. 加载驱动:

       Class.forName("com.mysql.jdbc.cj.Driver");
      

   2. 用户信息和密码：

      String url="jdbc.url=jdbc:mysql://localhost:3306/dormitory_db?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai";
              String username="root";
              String password="18227022334a";
      

   3. 连接数据库：

      Connection conn= DriverManager.getConnection(url,username,password);
      

   4. 创建执行sql语句的Statement对象：

      Statement statement=conn.createStatement();
      

   5. 执行sql语句：

       String sql="SELECT * from room;";
              ResultSet resultSet = statement.executeQuery(sql);
      //遍历结果集获得数据
      while (resultSet.next()){
                  System.out.println(resultSet.getObject("id"));
                  System.out.println(resultSet.getObject("number"));
                  System.out.println(resultSet.getObject("building_name"));
                  System.out.println(resultSet.getObject("max_capacity"));
              }
      

   6. 释放连接：

      resultSet.close();
              statement.close();
              conn.close();
      

4. 连接数据库各对象：

   1. DriverManager：

       Class.forName("com.mysql.jdbc.cj.Driver"); //加载数据库驱动
      DriverManager.getConnection(url,username,password);//获得一个数据库的连接对象
      //url成分分析
      // jdbc:mysql://主机名:端口号/数据库名?参数
      

   2. connection：

      //相当于数据库
      connection.commit();//事务提交
      connection.rollback();//事务回滚
      connection.setAutoCommit();//设置自事务动提交
      connection.createStatement();//创建一个执行sql语句的
      

   3. Statement：

      statement.executeQuery(sql);//执行查询语句，返回结果集
      statement.execute(sql);//执行任何语句
      statement.executeUpdate(sql);//执行更新，插入，删除语句，返回受影响的行数
      

   4. resulSet：

      //遍历结果集
      resultSet.next();//光标移动到下一行，注：光标一开始是在第一行前面
      //获得数据
      resultSet.getObject();//不知道类型情况下使用
      resultSet.getXXX();//XXX为基本数据类型，根据指定的数据类型获得数据
      

   注：在最后都应该释放资源，释放的原则遵循：假如创建时顺序为abc，那么释放是cba

5. Statement对象存在的问题：sql注入问题且效率低

   //比如：模拟一个用户登录的场景
   //假设存在一个login(username,password)
   //由于使用statement执行sql语句时，传入了参数，则需要使用字符串的拼接
   String sql="select * from student where name ='"+name+"' and password = '"+"';";
   //当用户非法传入进行字符串的拼接时，就会导致数据库的泄露，比如
   login("' or '1=1'","' or '1=1'");
   /*此时会查询出数据库student表所有信息，因为参数传进来进行拼接后成为
   select * from student where name ="" or '1=1' and password="" or '1=1';
   */
   

6. 使用PreStatement对象：

   public int execUpdate(String sql, Object[] parms) {
           int count = 0;
           try {
               this.getConn();
               ps = conn.prepareStatement(sql);
               if (parms != null) {
                   for (int i = 0; i < parms.length; i++) {
                       ps.setObject(i + 1, parms[i]);
                   }
               }
               count = ps.executeUpdate();
               return count;
           } catch (SQLException e) {
               e.printStackTrace();
           } finally {
               //关闭数据库连接
               this.closeConn(conn, resultSet, ps);
           }
           return count;
       }
   

   注：PreparedStatement 防止 SQL 注入的原理就是把用户非法输入的单引号进行转义，最终传入参数作为一个整体执行，从而防止 SQL 注入，而 Statement 对象不会进行此操作。

7. idea操作数据库

8. jdbc操作事务：

   1、获得connection对象

   2、设置conn.setAutoCommit(false);

   3、只有执行conn.commit();才会一起提交，否则不会一起提交 conn.rollback(); 回滚方法

   public void test(){
           try {
            this.getConn();
               String sql1="update user set money=money-500 where user_name='张三'";
               String sql2="update user set money=money+500 where user_name='李四'";
               conn.setAutoCommit(false);//关闭自动提交，开启事务
               conn.prepareStatement(sql1).executeUpdate();
               int x=1/0;//模拟中途出错
               conn.prepareStatement(sql2).executeUpdate();
               conn.commit();//事务提交
           } catch (SQLException e) {
               try {
                   conn.rollback();//执行失败，事务回滚
               } catch (SQLException ex) {
                   ex.printStackTrace();
               }
               e.printStackTrace();
           }finally {
               closeConn(conn,null,null);
           }
       }
   

9. 数据库连接池：

   1. 数据库连接--执行完毕--释放

      由于连接--释放十分浪费系统资源，故而开发出池化技术

      池化技术：准备一些预先的资源，连接时连接预先准备好的

      比如：

      数据库最大资源数：20

      假设常用连接数：10

      那么最大连接数：20

      小于10的连接数直接使用，超过10小于20则需要使用备用的资源

      超过20那么进行一个等待

      如果等待时间过长，那么等待超时

   2. 编写连接池:实现一个接口DataSource

   3. 开源数据源：DBCP，C3P0，Druid：阿里巴巴，当使用了数据库连接池之后就不用我们自己去实现数据库的连接的代码的编写了

      1. DBCP：dataSource= BasicDataSourceFactory.createDataSource()，该数据源的相关信息是通过一个propertiee文件保存的，在配置数据源时直接读取该属性文件信息。
      2. C3P0：ComboPooledDataSource dataSource = new ComboPooledDataSource();该数据源信息是通过一个xml文件进行配置的，并且它可以配备多个数据源，在使用的时候可以指定使用哪个数据源。

      注：使用数据库连接池都是需要去实现一个dataSource接口。

这篇关于MySQL知识点大全！！的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！