JDBC-用Java语句操作数据库

JDBC

1. Jdbc概述

问题：实际开发中，不可能用工具或者命令行操作数据库，数据库表中的数据最终要使用Java程序来操作,那么Java中如何操作数据库中的数据呢？

答：在Java语言中，有一个专门连接数据库的规范（JDBC），专门负责连接数据库进行数据操作的规范

JDBC只是SUN编写的一堆接口（规范的体现），SUN公司自己并没有实现

问题：为什么SUN只定义一个JDBC规范，而不实现呢？

答：因为市面上的数据库很多，每个数据库内部接口不会向外暴露，而且即便是暴露让SUN去实现，市面上很多数据库全部要SUN来实现不现实

实际中哪个数据库需要支持JAVA语言，就需要自己实现Java的JDBC规范，因为实现了JDBC很多接口，那么就会有很多实现类，而很多实现类在java中会使用一个专门的包封装起来，叫做jar包（在JDBC中叫做驱动包），各大数据库产商实现JDBC规范以后都会把他们jar包放在官网上以供开发者下载使用

1.1. JDBC

JDBC(Java DataBase Connectivity):

是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基

JDBC规范对应的api包

2.java连接数据库

以连接mysql为例

2.1. 创建普通java项目

2.2. 在项目下面新建一个lib目录

2.3. 将MySQL驱动包拷贝到项目中并添加依赖

2.5 获取数据库连接对象

准备:

1.拷贝MySQL的驱动包到项目中去:mysql-connector-java-5.1.x-bin.jar

2.build path,告速项目去哪里去找字节码文件.

--------------------------------------------------------------------------------

操作JDBC的第一步,获取JDBC的连接对象.:Connection.

步骤:

1.加载注册驱动.

就是把驱动中的Driver字节码加载到JVM中.

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

为什么这句话就可以加载注册驱动?

第一步:把com.mysql.jdbc.Driver.class这份字节码加载到JVM中.

第二步:当一份字节码被加载进JVM,马上就会执行该字节码中的静态代码块.

第三步:该静态代码中,就在完成,先创建驱动对象,再注册.

2.通过DriverManager获取连接对象.

public static Connection getConnection(String url,String user,String password)

Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/dbName","root","admin");

jdbc:mysql://localhost:3306/dbName

jdbc:mysql:// ：连接MySQL数据库的协议，不同数据库协议不一样

localhost:3306 ：数据库软件的主机和端口

dbName ：具体要连接数据库

若数据库安装在本机,并且端口是默认的3306,则可以简写:

Connection conn = DriverManager.getConnection("jdbc:mysql:///dbName","root","admin");

验证已经获取连接:可以在MySQL控制台,使用命令:show processlist; 查看MySQL运行进程.

 1 public class GetConnectionDemo {
 2     public static void main(String[] args) throws Exception {
 3         
 4         //1.加载注册驱动 : 把当前类对应的字节码加载到JVM中
 5         Class.forName("com.mysql.jdbc.Driver");
 6         //2.获取数据库连接
 7         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root");
 8         System.out.println(conn);
 9         
10     }
11 }

3. 创建表-DDL操作

在其他操作之间先要把数据库表要创建出来

/贾琏欲执事

创建一张t_student表:

id:

name:

age:

 1 //DML : 对表数据的增删改操作
 2 public class DMLDemo {
 3 
 4     /*
 5      * 向 t_student表中插入一条数据 
 6      * sql ： insert into t_student(name,age) values ('乔峰',30)
 7      */
 8     @Test
 9     public void testInsert() throws Exception {
10         String sql = "insert into t_student(name,age) values ('乔峰',30)";
11         
12         // 1.加载注册驱动
13         Class.forName("com.mysql.jdbc.Driver");
14 
15         // 2.获取数据库连接对象
16         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root");
17         // 3.创建语句对象
18         Statement st = conn.createStatement();
19         
20         // 4.执行SQL语句
21         // int rows = st.executeUpdate(String sql);执行DDL和DML语句,放回的是受影响的行数
22         // ResultSet res = st.executeQuery(String sql);执行DQL查询语句，返回的结果集对象
23         int rows = st.executeUpdate(sql);
24         System.out.println(rows);
25         //5.释放资源（先开后关）
26         st.close();
27         conn.close();
28 
29     }
30     /*
31      * 删除操作： 删除t_student表中的某一条数据
32      * SQL ：delete from t_student where id = 2
33      */
34     @Test
35     public void testDelete() throws Exception {
36         String sql = "delete from t_student where id = 2";
37         
38         // 1.加载注册驱动
39         Class.forName("com.mysql.jdbc.Driver");
40 
41         // 2.获取数据库连接对象
42         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root");
43         // 3.创建语句对象
44         Statement st = conn.createStatement();
45         
46         // 4.执行SQL语句
47         // int rows = st.executeUpdate(String sql);执行DDL和DML语句,放回的是受影响的行数
48         // ResultSet res = st.executeQuery(String sql);执行DQL查询语句，返回的结果集对象
49         int rows = st.executeUpdate(sql);
50         System.out.println(rows);
51         //5.释放资源（先开后关）
52         st.close();
53         conn.close();
54     }
55     /*
56      * 修改操作 ： 修改t_student表中的某一条数据
57      * SQL ： update t_student set name = '虚竹',age = 50 where id = 3
58      */
59     @Test
60     public void testUpdate() throws Exception {
61         String sql = "update t_student set name = '虚竹',age = 50 where id = 3";
62         
63         // 1.加载注册驱动
64         Class.forName("com.mysql.jdbc.Driver");
65 
66         // 2.获取数据库连接对象
67         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root");
68         // 3.创建语句对象
69         Statement st = conn.createStatement();
70         
71         // 4.执行SQL语句
72         // int rows = st.executeUpdate(String sql);执行DDL和DML语句,放回的是受影响的行数
73         // ResultSet res = st.executeQuery(String sql);执行DQL查询语句，返回的结果集对象
74         int rows = st.executeUpdate(sql);
75         System.out.println(rows);
76         //5.释放资源（先开后关）
77         st.close();
78         conn.close();
79     }
80 }

4.DML操作-表数据的增删改

 1 //DML : 对表数据的增删改操作
 2 public class DMLDemo {
 3 
 4     /*
 5      * 向 t_student表中插入一条数据 
 6      * sql ： insert into t_student(name,age) values ('乔峰',30)
 7      */
 8     @Test
 9     public void testInsert() throws Exception {
10         String sql = "insert into t_student(name,age) values ('乔峰',30)";
11         
12         // 1.加载注册驱动
13         Class.forName("com.mysql.jdbc.Driver");
14 
15         // 2.获取数据库连接对象
16         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root");
17         // 3.创建语句对象
18         Statement st = conn.createStatement();
19         
20         // 4.执行SQL语句
21         // int rows = st.executeUpdate(String sql);执行DDL和DML语句,放回的是受影响的行数
22         // ResultSet res = st.executeQuery(String sql);执行DQL查询语句，返回的结果集对象
23         int rows = st.executeUpdate(sql);
24         System.out.println(rows);
25         //5.释放资源（先开后关）
26         st.close();
27         conn.close();
28 
29     }
30     /*
31      * 删除操作： 删除t_student表中的某一条数据
32      * SQL ：delete from t_student where id = 2
33      */
34     @Test
35     public void testDelete() throws Exception {
36         String sql = "delete from t_student where id = 2";
37         
38         // 1.加载注册驱动
39         Class.forName("com.mysql.jdbc.Driver");
40 
41         // 2.获取数据库连接对象
42         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root");
43         // 3.创建语句对象
44         Statement st = conn.createStatement();
45         
46         // 4.执行SQL语句
47         // int rows = st.executeUpdate(String sql);执行DDL和DML语句,放回的是受影响的行数
48         // ResultSet res = st.executeQuery(String sql);执行DQL查询语句，返回的结果集对象
49         int rows = st.executeUpdate(sql);
50         System.out.println(rows);
51         //5.释放资源（先开后关）
52         st.close();
53         conn.close();
54     }
55     /*
56      * 修改操作 ： 修改t_student表中的某一条数据
57      * SQL ： update t_student set name = '虚竹',age = 50 where id = 3
58      */
59     @Test
60     public void testUpdate() throws Exception {
61         String sql = "update t_student set name = '虚竹',age = 50 where id = 3";
62         
63         // 1.加载注册驱动
64         Class.forName("com.mysql.jdbc.Driver");
65 
66         // 2.获取数据库连接对象
67         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root");
68         // 3.创建语句对象
69         Statement st = conn.createStatement();
70         
71         // 4.执行SQL语句
72         // int rows = st.executeUpdate(String sql);执行DDL和DML语句,放回的是受影响的行数
73         // ResultSet res = st.executeQuery(String sql);执行DQL查询语句，返回的结果集对象
74         int rows = st.executeUpdate(sql);
75         System.out.println(rows);
76         //5.释放资源（先开后关）
77         st.close();
78         conn.close();
79     }
80 }

5. DQL操作-查询操作

5.1. 查询操作的分析

5.2 查询具体操作

结果集的列的位置

1.使用 rs.next() 偏移光标，循环指定具体的某一行

获取数据的具体方法

Object	getObject(int columnIndex) columnIndex ：通过结果集的位置（1开始）获取对应的数据
Object	getObject(String columnLabel) columnLabel : 通过结果集的列名获取对应的数据

  1 package cn.sxt.jdbc._01connection;
  2 
  3 
  4 import java.sql.Connection;
  5 import java.sql.DriverManager;
  6 import java.sql.ResultSet;
  7 import java.sql.Statement;
  8 import java.util.ArrayList;
  9 import java.util.List;
 10 
 11 import org.junit.Test;
 12 
 13 //DQL :查询操作
 14 public class D_DQLDemo {
 15     
 16     /*
 17      * 多行查询 ：查询t_student表中的所有数据
 18      * SQL ： select * from t_student
 19      */
 20     @Test
 21     public void testList() throws Exception {
 22         String sql = "select * from t_student";
 23         
 24         // 1.加载注册驱动
 25         Class.forName("com.mysql.jdbc.Driver");
 26 
 27         // 2.获取数据库连接对象
 28         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root");
 29         // 3.创建语句对象
 30         Statement st = conn.createStatement();
 31         
 32         // 4.执行SQL语句
 33         // int rows = st.executeUpdate(String sql);执行DDL和DML语句,放回的是受影响的行数
 34         // ResultSet res = st.executeQuery(String sql);执行DQL查询语句，返回的结果集对象
 35         ResultSet rs = st.executeQuery(sql);
 36         
 37         
 38         //创建list集合用于封装Student对象
 39         List<Student> stus = new ArrayList<>();
 40         
 41         while(rs.next()) {
 42             //1.通过结果集的位置获取对应的数
 43             /*Object id = rs.getObject(1);
 44             Object name = rs.getObject(2);
 45             Object age = rs.getObject(3);*/
 46             
 47             //2.通过结果集的 列名获取对应的数据
 48             /*Object id = rs.getObject("id");
 49             Object name = rs.getObject("name");
 50             Object age = rs.getObject("age");*/
 51             //3.通过数据库数据和Java对应的数据类型获取对应的只
 52             int id = rs.getInt("id");
 53             String name = rs.getString("name");
 54             int age = rs.getInt("age");
 55             //System.out.println(id+","+name+","+age);
 56             
 57             //将获取的数据封装成对应的Student对象
 58             Student stu = new  Student(id, name, age);
 59             
 60             //将一个个Student对象添加到list集合中
 61             stus.add(stu);
 62         }
 63         
 64         for (Student student : stus) {
 65             System.out.println(student);
 66         }
 67         //5.释放资源（先开后关）
 68         rs.close();
 69         st.close();
 70         conn.close();
 71     }
 72     
 73     
 74     /*
 75      * 单行查询： 查询出t_student 指定id的信息
 76      * SQL : select * from t_student where id = 1;
 77      */
 78     @Test
 79     public void testGetOne() throws Exception {
 80         String sql = "select * from t_student where id = 2";
 81         
 82         // 1.加载注册驱动
 83         Class.forName("com.mysql.jdbc.Driver");
 84 
 85         // 2.获取数据库连接对象
 86         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root");
 87         // 3.创建语句对象
 88         Statement st = conn.createStatement();
 89         
 90         // 4.执行SQL语句
 91         // int rows = st.executeUpdate(String sql);执行DDL和DML语句,放回的是受影响的行数
 92         // ResultSet res = st.executeQuery(String sql);执行DQL查询语句，返回的结果集对象
 93         ResultSet rs = st.executeQuery(sql);
 94         
 95         if(rs.next()) {
 96             //1.通过结果集的位置获取对应的数
 97             /*Object id = rs.getObject(1);
 98             Object name = rs.getObject(2);
 99             Object age = rs.getObject(3);*/
100             
101             //2.通过结果集的 列名获取对应的数据
102             /*Object id = rs.getObject("id");
103             Object name = rs.getObject("name");
104             Object age = rs.getObject("age");*/
105             //3.通过数据库数据和Java对应的数据类型获取对应的只
106             int id = rs.getInt("id");
107             String name = rs.getString("name");
108             int age = rs.getInt("age");
109             //System.out.println(id+","+name+","+age);
110             
111             //将获取的数据封装成对应的Student对象
112             Student stu = new  Student(id, name, age);
113             System.out.println(stu);
114         }
115         //5.释放资源（先开后关）
116         rs.close();
117         st.close();
118         conn.close();    
119     }
120 }

6. 预编译语句对象PreparedStatment

问题：我们有了Statment对象可以执行SQL，为什么还要使用PreparedStatment？

优势

SQL语句结构清晰，参数的设置和SQL语句分离
性能更高
防止SQL注入

Statement: 表示静态SQL语句对象.

PreparedStatement:Statement的子接口,表示预编译SQL语句对象. 通过占位符(?)来拼SQL.

6.1 创建PreparedStatement

创建语句对象 Statment

Statement

createStatement()
创建一个 Statement 对象来将 SQL 语句发送到数据库。

创建预编译语句对象PreparedStatement

PreparedStatement	prepareStatement(String sql) 创建预编译语句对象,SQL是带有占位符的SQL模板.

6.2. 执行SQL语句的方法

6.2.1. Statment

在执行SQL语句的时候回带上SQL语句

ResultSet	executeQuery(String sql) 执行给定的 SQL 语句，该语句返回单个 ResultSet 对象。
int	executeUpdate(String sql) 执行给定 SQL 语句，该语句可能为 INSERT、UPDATE 或 DELETE 语句，或者不返回任何内容的 SQL 语句（如 SQL DDL 语句）。

6.2.2. PreparedStatement

在执行SQL语句的方法中不需要设置SQL语句

ResultSet	executeQuery() 在此 PreparedStatement 对象中执行 SQL 查询，并返回该查询生成的 ResultSet 对象。
int	executeUpdate() 在此 PreparedStatement 对象中执行 SQL 语句，该语句必须是一个 SQL 数据操作语言（Data Manipulation Language，DML）语句，比如 INSERT、UPDATE 或 DELETE 语句；或者是无返回内容的 SQL 语句，比如 DDL 语句。

6.3. 设置站位参数的值

void setXxx(int parameterIndex,Xxx value):用于设置占位符参数,

parameterIndex:第几个问号. 注意:从1开始.

value:设置的真实值.

Xxx:表示数据类型.String/int/long/Double/Date

6.4. 代码

package cn.sxt.jdbc._01connection;

import static org.junit.Assert.*;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.PreparedStatement;

import org.junit.Test;

//DML : 对表数据的增删改操作,使用预编译语句对象

public class E_DMLByPreparedStatmentDemo {

* 向 t_student表中插入一条数据

* sql ： insert into t_student(name,age) values ('乔峰',30)

@Test

public void testInsert() throws Exception {

String sql = "insert into t_student(name,age) values (?,?)";

// 1.加载注册驱动

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

// 2.获取数据库连接对象

Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root");

// 3.创建预编译语句对象

PreparedStatement ps = conn.prepareStatement(sql);

//3.1设置占位符参数

ps.setString(1, "东方姑娘");

ps.setInt(2, 18);

// 4.执行SQL语句:注意不要带SQL参数

ps.executeUpdate();

//5.释放资源（先开后关）

ps.close();

conn.close();

}

* 删除操作：删除t_student表中的某一条数据

* SQL ：delete from t_student where id = 2

@Test

public void testDelete() throws Exception {

String sql = "delete from t_student where id = ?";

// 1.加载注册驱动

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

// 2.获取数据库连接对象

Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root");

// 3.创建预编译语句对象

PreparedStatement ps = conn.prepareStatement(sql);

//3.1设置占位符对应的参数值

ps.setInt(1, 1);

// 4.执行SQL语句

int rows = ps.executeUpdate();

System.out.println(rows);

//5.释放资源（先开后关）

ps.close();

conn.close();

}

* 修改操作：修改t_student表中的某一条数据

* SQL ： update t_student set name = '虚竹',age = 50 where id = 3

@Test

public void testUpdate() throws Exception {

String sql = "update t_student set name = ?,age = ? where id = ?";

// 1.加载注册驱动

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

// 2.获取数据库连接对象

Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root");

// 3.创建预编译语句对象

PreparedStatement ps = conn.prepareStatement(sql);

//3.1设置占位符参数对应的值

ps.setString(1, "西方失败");

ps.setInt(2, 40);

ps.setInt(3, 4);

// 4.执行SQL语句

int rows = ps.executeUpdate();

System.out.println(rows);

//5.释放资源（先开后关）

ps.close();

conn.close();

}

7. JavaWeb开发的分层设计-三层架构

7.1. DAO层设计

实际开发中，JavaWeb开发代码一般分为三层,分层结构是JavaWeb开发中的一种设计思想，这样会让我们开发层次分明，每一层只要完成对应的功能即可，使得项目便于开发和维护

1 . Web层/表现层：主要接受前台浏览器用户的参数，给浏览器响应数据等等

Service层/业务成/服务层：主要处理业务功能，日志，权限，事物，等等
DAO层/持久层：专门负责和数据库交互，数据处理相关代码

DAO ： Data Access Object 数据访问对象

实际开发中：用户请求到-Web层--->Service层-->DAO层

7.2. DAO思想

7.3. 使用DAO以后代码的以及包的设计结构

开发中如果使用的分层，编写的包和类名接口名等等都是有固定规则，不能随便瞎写

7.3.1. DAO层接口包命名

公司域名倒写+项目名称/模块名称+dao

如： cn.sxt.crm.dao

7.3.2. DAO层实现类包命名

公司域名倒写+项目名称/模块名称+dao+impl

如： cn.sxt.crm.dao.impl

7.3.3. DAO层操作对应表的接口命名

对应表的名称 + Dao/DAO

如： StudentDao/DAO , TeacherDao/DAO

7.3.4. DAO层操作对应表的实现类命名

对应表的名称 + Dao/DAOImpl

如： StudentDaoImpl/DAOImpl , TeacherDaoImpl/DAOImpl

7.3.5. 数据表对应的Java类domain/pojo包命名

POJO（Plain Ordinary Java Object）简单的Java对象
domian ：域对象

公司域名倒写+项目名称/模块名称+domain/pojo

如： cn.sxt.crm.domain

7.3.6. 对应的测试包命名

公司域名倒写+项目名称/模块名称+test

如： cn.sxt.crm.test

7.3.7. 项目的工具类包命名

公司域名倒写+项目名称/模块名称+util/utils

如： cn.sxt.crm.util/utils

7.3.8. DAO代码设计结构

7.3.9. Dao的实现类代码

  1 package cn.sxt.jdbc.dao.impl;
  2 
  3 import java.sql.Connection;
  4 import java.sql.DriverManager;
  5 import java.sql.PreparedStatement;
  6 import java.sql.ResultSet;
  7 import java.sql.SQLException;
  8 import java.util.ArrayList;
  9 import java.util.List;
 10 
 11 import cn.sxt.jdbc.dao.StudentDao;
 12 import cn.sxt.jdbc.domain.Student;
 13 
 14 public class StudentDaoImpl implements StudentDao {
 15 
 16     @Override
 17     public int saveStudent(Student stu) {
 18         String sql = "insert into t_student(name,age) values (?,?)";
 19         
 20         Connection conn = null;
 21         PreparedStatement ps = null;
 22         try {
 23             
 24             // 1.加载注册驱动
 25             Class.forName("com.mysql.jdbc.Driver");
 26 
 27             // 2.获取数据库连接对象
 28             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root");
 29             // 3.创建预编译语句对象
 30             ps = conn.prepareStatement(sql);
 31             //3.1设置占位符参数
 32             ps.setString(1, stu.getName());
 33             ps.setInt(2, stu.getAge());
 34             
 35             // 4.执行SQL语句:注意不要带SQL参数
 36             return ps.executeUpdate();
 37             
 38             
 39         } catch (Exception e) {
 40             e.printStackTrace();
 41         }finally {
 42             //5.释放资源（先开后关）
 43             try {
 44                 if(ps !=null) {
 45                     ps.close();
 46                 }
 47             } catch (SQLException e) {
 48                 e.printStackTrace();
 49             }finally {
 50                 try {
 51                     if(conn !=null) {
 52                         conn.close();
 53                     }
 54                 } catch (SQLException e) {
 55                     // TODO Auto-generated catch block
 56                     e.printStackTrace();
 57                 }
 58             }
 59         }
 60         return 0;
 61     }
 62 
 63     @Override
 64     public int deleteById(int id) {
 65         
 66         String sql = "delete from t_student where id = ?";
 67         
 68         Connection conn = null;
 69         PreparedStatement ps = null;
 70         try {
 71             
 72             // 1.加载注册驱动
 73             Class.forName("com.mysql.jdbc.Driver");
 74 
 75             // 2.获取数据库连接对象
 76             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root");
 77             // 3.创建预编译语句对象
 78             ps = conn.prepareStatement(sql);
 79             //3.1设置占位符参数
 80             ps.setInt(1, id);
 81             
 82             // 4.执行SQL语句:注意不要带SQL参数
 83             return ps.executeUpdate();
 84             
 85             
 86         } catch (Exception e) {
 87             e.printStackTrace();
 88         }finally {
 89             //5.释放资源（先开后关）
 90             try {
 91                 if(ps !=null) {
 92                     ps.close();
 93                 }
 94             } catch (SQLException e) {
 95                 e.printStackTrace();
 96             }finally {
 97                 try {
 98                     if(conn !=null) {
 99                         conn.close();
100                     }
101                 } catch (SQLException e) {
102                     // TODO Auto-generated catch block
103                     e.printStackTrace();
104                 }
105             }
106         }
107         return 0;
108     }
109 
110     @Override
111     public int updateStudentById(Student stu) {
112         
113         String sql = "update t_student set name = ?,age = ? where id = ?";
114         
115         Connection conn = null;
116         PreparedStatement ps = null;
117         try {
118             
119             // 1.加载注册驱动
120             Class.forName("com.mysql.jdbc.Driver");
121 
122             // 2.获取数据库连接对象
123             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root");
124             // 3.创建预编译语句对象
125             ps = conn.prepareStatement(sql);
126             //3.1设置占位符参数
127             ps.setString(1, stu.getName());
128             ps.setInt(2, stu.getAge());
129             ps.setInt(3, stu.getId());
130             // 4.执行SQL语句:注意不要带SQL参数
131             return ps.executeUpdate();
132             
133             
134         } catch (Exception e) {
135             e.printStackTrace();
136         }finally {
137             //5.释放资源（先开后关）
138             try {
139                 if(ps !=null) {
140                     ps.close();
141                 }
142             } catch (SQLException e) {
143                 e.printStackTrace();
144             }finally {
145                 try {
146                     if(conn !=null) {
147                         conn.close();
148                     }
149                 } catch (SQLException e) {
150                     // TODO Auto-generated catch block
151                     e.printStackTrace();
152                 }
153             }
154         }
155         return 0;
156     }
157 
158     @Override
159     public Student selectById(int id) {
160         String sql = "select * from t_student where id = ?";
161         
162         Connection conn = null;
163         PreparedStatement ps = null;
164         ResultSet rs = null;
165         
166         try {
167             // 1.加载注册驱动
168             Class.forName("com.mysql.jdbc.Driver");
169 
170             // 2.获取数据库连接对象
171             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root");
172             // 3.创建语句对象
173             ps = conn.prepareStatement(sql);
174             //3.1设置占位符参数对应的值
175             ps.setInt(1, id);
176             
177             // 4.执行SQL语句
178             rs = ps.executeQuery();
179             if(rs.next()) {
180                 //通过数据库数据和Java对应的数据类型获取对应的只
181                 String name = rs.getString("name");
182                 int age = rs.getInt("age");
183                 //System.out.println(id+","+name+","+age);
184                 
185                 //将获取的数据封装成对应的Student对象
186                 Student stu = new  Student(id, name, age);
187                 
188                 return stu;
189             }
190             
191         } catch (Exception e) {
192             // TODO: handle exception
193         }finally {
194             try {
195                 if(rs !=null) {
196                     rs.close();
197                 }
198             } catch (SQLException e) {
199                 e.printStackTrace();
200             }finally {
201                 try {
202                     if(ps !=null) {
203                         ps.close();
204                     }
205                 } catch (SQLException e) {
206                     e.printStackTrace();
207                 }finally {
208                     try {
209                         if(conn !=null) {
210                             conn.close();
211                         }
212                     } catch (SQLException e) {
213                         e.printStackTrace();
214                     }
215                 }
216             }
217         }
218         
219         return null;
220     }
221 
222     @Override
223     public List<Student> selectList() {
224         String sql = "select * from t_student";
225         //创建list集合用于封装Student对象
226         List<Student> stus = new ArrayList<>();
227         
228         Connection conn = null;
229         PreparedStatement ps = null;
230         ResultSet rs = null;
231         
232         try {
233             
234             // 1.加载注册驱动
235             Class.forName("com.mysql.jdbc.Driver");
236 
237             // 2.获取数据库连接对象
238             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbcdemo", "root", "root");
239             // 3.创建语句对象
240             ps = conn.prepareStatement(sql);
241             
242             // 4.执行SQL语句
243             rs = ps.executeQuery();
244             while(rs.next()) {
245                 //通过数据库数据和Java对应的数据类型获取对应的只
246                 int id = rs.getInt("id");
247                 String name = rs.getString("name");
248                 int age = rs.getInt("age");
249                 //System.out.println(id+","+name+","+age);
250                 
251                 //将获取的数据封装成对应的Student对象
252                 Student stu = new  Student(id, name, age);
253                 //将一个个Student对象添加到list集合中
254                 stus.add(stu);
255             }
256             
257         } catch (Exception e) {
258             // TODO: handle exception
259         }finally {
260             try {
261                 if(rs !=null) {
262                     rs.close();
263                 }
264             } catch (SQLException e) {
265                 e.printStackTrace();
266             }finally {
267                 try {
268                     if(ps !=null) {
269                         ps.close();
270                     }
271                 } catch (SQLException e) {
272                     e.printStackTrace();
273                 }finally {
274                     try {
275                         if(conn !=null) {
276                             conn.close();
277                         }
278                     } catch (SQLException e) {
279                         e.printStackTrace();
280                     }
281                 }
282             }
283         }
284         
285         return stus;
286     }
287 
288 }

7.3.10. 快速生成单元测试类

一个dao层或者service编写代码以后，需要为每一个功能都进行单元测试，一个dao中的方法很多。我们快速为这个dao层的类生成单元测试类，（dao的每一个方法都自动生成一个测试方法）

7.4. 代码初步重构

上述的DAO方法中的代码,存在的问题:

问题1:每个DAO方法中都会写:驱动名称/url/账号/密码,不利于维护.

解决方案: 声明为成员变量即可.(在被类中任何地方都可以访问)

问题2:问题1的解决方案有问题.

每个DAO实现类里都有一模一样的4行代码,不利于维护(考虑有100个DAO实现类,就得重复99次).

解决方案: 把驱动名称/url/账号/密码这四行代码,专门抽取到一个JDBC的工具类中.---->JdbcUtil.

问题3:其实DAO方法,每次操作都只想需要Connection对象即可,而不关心是如何创建的.

解决方案:把创建Connection的代码,抽取到JdbcUtil中,并提供方法getConn用于向调用者返回Connection对象即可.

问题4:每次调用者调用getConn方法的时候,都会创建一个Connection对象.

但是,每次都会加载注册驱动一次.--->没必要的.

解决方案:把加载注册驱动的代码放在静态代码块中--->只会在所在类被加载进JVM的时候,执行一次.

问题5:每个DAO方法都要关闭资源.(鸡肋代码).

解决方案:把关闭资源的代码,抽取到JdbcUtil中.

public static void close(Connection conn, Statement st, ResultSet rs) {}

调用者:

DML: JdbcUtil.close(conn,st,null);

DQL: JdbcUtil.close(conn,st,rs);

问题6 ：连接数据库的账号密码写死在JdbcUtil工具类中了，不利于维护

抽取 db.properties 配置文件，将数据库对应的账号密码写到配置文件中，然后使用程序读取配置文件内容即可

7.4.1. JdbcUtil工具类

 1 package cn.sxt.jdbc.util;
 2 
 3 import java.io.InputStream;
 4 import java.sql.Connection;
 5 import java.sql.DriverManager;
 6 import java.sql.PreparedStatement;
 7 import java.sql.ResultSet;
 8 import java.sql.SQLException;
 9 import java.util.Properties;
10 
11 
12 public class JdbcUtil {
13 
14     // alt+shif+a 多行修改，修改以后还原 alt+shif+a
15 
16     /*private static String driverClassName = "com.mysql.jdbc.Driver";
17     private static String url = "jdbc:mysql://localhost:3306/jdbcdemo";
18     private static String username = "root";
19     private static String password = "root";*/
20     
21     private static Properties p = new Properties();
22     
23     static {
24         try {
25             //1.获取类加载器
26             ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
27             //2，使用类加载器获取项目 类路径下面的文件
28             InputStream inputStream = classLoader.getResourceAsStream("db.properties");
29             
30             //3.使用Priperties加载配置文件对应的输入流
31             p.load(inputStream);
32             
33             Class.forName(p.getProperty("driverClassName"));
34         } catch (Exception e) {
35             e.printStackTrace();
36         }
37     }
38 
39     public static Connection getConnection() {
40         try {
41             
42             return DriverManager.getConnection(p.getProperty("url"), p.getProperty("username"), p.getProperty("password"));
43         } catch (Exception e) {
44             e.printStackTrace();
45             throw new RuntimeException("亲，连接数据库失败", e);
46         }
47     }
48     
49     public static void close(Connection conn,PreparedStatement ps,ResultSet rs) {
50         try {
51             if(rs !=null) {
52                 rs.close();
53             }
54         } catch (SQLException e) {
55             e.printStackTrace();
56         }finally {
57             try {
58                 if(ps !=null) {
59                     ps.close();
60                 }
61             } catch (SQLException e) {
62                 e.printStackTrace();
63             }finally {
64                 try {
65                     if(conn !=null) {
66                         conn.close();
67                     }
68                 } catch (SQLException e) {
69                     e.printStackTrace();
70                 }
71             }
72         }
73     }
74 }

7.4.2. 使用工具类以后的DAO实现类效果

  1 package cn.sxt.jdbc.dao.impl;
  2 
  3 import java.sql.Connection;
  4 import java.sql.PreparedStatement;
  5 import java.sql.ResultSet;
  6 import java.sql.SQLException;
  7 import java.util.ArrayList;
  8 import java.util.List;
  9 
 10 import cn.sxt.jdbc.dao.StudentDao;
 11 import cn.sxt.jdbc.domain.Student;
 12 import cn.sxt.jdbc.util.JdbcUtil;
 13 
 14 public class StudentDaoImpl implements StudentDao {
 15     
 16     
 17 
 18     @Override
 19     public int saveStudent(Student stu) {
 20         String sql = "insert into t_student(name,age) values (?,?)";
 21         
 22         Connection conn = null;
 23         PreparedStatement ps = null;
 24         try {
 25             conn = JdbcUtil.getConnection();
 26             
 27             // 3.创建预编译语句对象
 28             ps = conn.prepareStatement(sql);
 29             //3.1设置占位符参数
 30             ps.setString(1, stu.getName());
 31             ps.setInt(2, stu.getAge());
 32             
 33             // 4.执行SQL语句:注意不要带SQL参数
 34             return ps.executeUpdate();
 35             
 36         } catch (Exception e) {
 37             e.printStackTrace();
 38         }finally {
 39             JdbcUtil.close(conn, ps, null);
 40         }
 41         return 0;
 42     }
 43 
 44     @Override
 45     public int deleteById(int id) {
 46         
 47         String sql = "delete from t_student where id = ?";
 48         
 49         Connection conn = null;
 50         PreparedStatement ps = null;
 51         try {
 52             
 53             conn = JdbcUtil.getConnection();
 54             // 3.创建预编译语句对象
 55             ps = conn.prepareStatement(sql);
 56             //3.1设置占位符参数
 57             ps.setInt(1, id);
 58             
 59             // 4.执行SQL语句:注意不要带SQL参数
 60             return ps.executeUpdate();
 61             
 62             
 63         } catch (Exception e) {
 64             e.printStackTrace();
 65         }finally {
 66             JdbcUtil.close(conn, ps, null);
 67         }
 68         return 0;
 69     }
 70 
 71     @Override
 72     public int updateStudentById(Student stu) {
 73         
 74         String sql = "update t_student set name = ?,age = ? where id = ?";
 75         
 76         Connection conn = null;
 77         PreparedStatement ps = null;
 78         try {
 79             
 80             conn = JdbcUtil.getConnection();
 81             // 3.创建预编译语句对象
 82             ps = conn.prepareStatement(sql);
 83             //3.1设置占位符参数
 84             ps.setString(1, stu.getName());
 85             ps.setInt(2, stu.getAge());
 86             ps.setInt(3, stu.getId());
 87             // 4.执行SQL语句:注意不要带SQL参数
 88             return ps.executeUpdate();
 89             
 90             
 91         } catch (Exception e) {
 92             e.printStackTrace();
 93         }finally {
 94             JdbcUtil.close(conn, ps, null);
 95         }
 96         return 0;
 97     }
 98 
 99     @Override
100     public Student selectById(int id) {
101         String sql = "select * from t_student where id = ?";
102         
103         Connection conn = null;
104         PreparedStatement ps = null;
105         ResultSet rs = null;
106         
107         try {
108             conn = JdbcUtil.getConnection();
109             // 3.创建语句对象
110             ps = conn.prepareStatement(sql);
111             //3.1设置占位符参数对应的值
112             ps.setInt(1, id);
113             
114             // 4.执行SQL语句
115             rs = ps.executeQuery();
116             if(rs.next()) {
117                 //通过数据库数据和Java对应的数据类型获取对应的只
118                 String name = rs.getString("name");
119                 int age = rs.getInt("age");
120                 //System.out.println(id+","+name+","+age);
121                 //将获取的数据封装成对应的Student对象
122                 Student stu = new  Student(id, name, age);
123                 return stu;
124             }
125             
126         } catch (Exception e) {
127             // TODO: handle exception
128         }finally {
129             try {
130                 if(rs !=null) {
131                     rs.close();
132                 }
133             } catch (SQLException e) {
134                 e.printStackTrace();
135             }finally {
136                 JdbcUtil.close(conn, ps, rs);
137             }
138         }
139         
140         return null;
141     }
142 
143     @Override
144     public List<Student> selectList() {
145         String sql = "select * from t_student";
146         //创建list集合用于封装Student对象
147         List<Student> stus = new ArrayList<>();
148         
149         Connection conn = null;
150         PreparedStatement ps = null;
151         ResultSet rs = null;
152         
153         try {
154             
155             conn = JdbcUtil.getConnection();
156             // 3.创建语句对象
157             ps = conn.prepareStatement(sql);
158             
159             // 4.执行SQL语句
160             rs = ps.executeQuery();
161             while(rs.next()) {
162                 //通过数据库数据和Java对应的数据类型获取对应的只
163                 int id = rs.getInt("id");
164                 String name = rs.getString("name");
165                 int age = rs.getInt("age");
166                 //System.out.println(id+","+name+","+age);
167                 
168                 //将获取的数据封装成对应的Student对象
169                 Student stu = new  Student(id, name, age);
170                 //将一个个Student对象添加到list集合中
171                 stus.add(stu);
172             }
173             
174         } catch (Exception e) {
175             // TODO: handle exception
176         }finally {
177             JdbcUtil.close(conn, ps, rs);
178         }
179         
180         return stus;
181     }
182 
183 }

7.5. 知识点补充，类加载器

在项目的类路径（src）下面创建一个 db.properties配置文件，专门配置连接数据库的账号密码

如何使用类加载器加载配置文件

7.5.1. 配置文件

7.5.1.1. 配置文件创建的位置

配置文件一般都放在项目的src 源目录下面

7.5.2. 加载代码

 1 package cn.sxt.jdbc.test;
 2 
 3 import static org.junit.Assert.*;
 4 
 5 import java.io.InputStream;
 6 import java.util.Properties;
 7 
 8 import org.junit.Test;
 9 
10 public class PropertiesTest {
11     
12     @Test
13     public void testName() throws Exception {
14         
15          /*
16           * ClassLoader 类加载器
17           * ClassLoader ：可以从项目的类路径下面读取对应的配置文件返回一个输入流
18           * ClassLoader 在程序运行的时候JVM已经为每一个项目都创建了一个，我们开发者只需要获取即可
19           * 获取类加载器方式
20           * 1、使用当前线程
21           * ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
22           * 2、通过某一类的字节码实例也可以获取
23           * ClassLoader classLoader = PropertiesTest.class.getClassLoader();
24           */
25         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
26         //使用类加载器获取项目 类路径下面的文件
27         InputStream inputStream = classLoader.getResourceAsStream("db.properties");
28         
29         
30         /*
31          * Properties 是Map集合下面的一个 专门用于读取配置文件的对象
32          * 可以读取当前类路径下面的  xxx.properites类型的配置文件
33          * 
34          * xxx.properites的内容必须是key=value 键值对的数据
35          */
36         
37         //1.创建Properties对象
38         Properties p = new Properties();
39         
40         //2.加载配置文件
41         p.load(inputStream);
42         
43         System.out.println(p);
44         
45         //获取具体某一个key对应的值
46         String driverClassName = p.getProperty("driverClassName");
47         System.out.println(driverClassName);
48     }
49 }

7.5.3. 效果

8. 连接池

8.1. 遇到的问题-引出连接池

8.2. 连接池思想

8.3. 连接池的概述

在Java中,连接池使用javax.sql.DataSource接口来表示连接池.

注意:DataSource仅仅只是一个接口,由各大服务器厂商来实现(Tomcat.JBoss，阿里巴巴).

常用的DataSource的实现:

DBCP: Spring推荐的

C3P0: Hibernate推荐的

Druid : （德鲁伊）阿里巴巴开源的,性能最好，速度最快

DataSource(数据源)和连接池(Connection Pool)是同一个.

8.4. 使用连接池和不使用连接池的区别在哪里

8.5. Druid连接池的使用

8.5.1. 准备druid 连接池jar包到项目

从代码上:

不使用连接池: Conenction对象由DriverManager获取.

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

使用连接池:

如何创建DataSource对象,如何在DataSource中设置url,账号,密码.

Connection conn = DataSource对象.getConnection();

--------------------------------------------------------------------

使用连接池的时候:

释放资源: Connection对象.close():

是把Connection放回给连接池,而不是和数据库断开.

 1 package cn.sxt.jdbc.test;
 2 
 3 import static org.junit.Assert.*;
 4 
 5 import java.io.InputStream;
 6 import java.io.Reader;
 7 import java.sql.Connection;
 8 import java.util.Properties;
 9 
10 import javax.sql.DataSource;
11 
12 import org.junit.Test;
13 
14 import com.alibaba.druid.pool.DruidDataSource;
15 import com.alibaba.druid.pool.DruidDataSourceFactory;
16 import com.alibaba.druid.pool.DruidPooledConnection;
17 
18 public class DataSourceTest {
19     // 直接创建连接池对象
20     @Test
21     public void testName() throws Exception {
22         // 1.创建连接池对象
23         DruidDataSource ds = new DruidDataSource();
24         // 2.设置连接数据库的账号密码
25         ds.setDriverClassName("com.mysql.jdbc.Driver");
26         ds.setUrl("jdbc:mysql://localhost:3306/jdbcdemo");
27         ds.setUsername("root");
28         ds.setPassword("root");
29         ds.setMaxActive(10);// 最大连接数
30         // 3.获取连接对象
31         Connection conn = ds.getConnection();
32         System.out.println(conn);
33     }
34 
35     // 使用工厂对象创建连接池对象，工厂对象的好处，不需要直接设置账号密码等等，只需要将
36     // 连接数据库的账号密码等等以指定的 key的名称配置到 xxx.properties文件中即可，工厂对象底层自动读取
37     @Test
38     public void testDataSourceByFactory() throws Exception {
39 
40         // 1.获取类加载器用于加载clsspath下面的 配置文件
41         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
42         // 2.读取druid.properties配置文件
43         InputStream inputStream = classLoader.getResourceAsStream("druid.properties");
44         // 3.创建Properties对象，并读取配置文件对应的输入流
45         Properties p = new Properties();
46         p.load(inputStream);
47 
48         // 4.创建连接池对象
49         DataSource ds = DruidDataSourceFactory.createDataSource(p);
50         // 5.获取连接对象
51         Connection conn = ds.getConnection();
52         System.out.println(conn);
53     }
54 }

8.5.2. db.propperties

8.5.3. 使用Druid抽取的工具类

9. 事务

案例:银行转账:从张无忌账户上给赵敏转1000块.

准备:account(账户表):

---------------------------------------------------------------

id name(账号,唯一) balance(余额)

1 张无忌 20000

2 赵敏 0

---------------------------------------------------------------

转账的思路:

1.检查张无忌的账号余额是否大于等于1000.

SQL: SELECT balance FROM account WHERE name = '张无忌' AND balance >=1000

余额>=1000:GOTO 2:

余额 <1000:提示:亲,你的余额不足.

2.在张无忌的账号余额上减少1000.

SQL: UPDATE account SET balance = balance-1000 WHERE name = '张无忌'

3.在赵敏的账户余额尚增加1000.

SQL: UPDATE account SET balance = balance+1000 WHERE name = '赵敏'

-------------------------------------------------------------------------------------------

注意:在第二步和第三步之间,停电了.

使用异常模拟停电:System.out.println(1/0);

9.1. 事务概述

事务(Transaction,简写为tx):

在数据库中,所谓事务是指一组逻辑操作单元,使数据从一种状态变换到另一种状态。

为确保数据库中数据的一致性,数据的操纵应当是离散的成组的逻辑单元:

当每个逻辑操作单元全部完成时,数据的一致性可以保持,

而当这个单元中的一部分操作失败,整个事务应全部视为错误,所有从起始点以后的操作应全部回退到开始状态。

事务的操作:先定义开始一个事务,然后对数据作修改操作,这时如果提交(commit),这些修改就永久地保存下来,如果回退(rollback),数据库管理系统将放弃您所作的所有修改而回到开始事务时的状态。

--------------------------------------------------

事务的ACID属性:

1. 原子性（Atomicity）
原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。

2. 一致性（Consistency）
事务必须使数据库从一个一致性状态变换到另外一个一致性状态。(数据不被破坏)

3. 隔离性（Isolation）

事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。

4. 持久性（Durability）
持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和数据库故障不应该对其有任何影响

--------------------------------------------------

事务：指构成单个逻辑工作单元的操作集合

事务处理：保证所有事务都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方式。当在一个事务中执行多个操作时，要么所有的事务都被提交(commit)，要么整个事务回滚(rollback)到最初状态

处理事务的两个动作:

提交:commit: 当整个事务中,所有的逻辑单元都正常执行成功. ---->提交事务.---数据已经提交,不能更改.

回滚:rollback: 当整个事务中,有一个逻辑单元执行失败, ---->回滚事务.

撤销该事务中的所有操作--->恢复到最初的状态.

---------------------------------------------------------------------------------------------------

如何在代码中去处理事务:

1.在JDBC中,事务是默认自动提交的. 必须先设置事务为手动提交.

connection对象.setAutoCommit(false);//设置事务为手动提交.

2.手动的提交事务.

connection对象.commit();

3.若出现异常必须回滚事务:

不回滚事务,总余额依然是正确的. 若不回滚事务,不会释放数据库资源.

connection对象.rollback();

-----------------------------------------------------------------------------------

1.在JDBC在事务是默认提交的,那是在什么时候提交的.

在执行一个DML/DDL操作的时候,就已经提交事务了.

2.针对于CRUD操作. 只有DML操作才有事务,查询操作没有事务.

但是,我们一般会把查询也放在事务里面.

以后,凡是发现自己编写的代码是正确的,测试也通过,但是就是数据库表中的数据不变----->事务没提交的问题.

4.MySQL中,InnoDB支持外键.支持事务,MyISAM不支持外键,不支持事务.

InnoDB存储引擎：支持事务，支持外键，但是查询效率略低，（金融，理财，p2p）

MyISAM存储引擎：不支持事务和外键，但是查询效率较高(新闻网站)

Oracle 不存在存储引擎，都有事务

9.2. 事务处理代码

 1 public class TransactionTest {
 2     @Test
 3     public void testName() throws Exception {
 4         Connection conn = null;
 5         Statement st = null;
 6         ResultSet rs = null;
 7         try {
 8             conn = DruidUtil.getConnection();
 9             //将事务设置为手动提交
10             conn.setAutoCommit(false);
11             
12             st = conn.createStatement();
13             // 1.检查张无忌的账号余额是否大于等于1000.
14             rs = st.executeQuery("SELECT balance FROM account WHERE name = '张无忌' AND balance >=1000");
15             if(!rs.next()) {
16                 throw new RuntimeException("亲，您的账户余额不够");
17             }
18             // 余额>=1000:GOTO 2:
19             // 余额 <1000:提示:亲,你的余额不足.
20             // 2.在张无忌的账号余额上减少1000.
21             st.executeUpdate("UPDATE account SET balance = balance-1000 WHERE name = '张无忌'");
22             
23             System.out.println(1/0);
24             
25             // 3.在赵敏的账户余额尚增加1000.
26             st.executeUpdate("UPDATE account SET balance = balance+1000 WHERE name = '赵敏'");
27             
28             //提交事务
29             conn.commit();
30         
31             
32         } catch (Exception e) {
33             e.printStackTrace();
34             //回滚事务
35             conn.rollback();
36             
37         }finally {
38             DruidUtil.close(conn, st, rs);
39         }
40         
41     }
42 }

相关阅读:
RabbitMQ管理
 vc6.0
SystemTap
undefined reference to `__imp_socket'
采集小板校时
 点播播放不出来
 抓包注意事项
 下载rfc
CLion快捷键
 rtsp vlc请求实例
原文地址：https://www.cnblogs.com/qq308015824/p/10887586.html