JDBC详解

JDBC

一、JDBC概述

　　为什么要使用JDBC？

　　JDBC：Java DataBase Connectivity，是SUN公司提供的一套操作数据库的标准规范(技术)。

　　JDBC与数据库驱动的关系：接口与实现的关系。

 

 

JDBC规范（掌握四个核心对象）：

　　　　DriverManager类：用于注册驱动(创建连接对象)。 java.sql.DriverManager;

　　　　Connection接口：表示与数据库创建的连接 。java.sql.Connection;

　　　　Statement接口：操作数据库sql语句的对象，并返回相应结果的对象。 java.sql.Statement;

　　　　　　preparedStatement接口：预编译对象，是Statement对象的子类。用于解决sql的注入问题。实际用的是这个类。java.sql.PreparedStatement;

　　　　ResultSet接口：结果集或一张虚拟表(客户端存表数据的对象)。 java.sql.ResultSet;

 

 二、开发一个JDBC程序

　使用JDBC技术，通过java代码实现查询数据库中的数据并显示在java的控制台中。

　　1、先创建数据库表，并向表中添加测试数据。

 

?
1
2
3
4
5
6
7
8
9
10
11
12
create database stu;
　use stu;
 
　create table user (
  　　 id int primary key auto_increment,
   　　username varchar(40),
   　　password varchar(40),
　) character set utf8 collate utf8_general_ci;
 
　insert into user(username, password) values('zs', '123456');
　insert into user(username, password) values('lisi', '123456');
　insert into user(username, password) values('wangwu', '123456');

 

　　

 

 2、创建Java Project项目，添加数据库驱动(xxx.jar)。

 

 

3、实现JDBC操作。

 

 4.源码示例

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package com.jdbc;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
 
public class JDBCUtils {
    public static Connection connection;
 
    private static String url ="jdbc:mysql://localhost:3306/stu?serverTimezone=GMT%2B8";
    private static String user ="root";
    private static String pwd = "root";
 
    static{
        try {
            Class.forName("com.mysql.jdbc.Driver");
            connection = DriverManager.getConnection(url,user,pwd);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
 
    public static Connection getConnection(){
        return connection;
    }
 
 
}

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package com.pojo;
 
public class User {
    private int id;
    private String username;
    private String password;
 
    public User() {
    }
 
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
 
    public User(int id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }
 
    public int getId() {
        return id;
    }
 
    public void setId(int id) {
        this.id = id;
    }
 
    public String getUsername() {
        return username;
    }
 
    public void setUsername(String username) {
        this.username = username;
    }
 
    public String getPassword() {
        return password;
    }
 
    public void setPassword(String password) {
        this.password = password;
    }
}

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
package com.dao;
 
import com.jdbc.JDBCUtils;
import com.pojo.User;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
 
public class UserDao {
 
    private Connection conn = JDBCUtils.getConnection();
    private PreparedStatement ps;
 
    /**
     * 添加用户
     * @param user 要添加的用户对象
     * @throws SQLException
     */
    public int add(User user) throws SQLException {
        String sql = "insert into user(username,password) values(?,?)";
        ps = conn.prepareStatement(sql);
        ps.setObject(1,user.getUsername());
        ps.setObject(2,user.getPassword());
        return ps.executeUpdate();
    }
 
    /**
     * 删除
     * @param id
     * @return
     * @throws SQLException
     */
    public int delete(int id) throws SQLException {
        String sql = "delete from user where id=?";
        ps = conn.prepareStatement(sql);
        ps.setObject(1,id);
        return ps.executeUpdate();
    }
 
    /**
     * 修改
     * @param user
     * @return
     * @throws SQLException
     */
    public int update(User user) throws SQLException {
        String sql = "update user set username=? , password=? where id=?";
        ps = conn.prepareStatement(sql);
        ps.setObject(1,user.getUsername());
        ps.setObject(2,user.getPassword());
        ps.setObject(3,user.getId());
        return ps.executeUpdate();
    }
 
    /**
     * 查询所有
     * @return
     * @throws SQLException
     */
    public List<User> findAll() throws SQLException {
        String sql = "select * from user";
        ps = conn.prepareStatement(sql);
        ResultSet rs = ps.executeQuery();
        List<User> list = new ArrayList<User>();
        while(rs.next()){
            int id = rs.getInt("id");
            String username = rs.getString("username");
            String password = rs.getString("password");
            User u = new User(id,username,password);
            list.add(u);
        }
        return list;
    }
 
    /**
     * 根据ID查询
     * @param id
     * @return
     * @throws SQLException
     */
    public User findByID(int id) throws SQLException {
        String sql = "select * from user where id=?";
        ps = conn.prepareStatement(sql);
        ps.setInt(1,id);
 
        ResultSet rs = ps.executeQuery();
        User u = null;
        while(rs.next()){
            int uid = rs.getInt("id");
            String username = rs.getString("username");
            String password = rs.getString("password");
            u = new User(uid,username,password);
        }
        return u;
    }
 
    /**
     * 登录的方法
     */
    public User login(User user) throws SQLException {
        String sql = "select * from user where username=? and password=?";
        ps = conn.prepareStatement(sql);
        ps.setObject(1,user.getUsername());
        ps.setObject(2,user.getPassword());
        ResultSet rs = ps.executeQuery();
        User u = null;
        while(rs.next()){
            int uid = rs.getInt("id");
            String username = rs.getString("username");
            String password = rs.getString("password");
            u = new User(uid,username,password);
        }
        return u;
    }
 
}

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
package com.service;
 
import com.dao.UserDao;
import com.pojo.User;
 
import java.sql.SQLException;
import java.util.List;
 
public class UserService {
 
    private UserDao userDao = new UserDao();
 
    /**
     * 添加用户
     * @param user 要添加的用户对象
     * @throws SQLException
     */
    public int add(User user) throws SQLException {
        return userDao.add(user);
    }
 
    /**
     * 删除
     * @param id
     * @return
     * @throws SQLException
     */
    public int delete(int id) throws SQLException {
        return userDao.delete(id);
    }
 
    /**
     * 修改
     * @param user
     * @return
     * @throws SQLException
     */
    public int update(User user) throws SQLException {
        return userDao.update(user);
    }
 
    /**
     * 查询所有
     * @return
     * @throws SQLException
     */
    public List<User> findAll() throws SQLException {
        return userDao.findAll();
    }
 
    /**
     * 根据ID查询
     * @param id
     * @return
     * @throws SQLException
     */
    public User findByID(int id) throws SQLException {
        return userDao.findByID(id);
    }
 
    /**
     * 登录
     */
    public User login(User user) throws SQLException {
        return userDao.login(user);
    }
 
}

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
package com.jdbc;
 
 
import com.pojo.User;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
 
public class Demo {
    public static void main(String[] args) throws Exception {
 
        //1.动态加载驱动
//        Class.forName("com.mysql.cj.jdbc.Driver");
//
//        //2.获取连接对象
//        String url = "jdbc:mysql://localhost:3306/stu?serverTimezone=GMT%2B8";
//        String user = "root";
//        String pwd = "123456";
//        Connection conn = DriverManager.getConnection(url, user, pwd);
 
        //3.使用jdbc规范实现CRUD
        //String sql = "insert into user(username,password) value(?,?)";
//        String sql ="select * from user ";
//        // 创建一个 PreparedStatement 对象来将参数化的 SQL 语句发送到数据库。
//        PreparedStatement ps = conn.prepareStatement(sql);
//
////        ps.setString(1,"晓峰");//将指定参数设置为给定 Java String 值
////        ps.setString(2,"xf");
//
////        ps.setObject(1,"军帅");//使用给定对象设置指定参数的值。
////        ps.setObject(2,"js");
//
////如果第一个结果是 ResultSet 对象，则返回 true；如果第一个结果是更新计数或者没有结果，则返回 false
////        boolean res = ps.execute();
////        System.out.println(res);
//
//        //(1) SQL 数据操作语言 (DML) 语句的行数 (2) 对于无返回内容的 SQL 语句，返回 0
////        int rel = ps.executeUpdate();
////        System.out.println(rel);//1
//
//        //ResultSet 对象具有指向其当前数据行的光标。最初，光标被置于第一行之前。next 方法将光标移动到下一行；
//        //在此 PreparedStatement 对象中执行 SQL 查询，并返回该查询生成的 ResultSet 对象。
//        ResultSet rs = ps.executeQuery();
////        rs.next();
////        rs.next();
////        rs.next();
////        rs.next();
////        boolean rel = rs.next();
////        System.out.println(rel);
//
//        List<User> list = new ArrayList<User>();
//
//        while (rs.next()){
//
//            int id = rs.getInt(1);
//            String username = rs.getString(2);
//            String password = rs.getString(3);
//
////            User u = new User(id,username,password);
////            list.add(u);
//            User u = (User) Class.forName("com.pojo.User").newInstance();
//            list.add(u);
//
//        }
//
//        System.out.println(list);
 
 
 
    }
}

　　

 

 

三、JDBC常用的类和接口详解

1、java.sql.Drivermanager类：注册驱动、建立连接

　　a、注册驱动

　　　　DriverManager.deregisterDriver(new com.mysql.jdbc.Driver()); // 不建议使用

　　　　原因有2个：

　　　　　　> 导致驱动被注册2次。

　　　　　　> 强烈依赖数据库的驱动jar包  （若把Build Path给Remove掉，代码就会报错，就能看到效果）

　　　　解决办法：

　　　　　　Class.forName("com.mysql.jdbc.Driver");  // 把Build Path给Remove掉，代码也不会报错了

　　　　　　用到反射机制的知识：靠类的全路径来加载，解耦合了，不依赖数据库的驱动jar包了，以后会把上面的字符串放在配置文件里，更灵活了，便于后期维护。

　　b、与数据库建立连接

　　　　DriverManager类的静态方法：

　　　　　　public static Connection getConnection(String url, String user, String password) 试图建立到给定数据库 URL 的连接

　　　　　　DriverManager.getConnection("jdbc:mysql://localhost:3306/stu?serverTimezone=GMT%2B8", "root", "root");

　　　　　　URL:是SUN公司与数据库厂商之间的一种协议。

　　　　　　jdbc:mysql://localhost:3306/stu?serverTimezone=GMT%2B8

　　　　　　协议 子协议     IP   数据库端口号 数据库名称

　　　　　　mysql:jdbc:mysql://localhost:3306/day14 或者 

　　　　　　jdbc:mysql:///day14（默认连接本机的数据库）

 

　　　　　　oracle:jdbc:oracle:thin:@localhost:1521:sid    瘦客户端，比如：玩页游协议   

　　　　　　子协议 子子协议            IP     数据库端口号 数据库名称

　　　　　　oracle:jdbc:oracle:thick:@localhost:1521:sid    胖客户端，比如：LOL、魔兽世界(需要下载软件)

　　　　与数据库建立连接的方式

　　　　第一种：

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

　　　　　　 Connection conn =  DriverManager.getConnection("jdbc:mysql://localhost:3306/stu?serverTimezone=GMT%2B8", "root", "root");

 

　　　　第二种:

　　　　　　// public static Connection getConnection(String url, Properties info)

　　　　　　Properties info = new Properties(); // 要参考数据库文档

　　　　       info.setProperty("username", "root");

　　　　　   info.setProperty("password", "root");

　　　　   Connection conn = DriverManager.getConnection("jjdbc:mysql://localhost:3306/stu?serverTimezone=GMT%2B8", info);

 

　　　　第三种：

　　　　　　// public static Connection getConnection(String url)

　　　　　　Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/stu?serverTimezone=GMT%2B8?username=root&password=root");

　　　　　　// 模拟表单form提交的两种方式：GET和POST

　　　　实际开发常用第一种。

 

 

扩展内容：演示3个案例的话需要写3个main方法，所以有了快速测试的方法 ==> junit技术

 

　　　　package com.itheima.junitdemo;

 

　　　　public class Calc {

 

    　　　　public int add(int a, int b) {

 

        　　　　return a + b;

 

    　　　　}

 

    　　　　public double div(double a, int b) {

 

        　　　　return a / b;

 

    　　　　}

 

　　　　}

 

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

 

　　　　package com.itheima.junitdemo;

 

　　　　import org.junit.Assert;

 

　　　　import org.junit.Test;

 

　　　　// 注：测试的方法有要求：不能有返回值，不能有参数。

 

　　　　public class TestCalc {

 

   　　 　　@Test

 

    　　　　public void test1(){

 

        　　　　Calc c = new Calc();

 

        　　　　Assert.assertEquals(8, c.add(3, 5)); // assert 断言

 

    　　　　}

 

    　　　　@Test

 

    　　　　public void test2(){

 

       　　 　　Calc c = new Calc();

 

        　　　　Assert.assertEquals(3, c.div(10, 3),0.4);

 

    　　　　}

 

　　　　}

 

2、java.sql.Connection接口：一个连接(与数据库连接的一座桥梁)

 

　　该接口的实现在数据库驱动jar包中。所有与数据库交互都是基于连接对象的。

 

　　// 创建执行sql语句的对象Satement(接口)

 

　　// Connection(接口)的方法：Statement createStatement()

 

　　Statement stmt = conn.createStatement();

 

3、java.sql.Statement接口：操作sql语句，并返回相应结果的对象(小货车)

 

　　该接口的实现在数据库驱动jar包中。用于执行静态 SQL 语句并返回它所生成结果的对象。

 

　　// 执行sql语句,该语句返回单个 ResultSet 结果集对象。 

 

　　// Statement(接口)的方法：ResultSet executeQuery(String sql)

 

　　// 注意；该方法只能执行select语句。

 

　　ResultSet rs = stmt.executeQuery("select * from users");

 

 

 

　　// Statement(接口)的方法：int executeUpdate(String sql)

 

　　// 根据执行的 DML(insert update delete)语句，返回受影响的行数。

 

　　// 服务器端叫法：insert、delete、update、select （增删改查）
　　 // 客户端的叫法：create、read、update、delete （CRUD）（增删改查）

 

　　int i = stmt.executeUpdate("INSERT INTO users VALUES (4, 'tom', '123','tom@163.com', '2015-09-28')");

 

　　int i = stmt.executeUpdate("UPDATE users SET NAME = 'jerry', PASSWORD = '333', email = 'jerry@163.com' WHERE id = 4");

 

　　int i = stmt.executeUpdate("DELETE FROM users WHERE id = 4");

 

         

 

　　// Statement(接口)的方法:boolean execute(String sql)

 

　　// 这个方法很奇葩！！！

 

　　// 此方法可以执行任意sql语句。返回boolean值，表示是否返回ResultSet结果集。

 

　　// 仅当执行select语句，且有返回结果时返回true, 其它语句都返回false。

4、java.sql.ResultSet接口：结果集(客户端存表数据的对象)

 

　　a、封装结果集

 

　　　　提供一个游标，默认游标指向结果集第一行之前(即表头)。

 

　　　　调用一次boolean next()，游标向下移动一行。

 

　　　　提供一些getXxx()方法。

 

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

 

　　　　将结果集中的数据封装到javaBean类中，javaBean就是一普通java类，该类中只有private类型的成员变量、无参构造方法和getter/setter方法。

 

　　　　java的数据类型与数据库中的类型的关系:

 

    　　　　JAVA         DB

 

    　　　　byte         tityint 1字节

 

    　　　　short        smallint 2字节

 

    　　　　int          int 4字节

 

    　　　　long         bigint 8字节

 

 

 

    　　　　float        float

 

    　　　　double       double

 

 

 

    　　　　String       char 或者 varchar 

 

    　　　　Date         date

 

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

 

　　　　ResultSet结果集封装数据的方法：

 

　　　　　　Object getObject(int columnIndex) 根据序号取值，索引从1开始

 

　　　　　　Object getObject(String ColomnName) 根据列名取值

 

　　　　　　boolean next() 将光标从当前位置向下移动一行

 

 

 

　　　　　　int getInt(int colIndex) 以int 形式获取ResultSet结果集当前行指定列号值

 

　　　　　　int getInt(String colLabel) 以int 形式获取ResultSet结果集当前行指定列名值

 

 

 

　　　　　　float getFloat(int colIndex) 以float 形式获取ResultSet结果集当前行指定列号值

 

　　　　　　float getFloat(String colLabel) 以float形式获取ResultSet结果集当前行指定列名值

 

 

 

　　　　　　String getString(int colIndex) 以String 形式获取ResultSet结果集当前行指定列号值

 

　　　　　　String getString(String colLabel) 以String 形式获取ResultSet结果集当前行指定列名值

 

 

 

　　　　　　Date getDate(int columnIndex) 以Date 形式获取ResultSet结果集当前行指定列号值

 

　　　　　　Date getDate(String columnName) 以Date 形式获取ResultSet结果集当前行指定列名

 

 

 

　　　　　　void close() 关闭ResultSet 对象

 

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package com.itheima.entitydemo;
 2
 3 import java.util.Date;
 4
 5 /*
 6  * 一般实体类的类名和数据库的表名一致。(注意：若数据库的表名单词带s的，则实体类名就去掉s)
 7  * 实体类的成员变量名和数据库表中的列名一致。(这是一个约定，网站开发的时候会提到)
 8  */
 9 public class User {
10     private int id;
11     private String name;
12     private String password;
13     private String email;
14     private Date birthday;
15
16     public int getId() {
17         return id;
18     }
19
20     public void setId(int id) {
21         this.id = id;
22     }
23
24     public String getName() {
25         return name;
26     }
27
28     public void setName(String name) {
29         this.name = name;
30     }
31
32     public String getPassword() {
33         return password;
34     }
35
36     public void setPassword(String password) {
37         this.password = password;
38     }
39
40     public String getEmail() {
41         return email;
42     }
43
44     public void setEmail(String email) {
45         this.email = email;
46     }
47
48     public Date getBirthday() {
49         return birthday;
50     }
51
52     public void setBirthday(Date birthday) {
53         this.birthday = birthday;
54     }
55
56     @Override
57     public String toString() {
58         return "User [id=" + id + ", name=" + name + ", password=" + password + ", email=" + email + ", birthday="
59                 + birthday + "]";
60     }
61
62 }

 

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
package com.itheima.entitydemo;
  2
  3 import java.sql.Connection;
  4 import java.sql.DriverManager;
  5 import java.sql.ResultSet;
  6 import java.sql.Statement;
  7 import java.util.ArrayList;
  8 import java.util.List;
  9
 10 import org.junit.Test;
 11
 12 /*
 13  * 服务器端叫法：insert、delete、update、select （增删改查）
 14  * 客户端的叫法：create、read、update、delete （CRUD）（增删改查）
 15  */
 16 public class TestCRUD {
 17
 18     @Test
 19     public void testSelect() throws Exception {
 20         // 加载驱动
 21         Class.forName("com.mysql.jdbc.Driver");
 22        
 23         // 获取连接对象Connection(注意：能用接口的就不用实现类，多态=>对象上传=>向上转型=>里氏替换，利于后期代码扩展)
 24         Connection conn =  DriverManager.getConnection("jdbc:mysql://localhost:3306/day06", "root", "root");
 25        
 26         // 获取执行sql语句的对象Statement
 27         Statement stmt = conn.createStatement();
 28        
 29         // 执行sql的查询语句，并返回结果
 30         ResultSet rs = stmt.executeQuery("select * from users");
 31        
 32         // 把取到的数据装到集合中
 33         List<User> list = new ArrayList<User>();
 34        
 35         // 处理结果
 36         User u = null;
 37         while (rs.next()) {
 38             u = new User();
 39             u.setId(rs.getInt("id"));
 40             u.setName(rs.getString("name"));
 41             u.setPassword(rs.getString("password"));
 42             u.setEmail(rs.getString("email"));
 43             u.setBirthday(rs.getDate("birthday"));
 44             list.add(u); // 把对象添加到集合中去
 45         }
 46        
 47         // 遍历集合(增强for)
 48         for (User user : list) {
 49             System.out.println(user);
 50         }
 51        
 52         // 关闭资源
 53         rs.close();
 54         stmt.close();
 55         conn.close();
 56     }
 57    
 58     @Test
 59     public void testInsert() throws Exception {
 60         // 加载驱动
 61         Class.forName("com.mysql.jdbc.Driver");
 62        
 63         // 获取连接对象Connection(注意；能用接口的就不用实现类，多态=>对象上传=>向上转型=>里氏替换，利于后期代码扩展)
 64         Connection conn =  DriverManager.getConnection("jdbc:mysql://localhost:3306/day06", "root", "root");
 65        
 66         // 获取执行sql语句的对象Statement
 67         Statement stmt = conn.createStatement();
 68        
 69         // 执行sql的插入语句，并返回结果
 70         int i = stmt.executeUpdate("INSERT INTO users VALUES (4, 'tom', '123','tom@163.com', '2015-09-28')");
 71        
 72         // 处理返回的结果
 73         if (i > 0) {
 74             System.out.println("success");
 75         }
 76        
 77         // 关闭资源
 78         stmt.close();
 79         conn.close();
 80     }
 81    
 82     @Test
 83     public void testUpdate() throws Exception {
 84         // 加载驱动
 85         Class.forName("com.mysql.jdbc.Driver");
 86        
 87         // 获取连接对象Connection(注意；能用接口的就不用实现类，多态=>对象上传=>向上转型=>里氏替换，利于后期代码扩展)
 88         Connection conn =  DriverManager.getConnection("jdbc:mysql://localhost:3306/day06", "root", "root");
 89        
 90         // 获取执行sql语句的对象Statement
 91         Statement stmt = conn.createStatement();
 92        
 93         // 执行sql的更新语句，并返回结果
 94         int i = stmt.executeUpdate("UPDATE users SET NAME = 'jerry', PASSWORD = '333', email = 'jerry@163.com' WHERE id = 4");
 95        
 96         // 处理返回的结果
 97         if (i > 0) {
 98             System.out.println("success");
 99         }
100        
101         // 关闭资源
102         stmt.close();
103         conn.close();
104     }
105    
106     @Test
107     public void testDelete() throws Exception {
108         // 加载驱动
109         Class.forName("com.mysql.jdbc.Driver");
110        
111         // 获取连接对象Connection(注意；能用接口的就不用实现类，多态=>对象上传=>向上转型=>里氏替换，利于后期代码扩展)
112         Connection conn =  DriverManager.getConnection("jdbc:mysql://localhost:3306/day06", "root", "root");
113        
114         // 获取执行sql语句的对象Statement
115         Statement stmt = conn.createStatement();
116        
117         // 执行sql的删除语句，并返回结果
118         int i = stmt.executeUpdate("DELETE FROM users WHERE id = 4");
119        
120         // 处理返回的结果
121         if (i > 0) {
122             System.out.println("success");
123         }
124        
125         // 关闭资源
126         stmt.close();
127         conn.close();
128     }
129    
130 }

　　

　b、可移动游标的方法(现在很少用了，只有next()还常用)

　　　　ResultSet结果集的方法： 
　　　　　　boolean next() 将光标从当前位置向前移一行
　　　　　　boolean previous() 将光标移动到此 ResultSet 对象的上一行
　　　　　　boolean absolute(int row)  参数是当前行的索引，从1开始，根据行的索引定位移动的指定索引行
　　　　　　void afterLast()  将光标移动到末尾，正好位于最后一行之后
　　　　　　void beforeFirst()  将光标移动到开头，正好位于第一行之前（即表头）

 

5、释放资源 

　　　　资源有限，要正确关闭。

　　　　原则：在使用对象之前，先判断对象是否为空。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
package com.itheima.jdbcdemo;
 2
 3 import java.sql.Connection;
 4 import java.sql.DriverManager;
 5 import java.sql.ResultSet;
 6 import java.sql.SQLException;
 7 import java.sql.Statement;
 8
 9 /*
10  * 使用JDBC技术，通过java代码实现查询数据库中的数据并显示在java的控制台中。
11  *
12  *         演示正确释放资源。
13  *
14  *         把某一部分代码加上try...catch...的快捷键：Alt + Shift + Z
15  */
16 public class Demo4 {
17    
18     public static void main(String[] args) {
19         // 获取连接对象Connection
20         Connection conn = null;
21         // 获取执行sql语句的对象Statement
22         Statement stmt = null;
23         // 执行sql查询语句，并返回结果
24         ResultSet rs = null;
25         try {
26             // 加载驱动
27             Class.forName("com.mysql.jdbc.Driver");
28             conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/day06", "root", "root");
29             stmt = conn.createStatement();
30             rs = stmt.executeQuery("select * from users");
31             // 处理返回的结果
32             while (rs.next()) {
33                 // 根据列名取值，顺序自己定，更灵活
34                 System.out.println(rs.getObject("id"));
35                 System.out.println(rs.getObject("name"));
36                 System.out.println(rs.getObject("password"));
37                 System.out.println(rs.getObject("email"));
38                 System.out.println(rs.getObject("birthday"));
39             }
40         } catch (Exception e) {
41             e.printStackTrace();
42         } finally {
43             // 关闭资源
44             if (rs != null) {
45                 try {
46                     rs.close();
47                 } catch (SQLException e) {
48                     e.printStackTrace();
49                 }
50             }
51             if (stmt != null) {
52                 try {
53                     stmt.close();
54                 } catch (SQLException e) {
55                     e.printStackTrace();
56                 }
57             }
58             if (conn != null) {
59                 try {
60                     conn.close();
61                 } catch (SQLException e) {
62                     e.printStackTrace();
63                 }
64             }   
65         }
66     }
67 }

　　

四、使用JDBC实现CRUD操作

 

 

　注意：
　　　　* 一般实体类的类名和数据库的表名一致。(注意：若数据库的表名单词带s的，则实体类名就去掉s)
　　　　* 实体类的成员变量名和数据库表中的列名一致。(这是一个约定，网站开发的时候会提到)
　　　　后续演示代码的实体类的类名为User。
　　　　其实名字可以随意起的，但是一般要求我们做到见名知意。
 
 

五、实现一个用户登录的功能

 

 

六、解决SQL注入问题：preparedStatement(预编译语句)

 

 

　preparedStatement(接口)：预编译对象，是Statement(接口)对象的子类。

　　　　特点：（安全高效，防止恶义SQL语法）

　　　　1、性能要高；PreparedStatement 实例包含已编译的 SQL 语句，所以其执行速度要快于 Statement 对象。

　　　　2、会把sql语句先编译。

　　　　3、sql语句中的参数会发生变化，过滤掉用户输入的关键字。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package com.itheima.service;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
 
import com.itheima.entity.User;
import com.itheima.util.DBUtils;
 
public class DoLogin {
 
    /**
     * 根据姓名和密码查询用户信息
     * @param name
     * @param password
     * @return User
     */
    public User findUser(String name, String password) {
        Connection conn = null;
        // Statement stmt = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        User u = null;
 
        try {
            conn = DBUtils.getConnection();
             
            // stmt = conn.createStatement();
            // String sql = "select * from users where name = '" + name + "' and password = '" + password + "'";
            // rs = stmt.executeQuery(sql);
             
            String sql = "select * from users where name = ? and password = ?";
            stmt = conn.prepareStatement(sql);
            stmt.setString(1, name); // 给?赋值
            stmt.setString(2, password); // 给?赋值
            rs = stmt.executeQuery();
             
            if (rs.next()) {
                u = new User();
                u.setId(rs.getInt("id"));
                u.setName(rs.getString("name"));
                u.setPassword(rs.getString("password"));
                u.setEmail(rs.getString("email"));
                u.setBirthday(rs.getDate("birthday"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DBUtils.closeAll(rs, stmt, conn);
             
        }
 
        return u;
    }
}

　　

 

posted @   泰斗贤若如  阅读(1861)  评论(10)  编辑  收藏  举报
编辑推荐：
· 如何编写易于单元测试的代码
· 10年+ .NET Coder 心语，封装的思维：从隐藏、稳定开始理解其本质意义
· .NET Core 中如何实现缓存的预热？
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
· AI与.NET技术实操系列：向量存储与相似性搜索在 .NET 中的实现
阅读排行：
· 周边上新：园子的第一款马克杯温暖上架
· Open-Sora 2.0 重磅开源！
· 分享 3 个 .NET 开源的文件压缩处理库，助力快速实现文件压缩解压功能！
· Ollama——大语言模型本地部署的极速利器
· DeepSeek如何颠覆传统软件测试？测试工程师会被淘汰吗？
点击右上角即可分享
微信分享提示
AI IDE Trae