JDBC

JDBC学习

JDBC基础

JDBC快速入门

JDBC的概念

jdbc的概念

JDBC（java DataBase Connectivity java数据库连接），是一种用于执行SQL语句的JavaAPI，可以为多种关系型数据库提供一种访问，它是由一组用java语言编写的类和接口组成

jdbc的本质

其实就是java官方提供的一种规范（接口），用于帮助开发人员快速实现不同关系型数据库的连接
1. jdbc快速入门程序
- 导入jar包
- 注册驱动
Class.forName(“com.mysql.jdbc.Driver”);
- 获取数据库链接
Connection conn=DriverManager.getConnection(“url”,“root”,”password”);
- 定义SQL语句
String sql=“select*from apples”;
- 获取执行对象
Statement stmt=conn.createStatement();
- 执行SQL语句并返回结果
stmt.executeUpdate(sql);
- 处理结果
- 释放资源
```
x
1
package frist;
2

3
import java.net.URL;
4
import java.sql.Connection;
5
import java.sql.DriverManager;
6
import java.sql.ResultSet;
7
import java.sql.Statement;
8

9
public class JDBCmysql {
10
     public static void main(String[] args) throws  Exception{
11
         //导入jar包--复制jar包
12
         //注册驱动
13
         Class.forName("com.mysql.jdbc.Driver");
14
         //获取连接
15
        Connection con = DriverManager.getConnection("jdbc:mysql://10.217.7.43:3306/专辑","root","LDBISABOY1314");
16
        //获取执行对象
17
         Statement stat = con.createStatement();
18
         //执行sql语句，并且接收结果
19
         String sql="SELECT*FROM 曲目";
20
         ResultSet rs = stat.executeQuery(sql);
21
         //处理结果
22
         while (rs.next()){
23
             System.out.println(rs.getString("曲目名")+"\t"+rs.getString("歌手")+"\t"+rs.getString("发行时间")+"\t"
24
             +rs.getString("专辑"));
25
         }
26
         //释放资源
27
         con.close();
28
         stat.close();
29
         rs.close();
30

31
     }
32
}
33
```

JDBC API功能类详解

DriverManager

1.DriverManager驱动管理对象

注册驱动

注册给定的驱动程序：static void registerDriver（Driver driver）；
写代码使用：Class.forName(“com.mysql.jdbc.Driver”);

在com.mysql.jdbc.Driver类中存在静态代码块


xxxxxxxxxx
7
1
static{
2
    try{
3
        java.sql.DriverManager.registerDriver(new Driver());
4
    }catch (SQLException E){
5
        throw new RuntimeException("can't register driver");
6
    }
7
}

MySQL5之后的驱动包，可以省略注册驱动的步骤
自动加载jar包中的META-INF/services/Java.sql.Driver文件中的驱动类

参数：

url：连接路劲

语法：jdbc:mysql://ip地址（域名）:端口号/数据库名称？参数键值对1&参数键值对2……
示例：jdbc:mysql://127.0.0.1:3306/db1
细节：
如果连接的时本机mysql服务器，并且mysql服务默认端口位3306，url可以简写成：jdbc:mysql:///数据库名称……
配置userSSL=false参数，禁用安全连接方式，解决警告提示

user：用户名
password：密码

Connection

Connection（数据库连接对象）作用：
- 获取执行SQL的对象
  1. 普通执行SQL对象
  Statement createStatement()
  1. 预编译SQL的执行SQL对象：防止SQL注入
  PreparedStatement prepareStatement(sql)
  1. 执行存储过程的对象
  CallableStatement prepareCall(sql)
- 管理事务
  - MySQL事务管理
  开启事务：BEGIN；/START TRANSACTION；
  提交事务：COMMIT;
  回滚事务：ROLLBACK;
  MySQL默认自动提交事务
  - JDBC事务管理：Connection接口中定义了3个应对的方法
  开启事务：setAutoCommit(boolean autoCommit):true为自动提交事务；false为手动提交事务，即为开启事务
  提交事务：commit()
  回滚事务：rollback()

Statement

Statement作用：执行SQL语句
执行SQL语句：
int executeUpdate(sql):执行DML、DDL语句
返回值：1. DML语句影响的行数 2. DDL语句执行后，执行成功也可能返回0
ResultSet executeQuery(sql):执行DQL语句
返回值：ResultSet结果集对象

ResultSet

ResultSet（结果集对象）作用：
1. 封装了DQL查询语句的结果
  ResultSet stmt.execateQuey(sql);执行DQL语句，返回ResultS儿童对象
- 获取查询结果：
  boolean next():1 将光标从当下位置向前移动一行 2.判断当前行是否为有效行
  返回值：
  - true：有效行，当前行有数据
  - false：无效行，当前行没有数据
  xxx getXxx(参数):获取数据
  - xxx:数据类型：如：int getInt(参数); String getString(参数)
  - 参数：
    - int : 列的编号，从1开始
    - String：列的名称

ResultSet的使用步骤：

游标向下移动一行，并判断该行数据是否为空
获取数据：getXxx(参数)

//循环判断游标是否在最后一行
while(rs.next()){
//获取数据
rs.getXxx(参数);
}


xxxxxxxxxx
36
1

2
    public static void main(String[] args) throws Exception {
3
        String user="root";
4
        String pass="LDBISABOY1314";
5
        String url="jdbc:mysql:///ldb";
6
        Connection coun= DriverManager.getConnection(url,user,pass);
7

8
        String sql="select*from informations";
9
        Statement stmt= coun.createStatement();
10
        ResultSet rs= stmt.executeQuery(sql);
11
//        处理结果，遍历rs中的结果
12
        while ( rs.next() ){
13
            //获取数据
14
            int id=rs.getInt("id");
15
            String name=rs.getString("name");
16
            int age= rs.getInt("age");
17
            String adrss= rs.getString("adrss");
18
            int tell= rs.getInt("tell");
19
            System.out.print(id);
20
            System.out.print("--");
21
            System.out.print(name);
22
            System.out.print("--");
23
            System.out.print(age);
24
            System.out.print("--");
25
            System.out.print(adrss);
26
            System.out.print("--");
27
            System.out.print(tell);
28
            System.out.println();
29
            System.out.println("------------------------------");
30
        }
31
        rs.close();
32
        stmt.close();
33
        coun.close();
34

35
    }
36
//执行完这个程序就会把数据库里表里面的数据全部打印到控制台里

//执行完这个程序就会把数据库里表里面的数据全部打印到控制台里

ResultSet练习案例：从数据库里提取数据存放到集合里面

需求：查询数据库中表的数据，封装一个对象，并且存储到ArrayList集合中

封装一个LDB对象


xxxxxxxxxx
61
1

2
package JDBC.pojo;
3

4
public class LDB {
5
    private int id;
6
    private String name;
7
    private  int age;
8
    private  String adrss;
9
    private int tell;
10

11
    public int getId() {
12
        return id;
13
    }
14

15
    public void setId(int id) {
16
        this.id = id;
17
    }
18

19
    public String getName() {
20
        return name;
21
    }
22

23
    public void setName(String name) {
24
        this.name = name;
25
    }
26

27
    public int getAge() {
28
        return age;
29
    }
30

31
    public void setAge(int age) {
32
        this.age = age;
33
    }
34

35
    public String getAdrss() {
36
        return adrss;
37
    }
38

39
    public void setAdrss(String adrss) {
40
        this.adrss = adrss;
41
    }
42

43
    public int getTell() {
44
        return tell;
45
    }
46

47
    public void setTell(int tell) {
48
        this.tell = tell;
49
    }
50
    @Override
51
    public String toString() {
52
        return "ldb{" +
53
                "id=" + id +
54
                ", name='" + name + '\'' +
55
                ", age=" + age +
56
                ", adrss='" + adrss + '\'' +
57
                ", tell=" + tell +
58
                '}';
59
    }
60
}
61

测试类


xxxxxxxxxx
35
1

2
public calss text{
3
    public static void main(String[] args){
4
        String user="root";
5
        String pass="123456";
6
        String url="jdbc:mysql:///ldb";
7
        Connection coun=DriverManager.getConnection(url,user,pass);
8
        Statement stmt=coun.createStatement();
9
        String sql="select*from informations";
10
        ResultSet rs=stmt.execateQuery(sql);
11
        Lise<LDB> list=new ArrayList();
12
        
13
        while(rs.next()){
14
            LDB l=new LDB();
15
            
16
            int id=rs.getInt("id");
17
            String name=rs.getString("name");
18
            int age=rs.getInt("age");
19
            String adrss=re.getString("adrss");
20
            int tell=rs.getInt("tell");
21
            
22
            l.setId(id);
23
            l.setName(name);
24
            l.setAge(age);
25
            l.setAdrss(adrss);
26
            l.setTell(tell);
27
            list.add(l);
28
           
29
        }
30
        System.out.println(list);
31
        rs.close();
32
        stmt.close();
33
        coun.close();
34
    }
35
}

PreparedStatement

PreparedStatement作用：

预编译SQL语句并执行：预防SQL注入问题
将敏感字符进行转义
1. 获取PreparedStatement对象
//SQL语句中的参数，使用？占位符替代
String sql=“select*from user where username=?and password=?”;
//通过Connection对象获取，并传入对应的sql语句
PreparedStatement pstmt = coun.preparedStatement(sql);
1. 设置参数
PreparedStatement对象：setXxx(参数1，参数2):给 ?赋值
- Xxx:数据类型；如 setInt(参数1,参数2)
- 参数：
  - 参数1：？的位置编号，从1开始
  - 参数2：？的值
1. 执行SQL
executeUpdate();/executeQuery(); :不需要再传递sql
SQL注入：
- SQL注入是通过操作输入来修改事先定义好的SQL语句，用以达到执行代码对服务器进行攻击的方法

案例防治SQL注入：


xxxxxxxxxx
52
1

2
package JDBC;
3

4
import java.sql.*;
5
import java.util.Scanner;
6

7
public class PreparedStatementText {
8
    public static void main(String[] args) throws SQLException {
9
        Scanner sc = new Scanner(System.in);
10

11
        System.out.println("请输入用户账号:");
12
        int userID = sc.nextInt();
13

14
        System.out.println("请输入密码：");
15
        //'' or '1'='1'
16
        String userPass = sc.next();
17

18

19
        String user = "root";
20
        String pass = "LDBISABOY1314";
21
        String url = "jdbc:mysql:///login";
22
        Connection coun = DriverManager.getConnection(url, user, pass);
23
        Statement stmt = coun.createStatement();
24
//        PreparedStatement API详解与使用演示：
25
//        预防SQL注入使用“？”占位符
26
//        定义SQL语句：
27
//      使用？占位符
28
        String sql = "select*from userid where id=? and password=?";
29
//        获取pstmt对象
30
        PreparedStatement pstmt = coun.prepareStatement(sql);
31

32
//        设置占位符“？”的值
33
        pstmt.setInt(1,userID);//第一个占位符
34
        pstmt.setString(2,userPass);//第二个占位符
35
//        执行sql
36
        ResultSet rs = pstmt.executeQuery();
37

38

39
        if(rs.next()){
40
            System.out.println("登录成功");
41
        }else {
42
            System.out.println("登录失败!");
43
        }
44

45
        rs.close();
46
        stmt.close();
47
        coun.close();
48
    }
49

50

51
}
52

PreparedStatement的原理

PreparedStatement预编译功能的开启：useServerPrepStmts=true

配置MYSQL

PreparedStatement原理：

在获取PreparedStatement对象时，将SQL语句发送给MySQL服务器进行检查、编译
执行时就不用再进行这些步骤了，速度更快
如果sql模板一样，则只需进行一次检查、编译

数据库连接池

数据库连接池是一个容器，负责分配、管理数据库连接
它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个
释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏
好处：
- 资源重用
- 提升系统响应速度
- 避免数据库连接遗漏

数据库连接池的使用

标准接口：DataSource
- 官方（SUN）提供的数据库连接池的标准接口，由第三方组织实现接口
- 功能：获取连接
  Connection getConnection()
常见数据库连接池
- DBCP
- C3P0
- Druid
Druid（德鲁伊）
- Druid连接池是阿里巴巴开源的数据库连接池项目
- 功能强大、性能优秀、是Java语言最好的数据库连接池之一

Driud数据库连接池的使用

导入druid的jar包
定义配置文件
加载配置文件
获取数据库连接池对象
获取链接


xxxxxxxxxx
32
1

2
package DruidText;
3

4

5
import com.alibaba.druid.pool.DruidDataSourceFactory;
6

7
import javax.sql.DataSource;
8
import java.io.FileInputStream;
9
import java.sql.Connection;
10
import java.util.Map;
11
import java.util.Properties;
12

13
//druid数据库连接池的演示
14
public class druidDemo {
15
    public static void main(String[] args) throws Exception {
16

17
//        导如jar包
18
//        定义配置文件
19
//        加载配置
20
        Properties prop=new Properties();
21
        prop.load(new FileInputStream("D:\\programmingsProject\\JavaProject\\leaningJava_Class_Object\\src\\src" +
22
                "\\druid.properties"));
23
//        获取连接池对象
24

25
        DataSource dataSource= DruidDataSourceFactory.createDataSource(prop);
26
//        获取对应数据库连接
27
        Connection connection=dataSource.getConnection();
28
        
29
        System.out.println(connection);
30
    }
31
}
32

JDBC案例

商品品牌的增删改查
查询所有数据
添加品牌
修改根据id修改
删除根据id删除


xxxxxxxxxx
177
1

2
package example;
3

4

5
import JDBC.pojo.brand;
6
import com.alibaba.druid.pool.DruidDataSourceFactory;
7
import org.junit.Test;
8

9
import javax.sql.DataSource;
10
import java.io.FileInputStream;
11
import java.sql.Connection;
12
import java.sql.PreparedStatement;
13
import java.sql.ResultSet;
14
import java.sql.Statement;
15
import java.util.ArrayList;
16
import java.util.List;
17
import java.util.Properties;
18

19
//品牌数据的增删改查操作
20
public class BrandText {
21
    //    查询所有数据
22
//    查询所有
23
//    1.SQL：select*from tb_brand
24
//    2.参数：在这个测试里不需要
25
//    3.结果：List<brand>
26
    @Test
27
    public void textSelectAll() throws Exception {
28

29

30
//        导如jar包
31
//        定义配置文件
32
//        加载配置
33
        Properties prop = new Properties();
34
        prop.load(new FileInputStream("D:\\programmingsProject\\JavaProject\\leaningJava_Class_Object\\src\\src" +
35
                "\\druid.properties"));
36
//        获取连接池对象
37

38
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
39
//        获取对应数据库连接
40
        Connection conn = dataSource.getConnection();
41
        String sql = "select*from tb_brand";
42
        Statement stmt = conn.createStatement();
43

44
//        获取pstmt对象
45
        PreparedStatement pstmt = conn.prepareStatement(sql);
46
//        设置参数
47
//        执行SQL
48
        ResultSet rs = pstmt.executeQuery();
49

50
//        处理结果 List<brand>封装brand对象到list集合去
51

52
        brand br = null;
53
        List<brand> brands = new ArrayList<>();
54
        while ( rs.next() ) {
55
            int id = rs.getInt("id");
56
            String brand_name = rs.getString("brand_name");
57
            String company_name = rs.getString("company_name");
58
            int ordered = rs.getInt("ordered");
59
            String description = rs.getString("description");
60
            int status = rs.getInt("status");
61
//            封装brand对象
62
            br = new brand();
63
            br.setId(id);
64
            br.setDescription(description);
65
            br.setBrandName(brand_name);
66
            br.setCompanyName(company_name);
67
            br.setOrdered(ordered);
68
            br.setStatus(status);
69

70
//            装在集合
71
            brands.add(br);
72

73
        }
74
        System.out.println(brands);
75
        rs.close();
76
        pstmt.close();
77
        conn.close();
78

79

80
    }
81

82
//    数据插入测试
83

84

85
    //    查询所有数据
86
//    查询所有
87
//    1.SQL：select*from tb_brand
88
//    2.参数：除了id以外的所有参数
89
//    3.结果：boolean
90
    @Test
91
    public void insertData() throws Exception {
92

93

94
        String brandName = "OPPO";
95

96
        String companyName = "OPPO有限公司";
97

98
        int ordered = 120;
99

100
        String description = "打最贵的广告，用最次的配置";
101

102
        int status = 0;
103
        Properties prop = new Properties();
104
        prop.load(new FileInputStream("D:\\programmingsProject\\JavaProject\\leaningJava_Class_Object\\src\\src" +
105
                "\\druid.properties"));
106
//        获取连接池对象
107

108
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
109
//        获取对应数据库连接
110
        Connection conn = dataSource.getConnection();
111
//        Statement stmt = conn.createStatement();
112
        String sql = "insert into tb_brand(brand_name,company_name,ordered,description,status) values(?,?,?,?,?)";
113
        PreparedStatement pstmt = conn.prepareStatement(sql);
114
//        设置参数
115
        pstmt.setString(1, brandName);
116
        pstmt.setString(2, companyName);
117
        pstmt.setInt(3, ordered);
118
        pstmt.setString(4, description);
119
        pstmt.setInt(5, status);
120

121
//        执行SQL处理结果
122
        int coun = pstmt.executeUpdate();
123
        System.out.println(coun > 0 ? true : false);
124
        pstmt.close();
125
        conn.close();
126
    }
127

128

129
    @Test
130
    public void updataTbBrand() throws Exception {
131
        String brandName = "vivo";
132
        String companyName = "vivo有限公司";
133
        String description = "vivo动感常在";
134
        int id = 4;
135
        Properties prop = new Properties();
136
        prop.load(new FileInputStream("D:\\programmingsProject\\JavaProject\\leaningJava_Class_Object\\src\\src" +
137
                "\\druid.properties"));
138
//        获取连接池对象
139

140
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
141
//        获取对应数据库连接
142
        Connection conn = dataSource.getConnection();
143
        String sql = "update tb_brand set brand_name=?,company_name=?,description=? where id=? ";
144
        PreparedStatement pstmt = conn.prepareStatement(sql);
145
        pstmt.setString(1, brandName);
146
        pstmt.setString(2, companyName);
147
        pstmt.setString(3, description);
148
        pstmt.setInt(4, id);
149
        int coun = pstmt.executeUpdate();
150
        System.out.println(coun > 0 ? true : false);
151
        pstmt.close();
152
        conn.close();
153
    }
154

155

156
    //    删除数据
157
    @Test
158
    public void dropData() throws Exception {
159
        int id = 7;
160
        Properties prop = new Properties();
161
        prop.load(new FileInputStream("D:\\programmingsProject\\JavaProject\\leaningJava_Class_Object\\src\\src" +
162
                "\\druid.properties"));
163
//        获取连接池对象
164

165
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
166
//        获取对应数据库连接
167
        Connection conn = dataSource.getConnection();
168
        String sql = "delete from tb_brand where id=?";
169
        PreparedStatement pstmt = conn.prepareStatement(sql);
170
        pstmt.setInt(1, id);
171
        int coun = pstmt.executeUpdate();
172
        System.out.println(coun > 0 ? true : false);
173
        pstmt.close();
174
        conn.close();
175
    }
176
}
177