java--jdbc基础

jdbc连接数据库

链接数据库时要先导包，导入数据库链接驱动程序包

public class Demo1 {
//连接数据库的URL
private String url = "jdbc:mysql://localhost:3306/day17";
                    // jdbc协议:数据库子协议:主机:端口/连接的数据库   //

private String user = "root";//用户名
private String password = "root";//密码

/**
 * 第一种方法
 * @throws Exception
 */
@Test
public void test1() throws Exception{
    //1.创建驱动程序类对象
    Driver driver = new com.mysql.jdbc.Driver(); //新版本
    //Driver driver = new org.gjt.mm.mysql.Driver(); //旧版本

    //设置用户名和密码
    Properties props = new Properties();
    props.setProperty("user", user);
    props.setProperty("password", password);

    //2.连接数据库，返回连接对象
    Connection conn = driver.connect(url, props);

    System.out.println(conn);
}

---

public void test2() throws Exception{
    Driver driver = new com.mysql.jdbc.Driver();
//driver类在加载的时候会自己在类内部自动注册一次驱动程序，这样写相当于注册了2次驱动程序
    //Driver driver2 = new com.oracle.jdbc.Driver();
    //1.注册驱动程序(可以注册多个驱动程序)
    DriverManager.registerDriver(driver);
    //DriverManager.registerDriver(driver2);

    //2.连接到具体的数据库
    Connection conn = DriverManager.getConnection(url, user, password);
    System.out.println(conn);

}

---

/**
 * （推荐使用这种方式连接数据库）
 * 推荐使用加载驱动程序类  来 注册驱动程序 
 * @throws Exception
 */
@Test
public void test3() throws Exception{
    //通过得到字节码对象的方式加载静态代码块，从而注册驱动程序
    Class.forName("com.mysql.jdbc.Driver");

    //2.连接到具体的数据库
    Connection conn = DriverManager.getConnection(url, user, password);
    System.out.println(conn);

}

JDBC接口核心的API

|- Driver接口： 表示java驱动程序接口。所有的具体的数据库厂商要来实现此接口。
|- connect(url, properties): 连接数据库的方法。
url: 连接数据库的URL
URL语法： jdbc协议:数据库子协议://主机:端口/数据库
user： 数据库的用户名
password： 数据库用户密码
|- DriverManager类： 驱动管理器类，用于管理所有注册的驱动程序
|-registerDriver(driver) : 注册驱动类对象
|-Connection getConnection(url,user,password); 获取连接对象

|- Connection接口： 表示java程序和数据库的连接对象。
        |- Statement createStatement() ： 创建Statement对象
        |- PreparedStatement prepareStatement(String sql)  创建PreparedStatement对象
        |- CallableStatement prepareCall(String sql) 创建CallableStatement对象

|- Statement接口： 用于执行静态的sql语句
        |- int executeUpdate(String sql)  ： 执行静态的更新sql语句（DDL，DML）
        |- ResultSet executeQuery(String sql)  ：执行的静态的查询sql语句（DQL）

    |-PreparedStatement接口：用于执行预编译sql语句
            |- int executeUpdate() ： 执行预编译的更新sql语句（DDL，DML）
            |-ResultSet executeQuery()  ： 执行预编译的查询sql语句（DQL）

        |-CallableStatement接口：用于执行存储过程的sql语句（call xxx）
            |-ResultSet executeQuery()  ： 调用存储过程的方法


|- ResultSet接口：用于封装查询出来的数据
        |- boolean next() ： 将光标移动到下一行
        |-getXX() : 获取列的值

使用Statement执行sql语句

执行DDL语句

执行完之后要关闭链接

/**
 * 执行DDL语句(创建表)
 */
@Test
public void test1(){
    Statement stmt = null;
    Connection conn = null;
    try {
        //1.驱动注册程序
        Class.forName("com.mysql.jdbc.Driver");

        //2.获取连接对象
        conn = DriverManager.getConnection(url, user, password);

        //3.创建Statement
        stmt = conn.createStatement();

        //4.准备sql
        String sql = "CREATE TABLE student(id INT PRIMARY KEY AUTO_INCREMENT,NAME VARCHAR(20),gender VARCHAR(2))";

        //5.发送sql语句，执行sql语句,得到返回结果
        int count = stmt.executeUpdate(sql);

        //6.输出
        System.out.println("影响了"+count+"行！");
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    } finally{
        //7.关闭连接(顺序:后打开的先关闭)
        if(stmt!=null)
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        if(conn!=null)
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            }
    }
}

使用Statement执行DQL语句（查询操作）

@Test
public void test1(){
    Connection conn = null;
    Statement stmt = null;
    try{
        //获取连接
        conn = JdbcUtil.getConnection();
        //创建Statement
        stmt = conn.createStatement();
        //准备sql
        String sql = "SELECT * FROM student";
        //执行sql
        ResultSet rs = stmt.executeQuery(sql);

        //遍历结果
        while(rs.next()){
            int id = rs.getInt("id");
            String name = rs.getString("name");
            String gender = rs.getString("gender");
            System.out.println(id+","+name+","+gender);
        }

    }catch(Exception e){
        e.printStackTrace();
        throw new RuntimeException(e);
    }finally{
        JdbcUtil.close(conn, stmt);
    }
}

使用PreparedStatement执行sql语句

public class Demo1 {

/**
 * 增加
 */
@Test
public void testInsert() {
    Connection conn = null;
    PreparedStatement stmt = null;
    try {
        //1.获取连接
        conn = JdbcUtil.getConnection();

        //2.准备预编译的sql
        String sql = "INSERT INTO student(NAME,gender) VALUES(?,?)"; //?表示一个参数的占位符

        //3.执行预编译sql语句(检查语法)
        stmt = conn.prepareStatement(sql);

        //4.设置参数值
        /**
         * 参数一： 参数位置  从1开始
         */
        stmt.setString(1, "李四");
        stmt.setString(2, "男");

        //5.发送参数，执行sql
        int count = stmt.executeUpdate();

        System.out.println("影响了"+count+"行");

    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    } finally {
        JdbcUtil.close(conn, stmt);
    }
}

/**
 * 修改
 */
@Test
public void testUpdate() {
    Connection conn = null;
    PreparedStatement stmt = null;
    try {
        //1.获取连接
        conn = JdbcUtil.getConnection();

        //2.准备预编译的sql
        String sql = "UPDATE student SET NAME=? WHERE id=?"; //?表示一个参数的占位符

        //3.执行预编译sql语句(检查语法)
        stmt = conn.prepareStatement(sql);

        //4.设置参数值
        /**
         * 参数一： 参数位置  从1开始
         */
        stmt.setString(1, "王五");
        stmt.setInt(2, 9);

        //5.发送参数，执行sql
        int count = stmt.executeUpdate();

        System.out.println("影响了"+count+"行");

    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    } finally {
        JdbcUtil.close(conn, stmt);
    }
}

/**
 * 删除
 */
@Test
public void testDelete() {
    Connection conn = null;
    PreparedStatement stmt = null;
    try {
        //1.获取连接
        conn = JdbcUtil.getConnection();

        //2.准备预编译的sql
        String sql = "DELETE FROM student WHERE id=?"; //?表示一个参数的占位符

        //3.执行预编译sql语句(检查语法)
        stmt = conn.prepareStatement(sql);

        //4.设置参数值
        /**
         * 参数一： 参数位置  从1开始
         */
        stmt.setInt(1, 9);

        //5.发送参数，执行sql
        int count = stmt.executeUpdate();

        System.out.println("影响了"+count+"行");

    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    } finally {
        JdbcUtil.close(conn, stmt);
    }
}

/**
 * 查询
 */
@Test
public void testQuery() {
    Connection conn = null;
    PreparedStatement stmt = null;
    ResultSet rs = null;
    try {
        //1.获取连接
        conn = JdbcUtil.getConnection();

        //2.准备预编译的sql
        String sql = "SELECT * FROM student"; 

        //3.预编译
        stmt = conn.prepareStatement(sql);

        //4.执行sql
        rs = stmt.executeQuery();

        //5.遍历rs
        while(rs.next()){
            int id = rs.getInt("id");
            String name = rs.getString("name");
            String gender = rs.getString("gender");
            System.out.println(id+","+name+","+gender);
        }

    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    } finally {
        //关闭资源
        JdbcUtil.close(conn,stmt,rs);
    }
}

}

PreparedStatement vs Statment

1）语法不同：PreparedStatement可以使用预编译的sql，而Statment只能使用静态的sql
2）效率不同： PreparedStatement可以使用sql缓存区，效率比Statment高
3）安全性不同： PreparedStatement可以有效防止sql注入，而Statment不能防止sql注入。

推荐使用PreparedStatement

CallableStatement执行存储过程

/**
     * 使用CablleStatement调用存储过程
     * @author APPle
     *
     */
public class Demo1 {

/**
 * 调用带有输入参数的存储过程
 * CALL pro_findById(4);
 */
@Test
public void test1(){
    Connection conn = null;
    CallableStatement stmt = null;
    ResultSet rs = null;
    try {
        //获取连接
        conn = JdbcUtil.getConnection();

        //准备sql
        String sql = "CALL pro_findById(?)"; //可以执行预编译的sql

        //预编译
        stmt = conn.prepareCall(sql);

        //设置输入参数
        stmt.setInt(1, 6);

        //发送参数
        rs = stmt.executeQuery(); //注意： 所有调用存储过程的sql语句都是使用executeQuery方法执行！！！

        //遍历结果
        while(rs.next()){
            int id = rs.getInt("id");
            String name = rs.getString("name");
            String gender = rs.getString("gender");
            System.out.println(id+","+name+","+gender);
        }

    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    } finally {
        JdbcUtil.close(conn, stmt ,rs);
    }
}

/**
 * 执行带有输出参数的存储过程
 * CALL pro_findById2(5,@NAME);
 */
@Test
public void test2(){
    Connection conn = null;
    CallableStatement stmt = null;
    ResultSet rs = null;
    try {
        //获取连接
        conn = JdbcUtil.getConnection();
        //准备sql
        String sql = "CALL pro_findById2(?,?)"; //第一个？是输入参数，第二个？是输出参数

        //预编译
        stmt = conn.prepareCall(sql);

        //设置输入参数
        stmt.setInt(1, 6);
        //设置输出参数(注册输出参数)
        /**
         * 参数一： 参数位置
         * 参数二： 存储过程中的输出参数的jdbc类型    VARCHAR(20)
         */
        stmt.registerOutParameter(2, java.sql.Types.VARCHAR);

        //发送参数，执行
        stmt.executeQuery(); //结果不是返回到结果集中，而是返回到输出参数中

        //得到输出参数的值
        /**
         * 索引值： 预编译sql中的输出参数的位置
         */
        String result = stmt.getString(2); //getXX方法专门用于获取存储过程中的输出参数

        System.out.println(result);

    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    } finally {
        JdbcUtil.close(conn, stmt ,rs);
    }
}
}

jdbcUtil工具类

/**
 * jdbc工具类
 * @author APPle
 *
 */
public class JdbcUtil {
private static String url = null;
private static String user = null;
private static String password = null;
private static String driverClass = null;

/**
 * 静态代码块中（只加载一次）
 */
static{
    try {
        //读取db.properties文件
        Properties props = new Properties();
        /**
         *  . 代表java命令运行的目录
         *  在java项目下，. java命令的运行目录从项目的根目录开始
         *  在web项目下，  . java命令的而运行目录从tomcat/bin目录开始
         *  所以不能使用点.
         */
        //FileInputStream in = new FileInputStream("./src/db.properties");

        /**
         * 使用类路径的读取方式
         *  / : 斜杠表示classpath的根目录
         *     在java项目下，classpath的根目录从bin目录开始
         *     在web项目下，classpath的根目录从WEB-INF/classes目录开始
         */
        InputStream in = JdbcUtil.class.getResourceAsStream("/db.properties");

        //加载文件
        props.load(in);
        //读取信息
        url = props.getProperty("url");
        user = props.getProperty("user");
        password = props.getProperty("password");
        driverClass = props.getProperty("driverClass");


        //注册驱动程序
        Class.forName(driverClass);
    } catch (Exception e) {
        e.printStackTrace();
        System.out.println("驱程程序注册出错");
    }
}

/**
 * 抽取获取连接对象的方法
 */
public static Connection getConnection(){
    try {
        Connection conn = DriverManager.getConnection(url, user, password);
        return conn;
    } catch (SQLException e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    }
}


/**
 * 释放资源的方法
 */
public static void close(Connection conn,Statement stmt){
    if(stmt!=null){
        try {
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    if(conn!=null){
        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
}

public static void close(Connection conn,Statement stmt,ResultSet rs){
    if(rs!=null)
        try {
            rs.close();
        } catch (SQLException e1) {
            e1.printStackTrace();
            throw new RuntimeException(e1);
        }
    if(stmt!=null){
        try {
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    if(conn!=null){
        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
}
}