-------JDBC

JDBC：
  JDBC的全称是Java数据库连接（Java Database Connectivity）,它是一套用于执行SQL语句的Java API。应用程序可通过这套API连接到关系型数据库，并使用SQL语句来完成对数据库中数据的查询、更新、新增和删除的操作。

JDBC编程步骤：
装载相应数据库的JDBC驱动并进行初始化
  导入专用的jar包（不同的数据库需要的jar包不同）

访问MySQL数据库需要用到第三方的类，这些第三方的类，都被压缩在一个.Jar的文件里。mysql-connector-java-5.0.8-bin.jar包可以在网上下载，或者在MySQL的安装目录下找到。通常下载到该jar包之后将其放到在项目的lib目录下。

初始化驱动

通过初始化驱动类com.mysql.jdbc.Driver，该类就在 mysql-connector-java-5.0.8-bin.jar中。如果你使用的是oracle数据库那么该驱动类将不同。
 

 

lass.forName是把这个类加载到JVM中，加载的时候，就会执行其中的静态初始化块，完成驱动的初始化的相关工作。

建立JDBC和数据库之间的Connection连接
这里需要提供：数据库服务端的IP地址:127.0.0.1 (这是本机，如果连接其他电脑上的数据库，需填写相应的IP地址)
                         数据库的端口号： 3306 （mysql专用端口号）
                         数据库名称 test（根据你自己数据库中的名称填写）
                         编码方式 UTF-8
                         账号 root
                         密码 root（如果你在创建数据库的时候没有使用默认的账号和密码，请填写自己设置的账号和密码）
 

Connection是与特定数据库连接回话的接口，使用的时候需要导包，而且必须在程序结束的时候将其关闭。getConnection方法也需要捕获SQLException异常。

 

 

创建Statement或者PreparedStatement接口，执行SQL语句
使用Statement接口

通过Connection对象获取Statement对象Connection创建Statement的方式有如下3种。

1.createStatement()：创建基本的Statement对象。

2.prepareStatement()： 创建PreparedStatement对象。

3.prepareCall()：创建CallableStatement对象。

基本的Statement

statement stmt=conn.createStatement();
Statement接口创建之后，可以执行SQL语句，完成对数据库的增删改查。其中 ，增删改只需要改变SQL语句的内容就能完成，然而查询略显复杂。在Statement中使用字符串拼接的方式，该方式存在句法复杂，容易犯错等缺点，具体在下文中的对比中介绍。所以Statement在实际过程中使用的非常的少，所以具体的放到PreparedStatement那里给出详细代码。

字符串拼接方式的SQL语句是非常繁琐的，中间有很多的单引号和双引号的混用，极易出错。
 

 

使用PreparedStatement接口

与 Statement一样，PreparedStatement也是用来执行sql语句的与创建Statement不同的是，需要根据sql语句创建PreparedStatement。除此之外，还能够通过设置参数，指定相应的值，而不是Statement那样使用字符串拼接。

使用PreparedStatement时，它的SQL语句不再采用字符串拼接的方式，而是采用占位符的方式。“？”在这里就起到占位符的作用。这种方式除了避免了statement拼接字符串的繁琐之外，还能够提高性能。每次SQL语句都是一样的，java类就不会再次编译，这样能够显著提高性能。
 

后面需要用到PreparedStatement接口创建的pstmt的set方法给占位符进行赋值。注意一点，这里的参数索引是从1开始的

 

增删改都使用pstmt.executeUpdate();语句进行SQL语句的提交

使用Statement 执行SQL语句
所有的Statement 都有如下3种执行SQL语句的方法。

1.execute()：可以执行任何SQL语句。

2.executeQuery()：通常执行查询语句，执行后返回代表结果集的ResultSet对象。

3.executeUpdate()：主要用于执行DML和DDL语句。执行DML语句，如 INSERT、UPDATE或DELETE时，返回受SQL语句影响的行数，执行DDL语句返回0。

以 executeQuery()方法为例，其使用方式如下。
 

操作ResultSet结果集
    如果执行的SQL语句是查询语句，执行结果将返回一个ResultSet对象，该对象里保存了
SQL语句查询的结果。程序可以通过操作该ResultSet对象来取出查询结果。

可以通过next（）方法由前向后逐个获取结果集的数据，如果想获取结果集中任意位置的数据，则需要创建statement对象中，设置两个resultset定义的常量
 
 

使用resultset对象指定数据信息

代码如下：

package cn.itcast.jdbc.example;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Example03 {
    public static void main(String[] args) {
            Connection conn = null;
            Statement stmt = null;
            try {
               Class.forName("com.mysql.jdbc.Driver");
               String url = "jdbc:mysql://localhost:3306/jdbc";
               String username = "root";
               String password = "root";
               //1.获取Connection对象
               conn = DriverManager.getConnection(url, username, password);
               String sql = "select * from users";
               //2.创建Statement对象并设置常量
               Statement st =conn.createStatement(
                        ResultSet.TYPE_SCROLL_INSENSITIVE, 
                        ResultSet.CONCUR_READ_ONLY);
               //3.执行SQL并将获取的数据信息存放在ResultSet中
                ResultSet rs = st.executeQuery(sql);
               //4.取出ResultSet中指定数据的信息
                System.out.print("第2条数据的name值为:");
                rs.absolute(2);        //将指针定位到结果集中第2行数据
                System.out.println(rs.getString("name"));
                System.out.print("第1条数据的name值为:");
                rs.beforeFirst();      //将指针定位到结果集中第1行数据之前
                rs.next();              //将指针向后滚动
                System.out.println(rs.getString("name"));
                System.out.print("第4条数据的name值为:");
                rs.afterLast();        //将指针定位到结果集中最后一条数据之后
                rs.previous();         //将指针向前滚动
                System.out.println(rs.getString("name"));
            } catch (Exception e) {
                e.printStackTrace();
            } finally { // 释放资源
                if (stmt != null) {
                    try {
                        stmt.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                    stmt = null;
                }
                if (conn != null) {
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                    conn = null;
                }
            }
        }
    }

 

关闭连接，释放资源
 每次操作数据库结束后都要关闭数据库连接，释放资源，包括关闭ResultSet、Statement
和Connection等资源。
        至此，JDBC程序的大致实现步骤已经讲解完成。接下来，依照上面所讲解的步骤来演示
JDBC的使用。该程序从users表中读取数据，并将结果打印在控制台。

步骤
搭建数据库环境
在MySQL中创建一个名称为jdbc的数据库，然后在该数据库中创建一个users表

数据库和表创建成功后，再向users表中插入3条数据，插入的SQL语句如下所示。

 

创建项目环境，导入数据库驱动 

导入下载好的MySQL数据库驱动文件

编写JDBC程序

创建Example01，用于读取数据库中的users表，并将结果输出控制台

代码如下：

package cn.itcast.jdbc.example;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Date;
public class Example01 {
    public static void main(String[] args) throws SQLException {
        Statement stmt = null;
        ResultSet rs = null;
        Connection conn = null;
        try {
            // 1. 注册数据库的驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 2.通过DriverManager获取数据库连接
            String url = "jdbc:mysql://localhost:3306/jdbc";
            String username = "root";
            String password = "root";
            conn = DriverManager.getConnection (url, username, 
                         password);
            // 3.通过Connection对象获取Statement对象
             stmt = conn.createStatement();
            // 4.使用Statement执行SQL语句。
            String sql = "select * from users";
            rs = stmt.executeQuery(sql);
            // 5. 操作ResultSet结果集
            System.out.println("id | name   | password | email  | birthday");
            while (rs.next()) {
                int id = rs.getInt("id"); // 通过列名获取指定字段的值
                String name = rs.getString("name");
                String psw = rs.getString("password");
                String email = rs.getString("email");
                Date birthday = rs.getDate("birthday");
                System.out.println(id + " | " + name + " | " + psw + " | " + email
                            + " | " + birthday);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally{
            // 6.回收数据库资源
            if(rs!=null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                rs = null;
            }
            if(stmt!=null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                stmt = null;
            }
            if(conn!=null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                conn = null;
            }
        }        
    }
}
 

首先注册了MySQL数据库驱动，通过DriverManager获取一个Connection对象，然后使用Connection对象创建一个Statement对象，Statement对象通过executeQuery()方法执行SQL语句，并返回结果集ResultSet。接下来，通过遍历ResultSet得到最终的查询结果，最后关闭连接，回收了数据库资源。
        程序执行成功后，控制台的打印结果如图所示
 

 

注意：

1.注册驱动

虽然使用 DriverManager.registerDriver(new com.mysql.jdbc.Driver())方法也可以完成注
册，但此方式会使数据库驱动被注册两次。这是因为Driver类的源码已经在静态代码块中完成了
数据库驱动的注册。所以，为了避免数据库驱动被重复注册，只需在程序中使用Class.forName()
方法加载驱动类即可。
 

2.释放资源

由于数据库资源非常宝贵，数据库允许的并发访问连接数量有限，因此，当数据库资源使用完毕后，一定要记得释放资源。为了保证资源的释放，在Java程序中，应该将最终必须要执行的操作放在 finally 代码块中。

创建Example02的类，在类中使用PreparedStatement对象对数据库进行插入数据的操作，预编译信息储存在PreparedStatement对象，提高数据访问效率
 

代码如下：

package cn.itcast.jdbc.example;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement ;
import java.sql.SQLException;
public class Example02 {
    public static void main(String[] args) throws SQLException {
        Connection conn = null;
        PreparedStatement  preStmt = null;
            try {
                 // 加载数据库驱动
                Class.forName("com.mysql.jdbc.Driver");
                String url = "jdbc:mysql://localhost:3306/jdbc";
                String username = "root";
                String password = "root";
                 // 创建应用程序与数据库连接的Connection对象
                conn = DriverManager.getConnection(url, username, password);
                // 执行的SQL语句
                String sql = "INSERT INTO users(name,password,email,birthday)"
                        + "VALUES(?,?,?,?)";
                 // 创建执行SQL语句的PreparedStatement 对象
                preStmt = conn.prepareStatement(sql);
                preStmt.setString(1, "zl");
                preStmt.setString(2, "123456");
                preStmt.setString(3, "zl@sina.com");
                preStmt.setString(4, "1789-12-23");
                preStmt.executeUpdate();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } finally {    // 释放资源
                if (preStmt != null) {
                    try {
                        preStmt.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                    preStmt = null;
                }
                if (conn != null) {
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                    conn = null;
                }
            }
        }
    }

首先通过Connection对象的prepareStatement()方法生成PreparedStatement对象，然后调用PreparedStatement对象的setXxx()方法，给SQL语句中的参数赋值，最后通讨调executeUpdate()方法执行SQL语句。
        文件运行成功后，会在users表中插入一条数据。进入MySQL数据库，使用SELECT句查看users表，查询结果如9-5所示。
 

 

使用JDBC完成数据的增删改查

创建JavaBean，创建一个用于保存用户数据User类

代码如下：

package cn.itcast.jdbc.example.domain;
import java.util.Date;
public class User {
    private int id;
    private String username;
    private String password;
    private String email;
    private Date birthday;
    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;
        }
        public String getEmail() {
            return email;
        }
        public void setEmail(String email) {
            this.email = email;
        }
        public Date getBirthday() {
            return birthday;
        }
        public void setBirthday(Date birthday) {
            this.birthday = birthday;
        }
}

 

创建工具类

每次操作数据库都需要加载驱动，建立数据库连接以及关闭数据库连接，为避免代码重复书写，专门建立一个数据库相关操作的工具类

代码如下：
 
package cn.itcast.jdbc.example.utils;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class JDBCUtils {
    // 加载驱动，并建立数据库连接
    public static Connection getConnection() throws SQLException,
                ClassNotFoundException {
            Class.forName("com.mysql.jdbc.Driver");
            String url = "jdbc:mysql://localhost:3306/jdbc";
            String username = "root";
                String password = "root";
            Connection conn = DriverManager.getConnection(url, username, 
                    password);
            return conn;
        }
        // 关闭数据库连接，释放资源
        public static void release(Statement stmt, Connection conn) {
            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                stmt = null;
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                conn = null;
            }
        }
         public static void release(ResultSet rs, Statement stmt, 
                 Connection conn){
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                rs = null;
            }
            release(stmt, conn);
        }
}
 

创建Dao

创建UersDao的类，封装对表users的添加、查询、删除和更新等操作

代码如下:

 
package cn.itcast.jdbc.example.dao;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import cn.itcast.jdbc.example.domain.User;
import cn.itcast.jdbc.example.utils.JDBCUtils;
public class UsersDao {
    // 添加用户的操作
    public boolean insert(User user) {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try {
        // 获得数据的连接
        conn = JDBCUtils.getConnection();
        // 获得Statement对象
        stmt = conn.createStatement();
        // 发送SQL语句
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String birthday = sdf.format(user.getBirthday());
        String sql = "INSERT INTO users(id,name,password,email,birthday) "+
                    "VALUES("
                    + user.getId()
                    + ",'"
                    + user.getUsername()
                    + "','"
                    + user.getPassword()
                    + "','"
                    + user.getEmail()
                    + "','"
                    + birthday + "')";
            int num = stmt.executeUpdate(sql);
            if (num > 0) {
                return true;
            }
            return false;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.release(rs, stmt, conn);
        }
        return false;
    }
    // 查询所有的User对象
    public ArrayList<User> findAll() {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        ArrayList<User> list = new ArrayList<User>();
        try {
            // 获得数据的连接
            conn = JDBCUtils.getConnection();
            // 获得Statement对象
            stmt = conn.createStatement();
            // 发送SQL语句
            String sql = "SELECT * FROM users";
            rs = stmt.executeQuery(sql);
            // 处理结果集
            while (rs.next()) {
                User user = new User();
                user.setId(rs.getInt("id"));
                user.setUsername(rs.getString("name"));
                user.setPassword(rs.getString("password"));
                user.setEmail(rs.getString("email"));
                user.setBirthday(rs.getDate("birthday"));
                list.add(user);
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.release(rs, stmt, conn);
        }
        return null;
    }
    // 根据id查找指定的user
    public User find(int id) {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try {
            // 获得数据的连接
            conn = JDBCUtils.getConnection();
            // 获得Statement对象
            stmt = conn.createStatement();
            // 发送SQL语句
            String sql = "SELECT * FROM users WHERE id=" + id;
            rs = stmt.executeQuery(sql);
            // 处理结果集
            while (rs.next()) {
                User user = new User();
                user.setId(rs.getInt("id"));
                user.setUsername(rs.getString("name"));
                user.setPassword(rs.getString("password"));
                user.setEmail(rs.getString("email"));
                user.setBirthday(rs.getDate("birthday"));
                return user;
                }
                return null;
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                JDBCUtils.release(rs, stmt, conn);
            }
            return null;
        }
        // 删除用户
        public boolean delete(int id) {
            Connection conn = null;
            Statement stmt = null;
            ResultSet rs = null;
            try {
                // 获得数据的连接
                conn = JDBCUtils.getConnection();
                // 获得Statement对象
                stmt = conn.createStatement();
                // 发送SQL语句
                String sql = "DELETE FROM users WHERE id=" + id;
                int num = stmt.executeUpdate(sql);
                if (num > 0) {
                    return true;
                }
                return false;
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                JDBCUtils.release(rs, stmt, conn);
            }
            return false;
        }
        // 修改用户
        public boolean update(User user) {
            Connection conn = null;
            Statement stmt = null;
            ResultSet rs = null;
            try {
                // 获得数据的连接
                conn = JDBCUtils.getConnection();
                // 获得Statement对象
                stmt = conn.createStatement();
                // 发送SQL语句
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                String birthday = sdf.format(user.getBirthday());
                String sql = "UPDATE users set name='" + user.getUsername()
                        + "',password='" + user.getPassword() + "',email='"
                        + user.getEmail() + "',birthday='" + birthday
                        + "' WHERE id=" + user.getId();
                int num = stmt.executeUpdate(sql);
                if (num > 0) {
                    return true;
                }
                return false;
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                JDBCUtils.release(rs, stmt, conn);
            }
            return false;
        }
    }
 

 编写测试类FindUersTest实现读取users表中的数据

打印users表中所有username值

 

 编写FindUerByldTest读取users表中指定数据

 

 

编写测试类UpdayeUerTest实现修改users表中数据操作

 

 

编写测试类DeletUserTest实现删除users表数据