JDBC也就那么回事

悠悠 2021-12-24 10:53 233阅读 0赞

# JDBC #

# 一、JDBC概述 #

为什么要使用**JDBC**？

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

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

![1640688-20190426103329809-1905537321.png][]

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

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

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

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

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

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

**![1640688-20190426103427684-936352512.png][]**

#  二、开发一个JDBC程序 #

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

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

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');

![1640688-20190426104525704-1997809450.png][]

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

**![1640688-20190426104755932-257952838.png][]**

![1640688-20190426105126228-989560896.png][]

**3、实现JDBC操作。**

**![1640688-20190426105339835-440977308.png][]**

** 4.源码示例**

**![1640688-20190426105943439-606283493.png][]**

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;
        }
    
    
    }

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;
        }
    }

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;
        }
    
    }

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);
        }
    
    }

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);
    
    
    
        }
    }

![1640688-20190426110100844-1814546772.png][]

# 三、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 对象**

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 }

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、释放资源  ###

资源有限，要正确关闭。

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

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操作 #

![1640688-20190426112407689-1240251940.png][]

注意：

\* 一般实体类的类名和数据库的表名一致。(注意：若数据库的表名单词带s的，则实体类名就去掉s)

\* 实体类的成员变量名和数据库表中的列名一致。(这是一个约定，网站开发的时候会提到)

后续演示代码的实体类的类名为User。

其实名字可以随意起的，但是一般要求我们做到见名知意。

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

![1640688-20190426112522721-1283892445.png][]

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

![1640688-20190426112604667-488566196.png][]

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

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

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

2、会把sql语句先编译。

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

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;
        }
    }

转载于:https://www.cnblogs.com/zyx110/p/10773306.html

[1640688-20190426103329809-1905537321.png]: /images/20211224/c6e0e47f75194bd2aca2ef8cdfc17159.png
[1640688-20190426103427684-936352512.png]: /images/20211224/ed5bdc6f10ff41c2bd8cbfd798402449.png
[1640688-20190426104525704-1997809450.png]: /images/20211224/3ab6da89646b4678a6ec36747eb59fb6.png
[1640688-20190426104755932-257952838.png]: /images/20211224/cbc843bb1f594933892c66ef4204f118.png
[1640688-20190426105126228-989560896.png]: /images/20211224/19916fae030641a79b9894444ce67eae.png
[1640688-20190426105339835-440977308.png]: /images/20211224/46a30b3ca8374bbdb7ae8321a56855cd.png
[1640688-20190426105943439-606283493.png]: /images/20211224/5adf403a06324f71afe4d8041f8f828e.png
[1640688-20190426110100844-1814546772.png]: /images/20211224/f2b831363641473eaaad4f231a0995a1.png
[1640688-20190426112407689-1240251940.png]: /images/20211224/d030b437b99f47f2b2dfca7e12259092.png
[1640688-20190426112522721-1283892445.png]: /images/20211224/dd15983837064360b6cc6a0e27be3019.png
[1640688-20190426112604667-488566196.png]: /images/20211224/922cc4578db54176a062bcc68d23331f.png