JDBC详解

JDBC数据库操作

JDBC概念：

• JDBC就是使用java语言操作关系型数据库的一套API

• 全程：（Java DataBase Connectivity）Java数据库连接

• JDBC -> 一套标准接口

  • MySQL实现类

  • Oracle实现类

  • DB2实现类

JDBC本质：

• 官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口

• 各个数据库厂商去实现这套接口，提供数据库驱动jar包

• 我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类

JDBC好处：

• 各数据库厂商使用相同的接口，java代码不需要针对不同数据库分别开发

• 可随时替换底层数据库，访问数据库的Java代码基本不变

JDBC快速入门：

• 创建工程，导入驱动jar包

• 注册驱动

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

• 获取连接

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

• 定义SQL语句

String sql = "update...";

• 获取执行SQL对象

Statement stmt = conn.createStatement();

• 执行SQL

stmt.executeUpdate(sql);

• 处理返回结果

• 释放资源

五种连接数据库的方法

password 为自己设置的密码，这里作者设置的是123456，数据库url同理。

方式一

//方式一
Driver driver = new com.mysql.jdbc.Driver();
String url = "jdbc:mysql://localhost:3306/mysql?&useSSL=false&serverTimezone=UTC";
Properties info = new Properties();
info.setProperty("user","root");
info.setProperty("password","123456");
Connection conn = driver.connect(url,info);
System.out.println(conn);

方式二

//方式二
Class clazz = null;
try {
clazz = Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
     e.printStackTrace();
}
Driver driver = null;
try {
      driver = (Driver) clazz.newInstance();
       } catch (InstantiationException e) {
                e.printStackTrace();
       } catch (IllegalAccessException e) {
                e.printStackTrace();
         }
String url = "jdbc:mysql://localhost:3306/mysql?&useSSL=false&serverTimezone=UTC";
Properties info = new Properties();
info.setProperty("user","root");
info.setProperty("password","123456");
Connection conn = driver.connect(url,info);
System.out.println(conn);

方式三

//方式三：使用DriverManger代替Driver
            //1、获取Driver实现类的对象
            Class clazz = null;
            try {
                clazz = Class.forName("com.mysql.jdbc.Driver");
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            Driver driver = null;
            try {
                driver = (Driver)clazz.newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            //2、提供另外三个连接的基本信息
       String url = "jdbc:mysql://localhost:3306/mysql?&useSSL=false&serverTimezone=UTC";
            String user = "root";
            String password = "123456";
            //注册驱动
            DriverManager.registerDriver(driver);
            //获取连接
            Connection conn = DriverManager.getConnection(url,user,password);
            System.out.println(conn);

方式四

//方式四，可以只是加载驱动，不用显示的注册驱动过了
    //提供三个连接的基本信息
       String url = "jdbc:mysql://localhost:3306/mysql?&useSSL=false&serverTimezone=UTC";
            String user = "root";
            String password = "123456";
            //加载Driver
            try {
                Class.forName("com.mysql.jdbc.Driver");
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            CachedJarURLConnection driver;
            Connection conn = DriverManager.getConnection(url,user,password);
            System.out.println(conn);

方式五

//方式五
            InputStream is = JDBC.class.getClassLoader().getResourceAsStream("jdbc.properties");
            Properties pros = new Properties();
                try {
                        pros.load(is);
                } catch (IOException e) {
                        e.printStackTrace();
                }
                String user = pros.getProperty("user");
            String password = pros.getProperty("password");
            String url = pros.getProperty("url");
            String dirverClass = pros.getProperty("dirverClass");
                try {
                        Class.forName(dirverClass);
                } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                }
                Connection conn = DriverManager.getConnection(url,user,password);
            System.out.println(conn);
//对应jdbc.properties文件
user=root
password=123456
url=jdbc:mysql://localhost:3306/mysql?&useSSL=false&serverTimezone=UTC
dirverClass=com.mysql.jdbc.Driver

JDBC数据库操作

//pojo
​
package jdbc.util;
​
public class pojo {
    private int idemploy;
    private String myemployees;
    private String girls;
    private String job_grades;
    private String student;
​
    public int getIdemploy() {
        return idemploy;
    }
​
    public void setIdemploy(int idemploy) {
        this.idemploy = idemploy;
    }
​
    public String getMyemployees() {
        return myemployees;
    }
​
    public void setMyemployees(String myemployees) {
        this.myemployees = myemployees;
    }
​
    public String getGirls() {
        return girls;
    }
​
    public void setGirls(String girls) {
        this.girls = girls;
    }
​
    public String getJob_grades() {
        return job_grades;
    }
​
    public void setJob_grades(String job_grades) {
        this.job_grades = job_grades;
    }
​
    public String getStudent() {
        return student;
    }
​
    public void setStudent(String student) {
        this.student = student;
    }
    public String toString(){
        return "pojo" +
                "idemploy= "+idemploy+
                ", myemployees= "+myemployees+
                ", girls= "+girls+
                ", job_grades= "+job_grades+
                ", student= "+student+
                "";
    }
}
​

一、修改mysql数据库

//方法一
package jdbc.util;
​
import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
​
public class zsgc {
  public static void main(String[] args) throws ClassNotFoundException, SQLException {
     
      //1、注册驱动
      Class.forName("com.mysql.jdbc.Driver");
      
      //2、获取连接
      String url = "jdbc:mysql://localhost:3306/mysql?&useSSL=false&serverTimezone=UTC";
      String user = "root";
      String password = "123456";
      Connection conn = DriverManager.getConnection(url,user,password);
      
      //3、定义sql，修改数据库信息
      String sql = "UPDATE new_schema.employ SET girls = 'true' WHERE idemploy = 1";
     
      //4、获取执行sql的对象Statement
      Statement stmt = conn.createStatement();
      
      //5、执行sql
      int count = stmt.executeUpdate(sql);
     
      //6、释放资源
      stmt.close();
      conn.close();
       
}
}
​
​
//方法二
//注意主键唯一性的问题，如出现Duplicate entry 'xxxxx' for key 'yyyy'的问题
package jdbc.util;
​
import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.junit.Test;
​
import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.Properties;
​
/**
 * 添加
 * 1.SQL：
 *update xxx
 *    set idemploy = ?,
 *    myemployees = ?,
 *    girls       = ?,
 *    job_grades  = ?,
 *    student     = ?
 *where idemploy = ?
 * 2.参数：需要，所有数据
 * 3.结果：boolean
 */
public class xiugai {
    @Test
    public void Updata() throws Exception {
        //接收页面提交的参数
        int idemploy = 4;
        String myemployees = "xiaoliu";
        String girls = "false";
        String job_grades = "老师";
        String student = "true";
        int id = 4;
​
​
        //1.获取Connection
        //2.加载配置文件
        Properties prop = new Properties();
        prop.load(new FileInputStream("D:/idea/untitled/src/jdbc/util/Druid.properties"));//文件的完全路径
​
        //3.获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
​
        //4.获取数据库连接 Connection
        Connection conn = dataSource.getConnection();
​
        //5.定义SQL
        String sql = "update new_schema.employ\n" +
                "     set idemploy = ?,\n" +
                "     myemployees = ?,\n" +
                "     girls       = ?,\n" +
                "     job_grades  = ?,\n" +
                "     student     = ?\n" +
                "     where idemploy = ?";
​
        //6.获取pstmt对象
        PreparedStatement pstmt = conn.prepareStatement(sql);
​
        //7.设置参数
        pstmt.setInt(1, idemploy);
        pstmt.setString(2,myemployees);
        pstmt.setString(3,girls);
        pstmt.setString(4,job_grades);
        pstmt.setString(5,student);
        pstmt.setInt(6,id);
​
        //8.执行SQL
        int count = pstmt.executeUpdate();//影响的行数
​
        //9.处理结果 List<xxx> 封装xxx对象，装载List集合
        System.out.println(count > 0);
​
        //10、释放资源
        //rs.close();
        pstmt.close();
        conn.close();
    }
}
​

二、查询所有数据

package jdbc.util;
​
import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.junit.Test;
​
import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
​
public class chaxun {
    /**
     * 查询所有
     * 1.SQL：select *from xxx;
     * 2.参数：不需要
     * 3.结果：List<xxx>
     */
    @Test
    public void SelectAll() throws Exception {
        //1.获取Connection
        //2.加载配置文件
        Properties prop = new Properties();
        prop.load(new FileInputStream("D:/idea/untitled/src/jdbc/util/Druid.properties"));//文件的完全路径
​
        //3.获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
​
        //4.获取数据库连接 Connection
        Connection conn = dataSource.getConnection();
​
        //5.定义SQL
        String sql = "select * from new_schema.employ";
​
        //6.获取pstmt对象
        PreparedStatement pstmt = conn.prepareStatement(sql);
​
        //7.设置参数
​
        //8.执行SQL
        ResultSet rs = pstmt.executeQuery();
​
        //9.处理结果 List<xxx> 封装xxx对象，装载List集合
        pojo poj = null;
        List<pojo> lists = new ArrayList<>();
        while(rs.next())
        {
            //读取数据
            int idemploy = rs.getInt("idemploy");
            String myemployees = rs.getString("myemployees");
            String girls = rs.getString("girls");
            String job_grades = rs.getString("job_grades");
            String student = rs.getString("student");
            //封装xxx对象
            poj = new pojo();
            poj.setIdemploy(idemploy);
            poj.setMyemployees(myemployees);
            poj.setGirls(girls);
            poj.setJob_grades(job_grades);
            poj.setStudent(student);
​
            //装载集合
            lists.add(poj);
        }
        System.out.println(lists);
        //10、释放资源
        rs.close();
        pstmt.close();
        conn.close();
    }
}
​

//结果
Loading class `com.mysql.jdbc.Driver'. This is deprecated. The new driver class is `com.mysql.cj.jdbc.Driver'. The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.
五月 21, 2022 11:47:56 下午 com.alibaba.druid.pool.DruidDataSource info
信息: {dataSource-1} inited
[pojoidemploy= 1, myemployees= xiaoli, girls= true, job_grades= 学生, student= true, pojoidemploy= 2, myemployees= xiaoming, girls= true, job_grades= 学生, student= true, pojoidemploy= 3, myemployees= xiaohong, girls= true, job_grades= 经理, student= false]

三、添加数据

package jdbc.util;
​
import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.junit.Test;
import service.pojo;
​
import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
​
public class zengjia {
    /**
     * 添加
     * 1.SQL：insert into new_schema.employ(idemploy,myemployees,grils,job_grades,student)values(?,?,?,?,?);
     * 2.参数：需要，除了id之外的所有参数信息
     * 3.结果：boolean
     */
    @Test
    public void Add() throws Exception {
        //接收页面提交的参数
        int idemploy = 4;
        String myemployees = "xiaoliu";
        String girls = "false";
        String job_grades = "学生";
        String student = "true";
​
​
        //1.获取Connection
        //2.加载配置文件
        Properties prop = new Properties();
        prop.load(new FileInputStream("D:/idea/untitled/src/jdbc/util/Druid.properties"));//文件的完全路径
​
        //3.获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
​
        //4.获取数据库连接 Connection
        Connection conn = dataSource.getConnection();
​
        //5.定义SQL
        String sql = "insert into new_schema.employ(idemploy,myemployees,girls,job_grades,student)values(?,?,?,?,?);";
​
        //6.获取pstmt对象
        PreparedStatement pstmt = conn.prepareStatement(sql);
​
        //7.设置参数
        pstmt.setInt(1, idemploy);
        pstmt.setString(2,myemployees);
        pstmt.setString(3,girls);
        pstmt.setString(4,job_grades);
        pstmt.setString(5,student);
​
        //8.执行SQL
        int count = pstmt.executeUpdate();//影响的行数
​
        //9.处理结果 List<xxx> 封装xxx对象，装载List集合
        System.out.println(count > 0);
​
        //10、释放资源
        //rs.close();
        pstmt.close();
        conn.close();
    }
}
​

四、删除数据

package jdbc.util;
​
import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.junit.Test;
​
import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.Properties;
​
public class shanchu {
    /**
     * 添加
     * 1.SQL：delete from xxx where if = ?;
     * 2.参数：需要:id
     * 3.返回结果如何封装：boolean
     */
    @Test
    public void delete() throws Exception {
        //接收页面提交的参数
​
        int id = 4;
​
        //1.获取Connection
        //2.加载配置文件
        Properties prop = new Properties();
        prop.load(new FileInputStream("D:/idea/untitled/src/jdbc/util/Druid.properties"));//文件的完全路径
​
        //3.获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
​
        //4.获取数据库连接 Connection
        Connection conn = dataSource.getConnection();
​
        //5.定义SQL
        String sql = "delete from new_schema.employ where idemploy = ?";
​
        //6.获取pstmt对象
        PreparedStatement pstmt = conn.prepareStatement(sql);
​
        //7.设置参数
        pstmt.setInt(1,id);
​
        //8.执行SQL
        int count = pstmt.executeUpdate();//影响的行数
​
        //9.处理结果 List<xxx> 封装xxx对象，装载List集合
        System.out.println(count > 0);
​
        //10、释放资源
        //rs.close();
        pstmt.close();
        conn.close();
    }
}
​

JDBC API详解

一、DriverManager

• DriverManager(驱动管理类)作用

1、注册驱动

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

//源码
​
package com.mysql.cj.jdbc;
​
import java.sql.DriverManager;
import java.sql.SQLException;
​
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    public Driver() throws SQLException {
    }
​
    static {
        try {
            DriverManager.registerDriver(new Driver());
        } catch (SQLException var1) {
            throw new RuntimeException("Can't register driver!");
        }
    }
}
​

​

2、获取连接

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

3、 url:指定连接的路径. jdbc.mysql://ip地址或域名:端口/数据库名称

jdbc:mysql://localhost:3306/mysql?&useSSL=false&serverTimezone=UTC

jdbc.mysql://localhost:3306/db3

细节: 如果连接的是本机的mysql服务器,并且mysql服务默认是3306,则这个地方的url课简写: jdbc.mysql:///db3 也就是把ip:端口 删除掉,不用写

4、 user: 用户名

5、 password: 密码

二、Connection

• 获取执行sql的对象

1、普通执行SQL对象

Statement createStatement()

2、预编译SQL的执行SQL对象：防止SQL注入

PreparedStatement prepareStatement(sql)

3、执行存储过程的对象

CallableStatement prepareCall(sql)

• 管理事务

  1、管理事务(一个业务操作,有多个步骤,要么所有都成功,要么都失败) ​ 2、开启事务 setAutoCommit, 设置false,则是开启事务 ​ 3、提交事务: commit ​ 4、回滚事务: rollback

  package jdbc.util;
  ​
  import java.io.IOException;
  import java.io.InputStream;
  import java.sql.*;
  import java.util.Properties;
  ​
  public class zsgc {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //获取连接
        String url = "jdbc:mysql://localhost:3306/mysql?&useSSL=false&serverTimezone=UTC";
        String user = "root";
        String password = "123456";
        Connection conn = DriverManager.getConnection(url,user,password);
        //定义sql
        String sql1 = "UPDATE new_schema.employ SET girls = 'true' WHERE idemploy = 1";
        String sql2 = "UPDATE new_schema.employ SET girls = 'true' WHERE idemploy = 2";
        //获取执行sql的对象 Statement
        Statement stmt = conn.createStatement();
  ​
        //ctrl+alt+t 自定义异常
        try {
            //开启事务
            conn.setAutoCommit(false);
            //执行sql
            int count1 = stmt.executeUpdate(sql1);
            //处理结果
            System.out.println(count1);
            //int i=3/0; 使下面部分出现异常，体现了事务的作用，建议实操：若是没有事务操作，则上部分数据会改变，下部分因为出现i=3/0这个异常而不执行；若是添加事务操作，则上部分和下部分的数据均不改变
            //执行sql
            int count2 = stmt.executeUpdate(sql2);
            //处理结果
            System.out.println(count2);
  ​
            //提交事务
            conn.commit();
        } catch (Exception throwables) {
            //回滚事务
            conn.rollback();
            throwables.printStackTrace();
        }
  ​
        //处理结束
        stmt.close();
        conn.close();
  ​
  }
  }

三、Statement

1、执行sql的对象(静态sql,参数都是给定值)

//作用

(1)execute-->了解

(2)int executeUpdate(sql)-->执行DML(增删改 Insert update delete)语句、DDL(创建或删除表、创建或删除库 create alter drop)
   返回值是: DML语句影响的行数。 > 0 则一般认为执行成功
           DDL语句执行后，执行成功也可能返回0

(3)Resultset executeQuery(sql)-->执行DQL(查询)
        返回值: 结果集对象

2、案例

package jdbc.util;
​
import org.junit.Test;
​
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
​
public class JDBC_Statement {
​
    //执行DML语句
    @Test
     public void testDML() throws Exception {
            //1、注册驱动
            Class.forName("com.mysql.jdbc.Driver");
​
            //2、获取连接
            String url = "jdbc:mysql://localhost:3306/mysql?&useSSL=false&serverTimezone=UTC";
            String user = "root";
            String password = "123456";
            Connection conn = DriverManager.getConnection(url,user,password);
​
            //3、定义sql，修改数据库信息
            String sql = "UPDATE new_schema.employ SET girls = 'true' WHERE idemploy = 1";
​
            //4、获取执行sql的对象Statement
            Statement stmt = conn.createStatement();
​
            //5、执行sql
            int count = stmt.executeUpdate(sql);//执行完DML语句，受影响的行数
            if(count>0){
                System.out.println("修改成功");
            }
            else{
                System.out.println("修改失败");
            }
            //6、处理结果
            // System.out.println(count);
​
            //7、释放资源
            stmt.close();
            conn.close();
​
        }
​
    //执行DDL语句
    @Test
    public void testDDL() throws Exception {
        //1、注册驱动
        Class.forName("com.mysql.jdbc.Driver");
​
        //2、获取连接
        String url = "jdbc:mysql://localhost:3306/mysql?&useSSL=false&serverTimezone=UTC";
        String user = "root";
        String password = "123456";
        Connection conn = DriverManager.getConnection(url,user,password);
​
        //3、定义sql，修改数据库信息
        String sql = "Create database db2";//drop删除数据库
​
        //4、获取执行sql的对象Statement
        Statement stmt = conn.createStatement();
​
        //5、执行sql
        int count = stmt.executeUpdate(sql);//返回值可能是0
​
        //6、处理结果
        System.out.println(count);
​
        //7、释放资源
        stmt.close();
        conn.close();
​
    }
}

四、ResultSet

• ResultSet(结果集对象)作用

1、封装了DQL查询语句的结果

ResultSet stmt.executeQuery(sql) :执行DQL语句，返回ResultSet对象

• 获取查询结果

boolean next():
   (1)将光标从当前位置向前移动一行（2）判断当前行是否为有效行

返回值：
  （1）true:有效行，当前行有数据
  （2）false:无效行，当前行没有数据
xxx getXxx(参数) ： 获取数据
   （1）xxx:数据类型；如：int getInt(参数)；String getString(参数)
   （2）参数：int : 列的编号，从1开始
            String ： 列的名称

• 使用步骤：

1、游标向下移动一行，并判断该行是否有数据：next()

2、获取数据：getXxx(参数)

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

• 案例

@Test
    public void testResultSet() throws Exception {
        //1、注册驱动
        Class.forName("com.mysql.jdbc.Driver");
​
        //2、获取连接
        String url = "jdbc:mysql://localhost:3306/mysql?&useSSL=false&serverTimezone=UTC";
        String user = "root";
        String password = "123456";
        Connection conn = DriverManager.getConnection(url,user,password);
​
        //3、定义sql，查询数据库信息
        String sql = "Select * from new_schema.employ";
​
        //4、获取执行sql的对象Statement
        Statement stmt = conn.createStatement();
​
        //5、执行sql
        ResultSet rs = stmt.executeQuery(sql);
​
        //6、处理结果，遍历rs中的所有数据
        //6.1、光标向下移动一行，并且判断是否有数据
        //方法一
        while(rs.next()){
            //6.2、获取数据  getXxx
            int idemploy = rs.getInt(1);
            String myemployees = rs.getString(2);
            String girls = rs.getString(3);
            String job_grades = rs.getString(4);
            String student = rs.getString(5);
​
            System.out.println(idemploy);
            System.out.println(myemployees);
            System.out.println(girls);
            System.out.println(job_grades);
            System.out.println(student);
​
            System.out.println("--------------");
        }
​
        //方法二
        while(rs.next()){
            //6.2、获取数据  getXxx
            int idemploy = rs.getInt("idemploy");
            String myemployees = rs.getString("myemployees");
            String girls = rs.getString("girls");
            String job_grades = rs.getString("job_grades");
            String student = rs.getString("student");
​
            System.out.println(idemploy);
            System.out.println(myemployees);
            System.out.println(girls);
            System.out.println(job_grades);
            System.out.println(student);
​
            System.out.println("--------------");
        }
​
​
        //7、释放资源
        rs.close();
        stmt.close();
        conn.close();
​
    }

/**
     * 查询new_schema.employ账户表数据，封装为pojo对象中，并且存储到ArrayList集合中
     * 1、定义实体类pojo
     * 2、查询数据，封装到pojo对象中
     * 3、将new_schema.employ对象存入ArrayList集合中
     * @throws Exception
     */
    @Test
    public void testResultSet() throws Exception {
        //1、注册驱动
        Class.forName("com.mysql.jdbc.Driver");
​
        //2、获取连接
        String url = "jdbc:mysql://localhost:3306/mysql?&useSSL=false&serverTimezone=UTC";
        String user = "root";
        String password = "123456";
        Connection conn = DriverManager.getConnection(url,user,password);
​
        //3、定义sql，查询数据库信息
        String sql = "Select * from new_schema.employ";
​
        //4、获取执行sql的对象Statement
        Statement stmt = conn.createStatement();
​
        //5、执行sql
        ResultSet rs = stmt.executeQuery(sql);
​
        //创建集合
        List<pojo> list = new ArrayList<>();
​
        //6、处理结果，遍历rs中的所有数据
        //6.1、光标向下移动一行，并且判断是否有数据
        //方法一
        while(rs.next()){
            pojo poj = new pojo();
​
            //6.2、获取数据  getXxx
            int idemploy = rs.getInt("idemploy");
            String myemployees = rs.getString("myemployees");
            String girls = rs.getString("girls");
            String job_grades = rs.getString("job_grades");
            String student = rs.getString("student");
​
            //赋值
            poj.setIdemploy(idemploy);
            poj.setMyemployees(myemployees);
            poj.setGirls(girls);
            poj.setJob_grades(job_grades);
            poj.setStudent(student);
​
            //存入集合123456
            list.add(poj);
        }
​
        System.out.println(list);
​
        //7、释放资源
        rs.close();
        stmt.close();
        conn.close();
​
    }

五、PreparedStatement

• 作用：

1、预编译SQL语句并执行；性能更高

2、预防SQL注入问题（将 ‘ 进行转义，即 \‘）

• SQL注入

1、SQL注入是通过操作输入来修改实现定义好的SQL语句，用以达到执行代码对服务器进行攻击的方法

@Test
    public void testResultSet() throws Exception {
        //1、注册驱动
        Class.forName("com.mysql.jdbc.Driver");
​
        //2、获取连接
       String url = "jdbc:mysql://localhost:3306/mysql?&useSSL=false&serverTimezone=UTC";
        String user = "root";
        String password = "123456";
        Connection conn = DriverManager.getConnection(url, user, password);
​
​
        // 接收用户输入 用户名和密码
        String name = "xiaoli";
        String std = "' or '1' = '1";//这里实现了sql注入
        //3、定义sql，查询数据库信息
        String sql = "Select * from new_schema.employ where myemployees = '"+name+"' and student = '"+std+"'";
        //System.out.println(sql);
​
        //获取stmt对象
        Statement stmt = conn.createStatement();
​
        // 执行sql
        ResultSet rs = stmt.executeQuery(sql);
​
        //判断登录是否成功
        if(rs.next()){
            System.out.println("登陆成功");
        }
        else{
            System.out.println("登陆失败");
        }
        //7、释放资源
        rs.close();
        stmt.close();
        conn.close();
​
    }

登陆成功

• 获取PreparedStatement对象

//SQL语句中的参数值，使用？占位符替代
String sql = "select *from user where username = ? and password = ?";
​
//通过Connection对象获取，并传入对应的sql语句
PreparedStatement pstmt = conn.prepareStatement(sql);

• 设置参数

PreparedStatement对象 : setXxx(参数1，参数2)：给？赋值
  Xxx:数据类型 ； 如setlnt(参数1，参数2)
  参数：
      参数1： ？的位置编号，从1开始
      参数2： ？的值

• 执行SQL

executeUpdate();/executeQuery; :不需要再船体sql

• 案例

@Test
    public void testResultSet() throws Exception {
        //1、注册驱动
        Class.forName("com.mysql.jdbc.Driver");
​
        //2、获取连接
        String url = "jdbc:mysql://localhost:3306/mysql?&useSSL=false&serverTimezone=UTC";
        String user = "root";
        String password = "123456";
        Connection conn = DriverManager.getConnection(url, user, password);
​
​
        // 接收用户输入 用户名和密码
        String name = "xiaoli";
        String std = "true";
​
        //定义sql
        String sql = "select * from new_schema.employ where myemployees = ? and student = ?";
​
        //获取pstmt对象
        PreparedStatement pstmt = conn.prepareStatement(sql);//对应sql语句发送给服务器了，mysql服务器会进行检查SQL语法和编译SQL，实现了预编译
​
        //设置？的值
        pstmt.setString(1,name);
        pstmt.setString(2,std);
​
        //执行sql
        ResultSet rs = pstmt.executeQuery();
​
        //7、释放资源
        rs.close();
        pstmt.close();
        conn.close();
​
    }

• 原理

1、在获取PreparedStatement对象时，将sql语句发送给mysql服务器进行检查，编译（这些步骤很耗时）

2、执行时就不用再进行这些步骤了，速度更快

3、如果sql模板一样，则只需进行一次检查、编译

数据库连接池实现

• 数据库连接池是个容器，负责分配、管理数据库连接

• 它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个

• 释放空间时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏

• 好处：

1、资源重用

2、提升系统响应速度

3、避免数据库连接遗漏

• 标准接口：DataSource

1、官方提供的数据库连接池标准接口，由第三方组织实现此接口

2、功能：获取连接

Connection getConnection()

• 常见的数据库连接池：

1、DBCP

2、C3P0

3、Druid

• Druid(德鲁伊)

1、Druid连接池是阿里巴巴开源的数据库连接池项目

2、功能强大，性能优秀，是java语言最好的数据库连接池之一