java学习【JDBC入门】

1.1 回顾

之前操作mysql数据库：
1）使用mysql客户端工具
2）使用客户端连接mysql服务器
3）发送sql语句到mysql服务器，执行

1.2 什么是JDBC？

使用java程序发送sql语句到数据库服务器端执行，这叫用到了JDBC技术！！！！
jdbc是Oracle-Sun公司设计的一套专门用于java程序操作数据库的接口。

1.3 使用jdbc发送sql条件
连接mysql数据库：

数据库主机
端口
数据库用户名
数据库密码
连接的数据库

1.4 JDBC的核心API

Driver接口： 数据库驱动程序的接口，所有具体数据库厂商需要的驱动程序需要实现此接口。
Connection connect(String url, Properties info) 用于获取数据库连接

案例：演示三种连接数据库的方式

package day21.edu_driver;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;

import com.mysql.jdbc.Driver;

public class DriverDemo {
    private static String url = "jdbc:mysql://localhost:3306/day20"; 
    //jdbc协议:mysql协议://主机地址:端口号/需要连接的数据库名称
    private static String user = "root";
    private static String password = "root";
    public static void main(String[] args) throws Exception {


        //直连(利用Driver接口的connect方法)
        //coon1();

        //coon2();(利用类 DriverManager来管理)

        coon3();
        //以后就使用这种方式获取数据库的连接对象
    }

    private static void coon3() throws Exception {
        //注册驱动，我们发现mysql驱动程序的Driver实现类已经帮我们在静态代码块中注册好了驱动，
        //我们在此时只需要将Driver实现类加载到我们的内存中，static代码块就会自动执行，我们的驱动也就自动注册了
        //注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //得到class的对象，使用Class类中的静态forname()方法获得与字符串对应的CLass对象

        //获取java连接数据库的对象
        Connection conn = DriverManager.getConnection(url, user, password);

        //打印这个连接对象
        System.out.println(conn);

    }

    private static void coon2() throws Exception {
        //使用驱动管理类，来管理我们的驱动程序，并获取连接
        //1.注册驱动
        //public static void registerDriver(Driver driver)throws SQLException
        // 向 DriverManager 注册给定驱动程序
        Driver driver = new com.mysql.jdbc.Driver();
        DriverManager.registerDriver(driver);

        //获取连接
        //public static Connection getConnection(String url,String user,String password)throws SQLException
        Connection coon = DriverManager.getConnection(url, user, password);

        //打印这里数据库连接
        System.out.println(coon);

    }

    private static void coon1() throws Exception {
        //创建一个驱动类对象Driver
        Driver driver = new com.mysql.jdbc.Driver();
        //获取java连接数据库的连接（driver接口中的connec方法）
        //Connection connect(String url, Properties info)throws SQLException

        //url - 要连接到的数据库的 URL
        //info - 做为连接参数的任意字符串标记/值对的列表。通常至少应该包括 "user" 和 "password" 属性。
        //返回 - 表示到 URL 的连接的 Connection 对象

        //创建一个properties集合
        Properties prop = new Properties();
        prop.setProperty("user", user);
        prop.setProperty("password", password);
        //public Object setProperty(String key,String value)
        //key - 要置于属性列表中的键。
        //value - 对应于 key 的值。

        Connection conn = driver.connect(url, prop);

        //打印这个连接对象，如果连接对象不为空，就说明我们已经成功获取到了连接对象
        System.out.println(conn);
    }
}

Connection接口：与具体的数据库的连接对象。

Statement createStatement()    创建一个静态sql语句对象

PreparedStatement prepareStatement(String sql)  创建预编译的sql语句对象

CallableStatement prepareCall(String sql)   创建存储过程的sql语句对象

Statement接口：用于执行静态 SQL 语句

(create/alter/drop) DDL语句

(insert/update/delete)DML语句

ResultSet executeQuery(String sql)  执行查询操作的sql语句

(select)（DQL查询语句）

PreparedStatement接口：用于执行预编译的 SQL 语句（是Statement的子接口）

int executeUpdate()  执行更新操作的sql语句
ResultSet executeQuery()  执行查询操作的sql语句

CallableStatement接口：用于执行 SQL 存储过程的接口（是PreparedStatement的子接口）

ResultSet executeQuery()  执行存储过程的sql语句

ResultSet接口：结果集对象。 存储所有数据库查询的结果，用该对象进行数据遍历。

boolean next() ： 把光标移动到下一行。如果下一行有数据，返回true，如果没有下一行数 据，返回false。
getXXX（列索引|列字段名称）： 获取字段的数据

2 . Statement对象执行SQL操作
2.1通过jdbc执行DDL语句（create/alter/drop) DDL语句

package day21.edu_statement;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class Demo {
    private static String url = "jdbc:mysql://localhost:3306/day20";
    private static String user = "root";
    private static String password = "root";
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        //注册驱动
        try {
            Class.forName("com.mysql.jdbc.Driver");
            //通过驱动管理类获取数据库连接
            conn = DriverManager.getConnection(url, user, password);
            //创建语句执行者
            stmt = conn.createStatement();
            //int executeUpdate(String sql)throws SQLException执行给定 SQL 语句，
            //该语句可能为 INSERT、UPDATE 或 DELETE 语句，或者不返回任何内容的 SQL 语句（如 SQL DDL 语句）。
            String sql = "CREATE TABLE student("+
                    "id INT,"+
                    "NAME VARCHAR(20),"+
                    "age INT"+
                    ");";
            //使用语句执行者执行创建的sql语句
            int count = stmt.executeUpdate(sql);

            //打印一下影响的结果
            System.out.println(count);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException();
        }finally{
            //释放资源
            if(conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(stmt!=null){
                try {
                    stmt.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

2.2通过jdbc执行DML语句(insert/update/delete)

package day21.edu_statement;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;


public class Demo2 {
    private static String url = "jdbc:mysql://localhost:3306/day20";
    private static String user = "root";
    private static String password = "root";
    public static void main(String[] args) {
        //testInsert();//给数据库添加一条记录
        //testUpdate();//修改数据库中的一条数据
        testDelete();//删除数据库中的一条数据
    }
    private static void testDelete() {
        Connection conn = null;
        Statement stmt = null;
        try {
            //1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接对象
            conn = DriverManager.getConnection(url, user, password);
            //3.准备sql
            String sql = "DELETE FROM student WHERE id=1;";
            //4.获取语句执行者
            stmt = conn.createStatement();
            //5.发送并执行sql
            int count = stmt.executeUpdate(sql);
            //打印影响的行数
            System.out.println(count);

        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException();
        }finally{
            if(conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }if(stmt!=null){
                try {
                    stmt.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

    }
    private static void testUpdate() {
        //需求：将刘德华改为岳云鹏
        Connection conn = null;
        Statement stmt = null;
        try {
            //1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接对象
            conn = DriverManager.getConnection(url, user, password);
            //3.准备sql
            String sql = "UPDATE student SET NAME='岳云鹏' WHERE id=1;";
            //4.获取语句执行者
            stmt = conn.createStatement();
            //5.发送并执行sql
            int count = stmt.executeUpdate(sql);
            //打印影响的行数
            System.out.println(count);

        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException();
        }

    }
    private static void testInsert() {
        //专门测试添加功能
        Connection conn = null;
        Statement stmt = null;
        try {
            //注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //获取连接
            conn = DriverManager.getConnection(url, user, password);
            //定义sql
            String sql = "INSERT INTO student VALUES(1,'刘德华',50);";
            //获取语句执行者
            stmt = conn.createStatement();
            //使用语句执行者发送并执行sql语句,并返回影响的行数
            int count = stmt.executeUpdate(sql);
            System.out.println(count);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException();
        }finally{
            //释放资源
            if(conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(stmt!=null){
                try {
                    stmt.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }       
    }
}

2.3使用jdbc执行DQL语句（select）

package day21.edu_statement;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

import day21.edu_Util.JDBCUtil;


public class Demo3 {
    public static void main(String[] args) {
        //定义一个连接对象和一个语句执行者
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try {
            conn = JDBCUtil.getconn();
            //获取java连接数据库的对象

            //定义sql
            String sql = "SELECT * FROM student;";
            //获取语句执行者对象
            stmt = conn.createStatement();
            //执行DQL查询语句
            //ResultSet executeQuery(String sql)throws SQLException执行给定的 SQL 语句，该语句返回单个 ResultSet 对象。
            rs = stmt.executeQuery(sql);
            //ResultSet是一个结果集

            //使用字段名称获取字段的每一个数据
            while(rs.next()){
                System.out.println(rs.getInt("id")+"  "+rs.getString("name")+"  "+rs.getInt("age"));

            }

        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            JDBCUtil.close(conn, stmt, rs);
        }
    }

}

2.4jdbc工具类的抽取

package day21.edu_Util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCUtil {
    private static String url = "jdbc:mysql://localhost:3306/day20";
    private static String user = "root";
    private static String password = "root";

    static{//随着类的加载而加载
        try {//注册驱动
        Class.forName("com.mysql.jdbc.Driver");
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

    public static Connection getconn(){
        //获取java连接数据库的对象
        try {
            Connection conn = DriverManager.getConnection(url, user, password);
            return conn;
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            throw new RuntimeException();
        }
    }

    public static void close(Connection conn,Statement stmt,ResultSet rs){
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            }
        if(stmt!=null){
            try {
                stmt.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            }
        if(rs!=null){
        try {
            rs.close();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            }
        }
    }
}

3 . PreparedStatement对象执行SQL操作
使用PreparedStatement执行sql语句

package day21.edu4_preparedstatement;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import day21.edu3_Util.JDBCUtil;

public class Demo {
    public static void main(String[] args) {
        //testInsert();
        //testUpdate();
        //testDelete();
        testSelect();
    }

    private static void testSelect() {
        Connection conn  =null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        try{
            //获取连接
            conn  = JDBCUtil.getconn();
            //定义预编译sql
            String sql = "SELECT * FROM student WHERE id=?;";
            //获取预编译sql对象
            stmt = conn.prepareStatement(sql);
            //给问好赋值
            stmt.setInt(1, 1);
            //发送参数并执行sql语句
            //ResultSet executeQuery()throws SQLException在此 
            //PreparedStatement 对象中执行 SQL 查询，并返回该查询生成的 ResultSet 对象。
            rs = stmt.executeQuery();
            //遍历结果集
            while (rs.next()) {
                System.out.println(rs.getInt("id")+"--"+rs.getString("name")+"--"+rs.getInt("age"));
            }

        }catch(Exception e){
            e.printStackTrace();
        }finally{
            JDBCUtil.close(conn, stmt, rs);
        }

    }

    private static void testDelete() {
        //定义连接对象和预编译sql对象
                Connection conn = null;
                PreparedStatement stmt = null;
                try {
                    //获取链接
                    conn = JDBCUtil.getconn();
                    //PreparedStatement prepareStatement(String sql)throws SQLException
                    //创建一个 PreparedStatement 对象来将参数化的 SQL 语句发送到数据库
                    String sql = "DELETE FROM student WHERE id=?;";//参数化的sql,动态sql
                    stmt = conn.prepareStatement(sql);
                    //需要一个预编译的sequel语句，将sq发送到数据库端，检查sql语法及用户权限等信息

                    //给之前参数化的sql语句设置参数
                    //两个参数：1：是给第几个？设置数据    2：给？设置的数据
                    stmt.setInt(1, 5);
                    //int executeUpdate()throws SQLException
                    int count = stmt.executeUpdate();
                    System.out.println(count);

                } catch (Exception e) {
                    e.printStackTrace();
                }finally{
                    JDBCUtil.close(conn, stmt, null);
                }

    }

    private static void testUpdate() {
        //定义连接对象和预编译sql对象
                Connection conn = null;
                PreparedStatement stmt = null;
                try {
                    //获取链接
                    conn = JDBCUtil.getconn();
                    //PreparedStatement prepareStatement(String sql)throws SQLException
                    //创建一个 PreparedStatement 对象来将参数化的 SQL 语句发送到数据库
                    String sql = "UPDATE student SET NAME=? WHERE id=?;";//参数化的sql,动态sql
                    stmt = conn.prepareStatement(sql);
                    //需要一个预编译的sequel语句，将sq发送到数据库端，检查sql语法及用户权限等信息

                    //给之前参数化的sql语句设置参数
                    //两个参数：1：是给第几个？设置数据    2：给？设置的数据
                    stmt.setString(1, "张学友");
                    stmt.setInt(2, 5);
                    //int executeUpdate()throws SQLException
                    int count = stmt.executeUpdate();
                    System.out.println(count);
                } catch (Exception e) {
                    e.printStackTrace();
                }finally{
                    JDBCUtil.close(conn, stmt, null);
                }
    }

    private static void testInsert() {
        //定义连接对象和预编译sql对象
        Connection conn = null;
        PreparedStatement stmt = null;
        try {
            //获取链接
            conn = JDBCUtil.getconn();
            //PreparedStatement prepareStatement(String sql)throws SQLException
            //创建一个 PreparedStatement 对象来将参数化的 SQL 语句发送到数据库
            String sql = "INSERT INTO student VALUES(?,?,?);";//参数化的sql,动态sql
            stmt = conn.prepareStatement(sql);
            //需要一个预编译的sequel语句，将sq发送到数据库端，检查sql语法及用户权限等信息

            //给之前参数化的sql语句设置参数
            //两个参数：1：是给第几个？设置数据    2：给？设置的数据
            stmt.setInt(1, 5);
            stmt.setString(2, "小黑");
            stmt.setInt(3, 60);
            //int executeUpdate()throws SQLException
            int count = stmt.executeUpdate();
            System.out.println(count);

        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            JDBCUtil.close(conn, stmt, null);
        }       
    }
}

Statement和PreparedStatement的区别
一、语法结构不同

1）Statment执行静态sql语句，且sql可以拼接。
2）PreparedStatement可以先执行预编译的sql语句，在预编译sql语句中使用？进行参数占位，后面再进行参数赋值

二、原理不同

1）Statement不能进行sql缓存
2）而PreparedStatement可以进行sql缓存，执行效率会比Statement快！！！

三、安全性不同

1）Statement存在sql注入的风险(使用登录注册讲解sql注入)
2）而PreparedStatement可以有效防止用户注入。

4 . CallableStatement对象执行存储过程
4.1 执行带输入参数的存储过程
4.2 执行带有输出参数的存储过程

package day21.edu5_callablestatement;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;

import day21.edu3_Util.JDBCUtil;

public class Demo {
    public static void main(String[] args) {
        //执行带有输入参数存储过程
        //testIn();
        //执行带有输出参数的存储过程
        testOut();
    }

    private static void testOut() {
        Connection conn  =null;
        CallableStatement stmt = null;
        ResultSet rs = null;
        try {
            conn = JDBCUtil.getconn();
            String sql = "CALL pro_QueryNameById(?,?);";
            stmt = conn.prepareCall(sql);
            //给问号赋值
            stmt.setInt(1, 2);
            //如果存储过程带有输出参数的时候，首先需要注册，输出参数的类型
            //void registerOutParameter(int parameterIndex,int sqlType)
            stmt.registerOutParameter(2, java.sql.Types.VARCHAR);

            //发送参数并执行sql
            stmt.executeQuery();

            //从stmt中取出输出参数的结果
            System.out.println(stmt.getString(2));

        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            JDBCUtil.close(conn, stmt, rs);

        }

    }

    private static void testIn() {
        Connection conn = null;
        CallableStatement stmt = null;
        ResultSet rs = null;
        try {
            conn = JDBCUtil.getconn();
            String sql = "CALL pro_QueryById(?);";
            stmt = conn.prepareCall(sql);

            //给问号设置值
            stmt.setInt(1, 1);
            //发送参数并执行sql,只能调用excuteQuery()
            rs = stmt.executeQuery();
            if (rs.next()) {
                System.out.println(rs.getInt("id")+"--"+rs.getString("name"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            JDBCUtil.close(conn, stmt, rs);
        }       
    }
}