Mysql

1. 操作数据库

操作数据库---操作数据库中的表---操作数据库中表的数据，关键字不区分大小写

1.1 操作数据库

0. 创建数据库

 CREATE DATABASE [IF NOT EXISTS] 数据库名

2. 删除数据库

 DROP DATABASE [IF EXISTS] 数据库名

3. 使用数据库

 USE 数据库名

4. 查看数据库

 SHOW DATABASES   查看所有的数据库

1.2 数据库的列类型

数值

• tinyint 非常小的数据 1个字节
• smallint 较小的数据 2个字节
• mediumint 中等大小的数据 3个字节
• int 标准 4个字节 常用
• bigint 较大的数据 8个字节
• float 浮点数 4个字节
• double 浮点数 8个字节
• decimal 字符串形式的浮点数 金融计算一般使用

字符串

• char 字符串固定大小 0~255
• varchar 可变字符串 0~65535 常用
• tinytext 微型文本 2^8-1
• text 文本串 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进行运算

1.3 数据库的字段属性

Unsigned

• 无符号的数
• 声明了该列不能为负数

zerofill

• 0填充的
• 不足的位数，用0来填充

自增

• 通常理解为自增，自动在一条记录的基础上 +1 (默认)
• 通常用来设计唯一的主键 index，必须是整数类型
• 可以自定义设计主键自增的初始值和步长

非空

• not null
• 设置为not null，如果不给他赋值就会报错
• NULL，默认为NULL

默认值

• 设置默认的值

拓展，之后做项目才会用到

/*每个表，都必须存在以下五个字段，未来做项目用，表示一个记录存在意义
​
id  主键
`version`  乐观锁
is_delete  伪删除
gmt_create  创建时间
gmt_update  修改时间
*/

1.4 创建数据库表

--注意点，使用英文(), 表的名称和字段尽量用 ``括起来
--AUTO_INCREMENT 自增
--字符串使用单引号括起来
--所有的语句后面都是英文的,最后一个不用加
--PRIMARY KEY 主键，一般一个表只有一个唯一的主键
CREATE TABLE IF NOT EXISTS `student`(
    `id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
    `name` VARCHAR(30) NOT NULL DEFAULT '匿名' COMMENT '姓名',
    `pwd` VARCHAR(20) NOT NULL DEFAULT '123456' COMMENT '密码',
    `sex` VARCHAR(2) NOT NULL DEFAULT '男' COMMENT '性别',
    `birthday` DATETIME DEFAULT NULL COMMENT '出生日期',
    `address` VARCHAR(100) DEFAULT NULL COMMENT '家庭住址',
    `email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
    PRIMARY KEY (`id`)
)ENGINE =INNODB DEFAULT CHARSET = utf8

格式：

CREATE TABLE [IF NOT EXISTS] `表明`(
    `字段名` 类型[类型][索引][注释],
    `字段名` 类型[类型][索引][注释],
    ......
    `字段名` 类型[类型][索引][注释]
)[表的类型][字符集设置][注释]

常用命令

SHOW CREATE DATABASE school --查看创建数据库的语句
SHOW CREATE TABLE student --查看创建数据库表的语句
DESC student--显示表的结构

2.5 数据表的类型

INNODB  默认使用
MYISAM  早期使用

	MYISAM	INNODB
事务支持	不支持	支持
数据行锁定	不支持	支持
外键约束	不支持	支持
全文索引	支持	不支持
表空间的大小	较小	较大，约为前者两倍

常用操作：

• MYISAM 节约空间，速度很快

• INNODB 安全性高，实务的处理，多表多用户操作

• 在物理空间的存在位置

  • 所有数据库文件都存在data目录下，本质还是文件的存储,一个文件夹对应一个数据库

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

• InnoDB 在数据库表中只有一个 *.frm文件，以及上级目录下的ibdata1文件

• MYISAM对应文件

  • *.frm 表结构的定义文件
  • *.MYD 数据文件(data)
  • *.myi 索引文件(index)

• 设置数据库表的字符集编码

CHARSET = UTF8

不设置的话，会是mysql默认的字符集编码（不支持中文）

MySQL的默认编码Latin1，不支持中文

在my.ini中配置默认的编码

1.6 修改删除表

修改

--修改表名， ALTER TABLE 旧表名 RENAME AS 新表名
ALTER TABLE school1 RENAME AS student

--增加表的字段	ALTER TABLE 表明 ADD 字段名 类型(长度)
ALTER TABLE student ADD age INT(11)

--修改表的字段(重命名，修改约束)
--ALTER TABLE 表明 MODIFY 字段名 列属性[]
ALTER TABLE student MODIFY age VARCHAR(10) --修改约束

--ALTER TABLE 表明 CHANGE 旧名字 新名字 列属性[]
ALTER TABLE student CHANGE age age1 INT(11)  --字段重命名
--CHANGE用来字段重命名，不能修改字段类型和约束；MODIFY不用来字段重命名，只能修改字段类型和约束

--删除表的字段  ALTER TABLE 表明 DROP 字段名
ALTER TABLE student DROP age1

删除

--删除表
DROP TABLE [IF EXISTS] student    --如果表不存在就删除

• 所有的创建和删除操作尽量加上判断，以免报错

2. MySQL数据管理

2.1 外键

方式一，在创建表的时候，增加约束(比较麻烦)

CREATE TABLE `grade`(
	`gradeid` INT(10) NOT NULL AUTO_INCREMENT COMMENT '年级id',
	`gradename` VARCHAR(50) NOT NULL COMMENT '年级名称',
	PRIMARY KEY(`gradeid`)
)ENGINE=INNODB DEFAULT CHARSET = utf8

--学生表gradeid字段要去引用年级表中的gradeid
--定义外键KEY
--给这个外键添加约束 REFERENCES引用

CREATE TABLE IF NOT EXISTS `student`(
	`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
	`name`VARCHAR(30) NOT NULL DEFAULT '匿名' COMMENT '姓名',
	`pwd` VARCHAR(20) NOT NULL DEFAULT '123456' COMMENT '密码',
	`sex` VARCHAR(2) NOT NULL DEFAULT '女' COMMENT '性别',
	`birthday` DATETIME DEFAULT NULL COMMENT '出生日期',
	`gradeid` INT(10) NOT NULL COMMENT '学生的年纪',
	`address`VARCHAR(100) DEFAULT NULL COMMENT '家庭住址',
	`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
	PRIMARY KEY (`id`),
	KEY `FK_gradeid` (gradeid),
	CONSTRAINT `FK_gradeid` FOREIGN KEY(`gradeid`) REFERENCES `grade`(`gradeid`)
)ENGINE=INNODB DEFAULT CHARSET = utf8

• 注意：删除外键关系的表的时候，必须要先删除引用别人的表(从表)，在删除被引用的表（主表）

方式二，两个表创建成功后，添加外键约束

CREATE TABLE `grade`(
	`gradeid` INT(10) NOT NULL AUTO_INCREMENT COMMENT '年级id',
	`gradename` VARCHAR(50) NOT NULL COMMENT '年级名称',
	PRIMARY KEY(`gradeid`)
)ENGINE=INNODB DEFAULT CHARSET = utf8

--学生表gradeid字段要去引用年级表中的gradeid
--定义外键KEY
--给这个外键添加约束 REFERENCES引用

CREATE TABLE IF NOT EXISTS `student`(
	`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',
	`name`VARCHAR(30) NOT NULL DEFAULT '匿名' COMMENT '姓名',
	`pwd` VARCHAR(20) NOT NULL DEFAULT '123456' COMMENT '密码',
	`sex` VARCHAR(2) NOT NULL DEFAULT '女' COMMENT '性别',
	`birthday` DATETIME DEFAULT NULL COMMENT '出生日期',
	`gradeid` INT(10) NOT NULL COMMENT '学生的年纪',
	`address`VARCHAR(100) DEFAULT NULL COMMENT '家庭住址',
	`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
	PRIMARY KEY (`id`)
)ENGINE=INNODB DEFAULT CHARSET = utf8
--创建表的时候没有外键关系
ALTER TABLE `student`
ADD CONSTRAINT `FK_gradeid` FOREIGN KEY(`gradeid`) REFERENCES `grade`(`gradeid`);

--ALTER TABLE 表 ADD CONSTRAINT 约束名 FOREIGN KEY(外键的列) REFERENCES 另一个表(字段);

• 以上的操作都是物理外键，数据库级别的外键，不建议使用，避免数据库过多造成困扰，了解即可

2.2 DML语言(数据库操作语言)

• 添加 insert

--插入语句(添加),如果不写字段，就会一一匹配
--INSERT INTO 表明[(字段名1，字段名2，字段名3,...)]VALUE('值1','值2','值3',...)
INSERT INTO `grade` (`gradename`) VALUES('大三') --插入一行数据

INSERT INTO `grade` (`gradename`) VALUES ('大二'),('大一') --插入两行数据

• 修改 update

--修改名字,带where是指定一条修改
UPDATE 	`student` SET `name` = '王五' WHERE id = 1001

--不指定条件的情况下，会改动所有记录
UPDATE 	`student` SET `name` = '王五'

--语法：
--UPDATE 表名 SET COLNUM_NAME = VALUE [,COLNUM_NAME = VALUE...] [WHERE 条件] 

• 删除 delete

语法： delete from 表明 [where 条件]

--删除数据，（会全部删除）
DELETE FROM `student`

--删除指定数据
--DELETE FROM `student` WHERE id = 1;

TRUNCATE命令

• 完全清空一个数据库表，表的索引 结构不会变

TRUNCATE [TABLE] 表名

delete 和 TRUNATE 区别

• 相同点：都能删除数据，都不会删除表结构

• 不同点：

  • TRUNCATE 重新设置自增列 计数器会归零
  • TRUNCATE 不会影响事务

delete from student --不会影响自增
truncate table student --自增归零

了解：delete删除的问题，重启数据库现象

• InnoDB 自增列会从1开始（存在内存当中，断电即失败）
• MyISAM 继续从上一个自增量开始(存在文件中，不会丢失)

3. DQL 查询数据

3.1 DQL （数据查询语言）

• 所有的查询操作都用它，select
• 简单的查询，复杂的查询都用他做
• 数据库中最核心的语言，最重要的语句
• 使用频率最高的语句

3.2 指定查询字段

--查询表中所有的字段	SELECT 字段 FROM 表明
SELECT * FROM student

--查询指定字段
SELECT studentname FROM student

--别名，给结果起一个名字 AS 可以给字段，也可以给表起别名
SELECT studentname AS 姓名 FROM student

--函数 CONCAT(a,b)
SELECT CONCAT('姓名：',studentname) FROM student

语法： SELECT 字段,... FROM 表名

去重复：dist

SELECT DISTINCT studentno FROM result --去掉重复数据查询

3.3 where条件字句

作用：检索数据中符合条件的值，返回值是布尔值

逻辑运算符

运算符	语法	描述
and &&	a and b	与，都为真，结果为真
or			a or b	或，一个为真，结果为真
not !	not a	非，相反，真为假，假为真

模糊查询：比较运算符

运算符	语法	描述
is null	a is null	如果操作符为null，结果为真
is not null	a is not null	如果操作符为not null，结果为真
between and	a between b and c	若a在b和c之间为真
like	a like b，%表示多个，_表示一个	如果a匹配到b，则结果为真
in	a in (a1,a2,a3)	假设a在括号中，则结果为真

3.4 联表查询

JOIN on

操作	描述
Inner join	如果表中至少有一个匹配，就返回行
right join	从右表中返回所有的值，即使右表中没有匹配
left join	从左表中返回所有的值，即使右表中没有匹配

SELECT student.studentno,studentname,subjectno,studentresult 
FROM student
RIGHT JOIN result
ON student.studentno = result.studentno

SELECT student.studentno,studentname,subjectno,studentresult 
FROM student
LEFT JOIN result
ON student.studentno = result.studentno

SELECT student.studentno,studentname,subjectno,studentresult 
FROM student
INNER JOIN result
ON student.studentno = result.studentno

自连接：自己的表和自己的表连接，核心：一张表拆分为两张不一样的表

3.5 分页和排序

排序

--ORDER BY 字段 ASC(升序,默认) DESC(降序)

SELECT DISTINCT student.studentname,studentresult 
FROM student 
INNER JOIN result
ON student.studentno = result.studentno
ORDER BY studentresult DESC

分页 (n-1)*pageSize n:当前页 总页数=数据总数/页面大小

--分页，每页显示3条数据
--语法： LIMIT 起始值，页面的大小

SELECT DISTINCT student.studentname,studentresult 
FROM student 
INNER JOIN result
ON student.studentno = result.studentno
ORDER BY studentresult DESC
LIMIT 0,3

4. MySQL函数

4.1 常用函数

--数学运算函数
SELECT ABS(-8)  --绝对值
SELECT CEILING(9.4)  --向上取整
SELECT FLOOR(9.4)  --向下取整
SELECT RAND()  --返回一个0~1之间的随机数
SELECT SIGN(-10)  --判断一个数的符号

--字符串函数
SELECT CHAR_LENGTH('中国')  --返回字符串长度
SELECT CONCAT('wo','men')  --拼接字符串
SELECT INSERT('hello，world',2,2,'00')  --插入，替换
SELECT LOWER('ABCDEF')  --转换为小写
SELECT UPPER('abcdef')  --转换为大写
SELECT INSTR('abcdef','a')  --返回下标
SELECT REPLACE('abcdef','a','000')  --替换
SELECT SUBSTR('abcdef',2,2)  --返回指定的字符串
SELECT REVERSE('abcdef')  --反转

--时间和日期函数
SELECT CURRENT_DATE()  --获取当前日期
SELECT CURDATE()  --获取当前日期
SELECT NOW()  --获取当前的时间日期
SELECT LOCALTIME()  --本地时间

--系统
SELECT SYSDATE()  --系统时间
SELECT USER()
SELECT VERSION()

4.2 聚合函数

函数名称
COUNT()	统计
SUM()	求和
AVG()	平均值
MAX()	最大值
MIN()	最小值

5. 事务

要么都成功，要么都失败， 将一组SQL放在一批次中去执行

事务原则：ACID原则，原子性，一致性，隔离性，持久性

• 原子性(Atomicity)：要么都成功，要么都失败
• 一致性(Consistency)：事务前后的数据完整性保持一致
• 持久性(Durability)：事务一旦提交不可逆，被持久化到数据库中
• 隔离性(Isolation)：事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所以事务之间要相互隔离

隔离导致的一些问题：

脏读：指一个事务读取了另外一个事务未提交的数据

不可重复读：在一个事务内读取表中的某一行数据，多次读取结果不同。

虚读(幻读)：指在一个事务读取到了别的事务插入的数据，导致前后读取不一致。

-- mysql 是默认开启事务自动提交的
SET autocommit = 0  /*关闭*/
SET autocommit = 1  /*开启(默认)*/

-- 手动处理事务
SET autocommit = 0  -- 关闭自动提交

-- 事务开启
START TRANSACTION  -- 标记一个事务的开始，从这个之后的sql都在同一个事务内

INSERT xx
INSERT xx

-- 提交：持久化(成功)
COMMIT
-- 回滚：回到原来的样子（失败）
ROLLBACK

-- 事务结束
SET autocommit = 1  -- 开启自动提交

-- 了解
SAVEPOINT 保存点名 -- 设置一个事务的保存点
ROLLBACK TO SAVEPOINT 保存点名  -- 回滚到保存点
RELEASE SAVEPOINT  保存点名  -- 撤销保存点

模拟转账，事务

CREATE DATABASE shop CHARACTER SET utf8 COLLATE utf8_general_ci
USE shop

CREATE TABLE `account`(
	`id` INT(3) NOT NULL AUTO_INCREMENT,
	`name` VARCHAR(30) NOT NULL,
	`money` DECIMAL(9,2) NOT NULL,
	PRIMARY KEY(`id`)
)ENGINE = INNODB DEFAULT CHARSET = utf8

INSERT INTO account(`name`,`money`)
VALUES('A',2000.00),('B',10000.00)

SELECT * FROM account


-- 模拟转账：事务
SET autocommit = 0  -- 关闭自动提交
START TRANSACTION  -- 开启一个事务

UPDATE account SET money = money -500 WHERE `name` = 'A' -- A减500
UPDATE account SET money = money + 500 WHERE `name` = 'B'  -- A加500

COMMIT;  -- 提交事务
ROLLBACK; -- 回滚
 
SET autocommit = 1;  -- 恢复默认值

6.索引

MySQL官方对索引的定义为：索引（Index）是帮助MySQL高效地获取数据的数据结构，

提取句子主干，就可以得到索引的本质：索引就是数据结构

6.1 索引的分类

在一个表中，主键索引只能有一个，唯一索引可以有多个

• 主键索引(PRIMARY KEY)

  • 唯一标识，主键不可重复，只能有一个列作为主键

• 唯一索引(UNIQUE KEY)

  • 避免重复的列出现，可以重复，多个列都可以标识为唯一索引

• 常规索引(KEY/INDEX)

  • 默认的，index，key关键字来设置

• 全文索引(FullText)

  • 在特定的数据库引擎下采用，快速定位数据

CREATE [UNIQUE|FULLTEXT|SPATIAL] INDEX 索引名 
[index_type] 
ON 表明 (index_col_name,...) 
[index_type] 
------
index_col_name: 
col_name [(length)] [ASC | DESC]

index_type: 
USING {BTREE | HASH | RTREE}

6.2 索引原则

• 索引不是越多越好
• 不要给经常变动的数据加索引
• 小数据量的表需要加索引
• 索引一般加在常用来查询的字段上

7.权限管理和备份

-- 创建用户 CREATE USER 用户名 IDENTIFIED BY '密码'
CREATE USER lili IDENTIFIED BY '123456'

-- 修改密码（修改当前用户密码）
SET PASSWORD = PASSWORD('root')

-- 修改指定用户密码
SET PASSWORD FOR li = PASSWORD('123456')
 
-- 重命名  rename user 原来名字 to 新的名字
RENAME USER li TO li1

-- 用户授权  ALL PRIVILEGES  全部的权限 ,库.表
GRANT ALL PRIVILEGES ON *.* TO li1

-- 查询权限
SHOW GRANTS FOR li1   -- 查看指定用户的权限
SHOW GRANTS FOR  root@localhost  -- 查看root用户的权限

-- 撤销权限 REVOKE
REVOKE ALL PRIVILEGES ON *.* FROM  li1

-- 删除用户
DROP USER lili

8. JDBC

8.1 JDBC驱动

public class lesson01 {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver"); //固定写法，加载驱动

        //2.用户信息 url
        //useUnicode=true&characterEncoding=utf8&useSSL=true 1.设置中文编码,2.设置utf8,3.安全连接
        String url = "jdbc:mysql://localhost:3306/study?useUnicode=true&characterEncoding=utf8&useSSL=true";
        String username = "root";
        String password = "root";

        //3.连接成功，数据库对象 Connection代表数据库
        Connection connection = DriverManager.getConnection(url, username, password);

        //4.执行SQL的对象 Statement执行sql的对象
        Statement statement = connection.createStatement();

        //5.执行SQL的对象,可能存在结果，查看返回结果
        String sql = "select * from users";
        ResultSet resultSet = statement.executeQuery(sql);//返回的结果集合,结果集中封装了全部查询出来的结果
        while(resultSet.next()){
            System.out.println("id="+resultSet.getObject("id"));
            System.out.println("name="+resultSet.getObject("name"));
            System.out.println("password="+resultSet.getObject("password"));
            System.out.println("email="+resultSet.getObject("email"));
            System.out.println("birthday="+resultSet.getObject("birthday"));
        }

        //6.释放连接
        resultSet.close();
        statement.close();
        connection.close();

    }
}

连接数据库步骤：

1. 加载驱动
2. 连接数据库DriverManager
3. 获得执行sql的对象  Statement
4. 获得返回的结果集
5. 释放连接

DriverManager

//DriverManager.registerDriver(new com.mysql.jdbc.Driver);
Class.forName("com.mysql.jdbc.Driver"); //固定写法，加载驱动

Connection connection = DriverManager.getConnection(url, username, password);
//connection  代表数据库
//数据库设置自动提交		connection.setAutoCommit();
//事务提交		connection.commit();
//事务回滚		connection.rollback();

URL

String url = "jdbc:mysql://localhost:3306/study?useUnicode=true&characterEncoding=utf8&useSSL=true";

//useUnicode=true&characterEncoding=utf8&useSSL=true 1.设置中文编码,2.设置utf8,3.安全连接

//mysql  -- 端口号：3306
//jdbc:mysql://主机地址:端口号/数据库名?参数1&参数2&参数3

Statement 具体执行sql的对象

statement.executeQuery();	//查询操作返回ResultSet
statement.execute();		//执行任何SQL
statement.executeUpdate();	//更新，插入，删除，都用这个，返回一个受影响的行数

ResultSet 查询的结果集，封装了所有的查询结果

获得指定的结果集

resultSet.getObject();	//在不知列类型的情况下使用
//如果知道列类型使用指定的类型
resultSet.getString();	
resultSet.getInt();
resultSet.getFloat();
resultSet.getDate();
resultSet.get ... 

遍历

resultSet.beforeFirst();		//移动到最前面
resultSet.afterLast();			//移动到最后面
resultSet.next();				//移动到下一个数据
resultSet.previous();			//移动到前一行
resultSet.absolute(row);		//移动到指定行

释放资源

resultSet.close();
statement.close();
connection.close();	//比较耗费资源，全部关闭

8.2 statement对象

JDBC中的statement对象用于向数据库发送SQL语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可。

Statement对象的executeUpdate方法，用于向数据库发送增、删、改的sql语句，executeUpdate执行后，将会返回一个整数(即增删改语句导致了数据库几行数据发生了变化)。

Statement.executeQuery方法用于向数据库发送查询语句，executeQuery方法返回代表查询结果的ResultSet对象。

insert 增

使用executeUpdate(String sql)方法完成数据添加操作

Statement st = connection.createStatement();
String sql = "inser into user() values ()";
int num = st.executeUpdate(sql);
if (num > 0) {
     System.out.println("插入成功");
}

delete 删

使用executeUpdate(String sql)方法完成数据删除操作

Statement st = connection.createStatement();
String sql = "delete * from users where id = ?";
int num = st.executeUpdate(sql);
if (num > 0) {
     System.out.println("删除成功");
}

update 改

使用executeUpdate(String sql)方法完成数据修改操作

Statement st = connection.createStatement();
String sql = "update user set name = '' where name = ''";
int num = st.executeUpdate(sql);
if (num > 0) {
     System.out.println("修改成功");
}

query 查询

使用executeQuery(String sql)方法完成数据查询

Statement st = connection.createStatement();
String sql = "select * from user where id = 1";
ResultSet rs = st.executeQuery(sql);
while(re.next()){
    //根据获取列的数据类型，分别调用rs的相应方法映射到java对象中
}

8.3 封装工具类

用户信息 db.properties 类

driver = com.mysql.jdbc.Driver
url = jdbc:mysql://localhost:3306/study?useUnicode=true&characterEncoding=utf8&useSSL=true
username = root
password = root

连接工具类

package jdbcUtils;

import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class jdbcUtils {

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

    static {
        try {

            InputStream in = jdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
            Properties properties = new Properties();
            properties.load(in);

            driver = properties.getProperty("driver");
            url = properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");

            //1.驱动只需要加载一次
            Class.forName(driver);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //获取连接
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }

    //释放连接资源
    public static void release(Connection conn, Statement st, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (st != null) {
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

test insert , delete ,update 与之类似，只需修改sql语句就行

package edu.lfsfxy;

import jdbcUtils.jdbcUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class Test {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;

        try {
            //1.获取数据库连接
            conn = jdbcUtils.getConnection();
            //2.获得SQL的执行对象
            st = conn.createStatement();

            String sql = "INSERT INTO users (id,name,password,email,birthday) VALUES (4,'zhao','123456','zhao@qq.com','2020-04-04')";
            
            int i = st.executeUpdate(sql);
            if (i > 0) {
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            jdbcUtils.release(conn, st, rs);
        }
    }
}

test query

package edu.lfsfxy;

import jdbcUtils.jdbcUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class Test {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;

        try {
            //1.获取数据库连接
            conn = jdbcUtils.getConnection();
            //2.获得SQL的执行对象
            st = conn.createStatement();
            
            String sql = "select * from users";

            rs = st.executeQuery(sql);

            while (rs.next()){
                System.out.println(rs.getString("name"));
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            jdbcUtils.release(conn, st, rs);
        }
    }
}

8.4 PreparedStatement对象

可以防止SQL注入，效率更好

package edu.lfsfxy;

import jdbcUtils.jdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Date;

public class testinsert {
    public static void main(String[] args) {

        Connection conn = null;
        PreparedStatement st = null;

        try {
            conn = jdbcUtils.getConnection();
            //区别
            String sql = "INSERT INTO users (id,name,password,email,birthday) VALUES (?,?,?,?,?)";

            st = conn.prepareStatement(sql);//预编译SQL,先写sql，然后不执行

            //手动给参数赋值
            st.setInt(1, 4);
            st.setString(2, "zhao");
            st.setString(3, "123456");
            st.setString(4, "zhoa@qq.com");
            st.setDate(5, new java.sql.Date(new Date().getTime()));

            int i = st.executeUpdate();
            if (i > 0) {
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            jdbcUtils.release(conn, st,null);
        }
    }
}

本章知识学习自