JDBC的具体实现及对象详解

1.概念
Java DataBase Connectivity 即用Java语言操作数据库。
其本质是：官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类。

2.步骤及代码实现

//1. 导入驱动jar包
//2.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//3.获取数据库连接对象
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3", "root", "root");
//4.定义sql语句
String sql = "update account set balance = 500 where id = 1";
//5.获取执行sql的对象 Statement
Statement stmt = conn.createStatement();
//6.执行sql
int count = stmt.executeUpdate(sql);
//7.处理结果
System.out.println(count);
//8.释放资源
stmt.close();
conn.close();

3.各个对象详解
3.1 DriverManager：驱动管理对象
功能：

• 注册驱动
  告诉程序该使用哪一个数据库驱动jar，
  注意：mysql5之后的驱动jar包可以省略注册驱动的步骤，
  写代码使用： Class.forName(“com.mysql.jdbc.Driver”);
  通过查看源码发现：在com.mysql.jdbc.Driver类中存在如下的静态代码块：

 static {
			try {
				    java.sql.DriverManager.registerDriver(new Driver());
				} catch (SQLException E) {
				    throw new RuntimeException("Can't register driver!");
				}
		}

• 获取数据库连接
  方法：static Connection getConnection(String url, String user, String password)
  参数：
  url：指定连接的路径
  语法：jdbc:mysql://ip地址(域名):端口号/数据库名称
  例子：jdbc:mysql://localhost:3306/db3
  细节：如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称
  user：用户名
  password：密码

3.2 Connection：数据库连接对象
功能：

• 获取执行sql 的对象
  Statement createStatement()
  PreparedStatement prepareStatement(String sql)
• 管理事务
  开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
  提交事务：commit()
  回滚事务：rollback()

3.3 Statement：执行sql的对象
功能：

• 执行sql
  1. boolean execute(String sql) ：可以执行任意的sql 了解
  2. int executeUpdate(String sql) ：执行DML（insert、update、delete）语句、DDL(create，alter、drop)语句
  返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功 返回值>0的则执行成功，反之，则失败。
  3. ResultSet executeQuery(String sql) ：执行DQL（select)语句。

3.4 ResultSet：结果集对象
功能：

• 封装查询结果
  boolean next(): 游标向下移动一行，判断当前行是否是最后一行末尾(是否有数据)，如果是，则返回false，如果不是则返回true。
  getXxx(参数):获取数据
  Xxx：代表数据类型 如： int getInt() , String getString()
  参数：
  1. int：代表列的编号,从1开始 如：getString(1)
  2. String：代表列名称。 如：getDouble(“balance”)

    	* 使用步骤：
    		1. 游标向下移动一行
    		2. 判断是否有数据
    		3. 获取数据
  

• 练习
  定义一个方法，查询student数据库中grade表的数据，将其封装为对象，然后装载集合，返回。

  代码实现：首先定义Grade类，把数据库这个表的字段设为私有属性。添加get和set方法，并重写tostring()。

  再定义并实现方法 public List findAll(){}。

public class exerciseDemo {
    public static void main(String[] args) {
        List<Grade> list=new exerciseDemo().findAll();
        System.out.println(list);
    }
    //查询所有Grade对象
    public List<Grade> findAll(){
        Connection conn=null;
        Statement stmt=null;
        ResultSet res=null;
        List<Grade> list=null;
        try {
            //注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //获取连接
            conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/student","root","123456");
            //定义sql
            String sql="select * from grade";
            //获取执行sql的对象
            stmt=conn.createStatement();
            //执行sql
            res=stmt.executeQuery(sql);
            //遍历结果集，封装对象，装载集合
            Grade grade=null;
            list=new ArrayList<Grade>();
            while(res.next()){
                //获取数据
                int id=res.getInt("id");
                String name=res.getString("name");
                //复用对象
                grade=new Grade();
                grade.setId(id);
                grade.setName(name);
                //装载集合
                list.add(grade);
            }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }finally {
            if(res!=null){
                try {
                    res.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(stmt!=null){
                try {
                    stmt.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(conn!=null){
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
            return list;
    }
}

执行结果：

3.5 PreparedStatement：执行sql的对象
功能：也是执行sql的对象
但是它可以防止sql注入，提高安全性，并且提高效率，后期都会使用PreparedStatement来完成增删改查的所有操作。

1. SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题
   1. 输入用户随便输入密码：a’ or ‘a’ = 'a显示登陆成功
   2. 控制台提示：sql：select * from user where username = ‘fhdsjkf’ and password = ‘a’ or ‘a’ = ‘a’

2. 解决sql注入问题：使用PreparedStatement对象来解决

3. 预编译的SQL：参数使用?作为占位符

4. 步骤：
   1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
   2. 注册驱动
   3. 获取数据库连接对象 Connection
   4. 定义sql
   * 注意：sql的参数使用？作为占位符。 如：select * from user where username = ? and password = ?;
   5. 获取执行sql语句的对象 PreparedStatement Connection.prepareStatement(String sql)
   6. 给？赋值：
   * 方法： setXxx(参数1,参数2)
   * 参数1：？的位置编号 从1 开始
   * 参数2：？的值
   7. 执行sql，接受返回结果，不需要传递sql语句
   8. 处理结果
   9. 释放资源

练习：

//键盘录入用户名和密码，后台检索是否登陆成功
public class enroll {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入用户名");
        String username=scanner.nextLine();
        System.out.println("请输入密码");
        String password=scanner.nextLine();

        boolean flag=new enroll().login(username,password);
        if(flag){
            System.out.println("登陆成功！");
        }else{
            System.out.println("用户名或密码错误");
        }
    }
    /*登陆方法*/
    public boolean login(String username,String password){
        if(username==null || password==null){
            return false;
        }
        Connection conn=null;
        Statement stmt=null;
        ResultSet res=null;
        PreparedStatement pstmt=null;
        try {
            conn=JDBCUtils.getConnection();
            /*String sql="select * from user where username='"+username+"'and password='"+password+"'";*/
            /* 存在sql注入问题，有一些sql的特殊关键字参与拼接，造成安全问题*/
            String sql="select * from user where username=? and password=?";
            //获取执行sql的prepareStatement对象,可以避免sql注入，并且提高效率
            /* stmt=conn.createStatement();*/
            pstmt=conn.prepareStatement(sql);
            //给？赋值
            pstmt.setString(1,username);
            pstmt.setString(2,password);
            //执行sql
            /* res=stmt.executeQuery(sql);*/
            res=pstmt.executeQuery();
            return res.next();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            /*JDBCUtils.close(res,stmt,conn);*/
            JDBCUtils.close(res,pstmt,conn);
        }
        return false;
    }
}

4.抽取JDBC工具类 ： JDBCUtils
上述那个登录例子用到了自定义的jdbc工具类，因为很多步骤都是重复的，想抽取出来简化下。

• 需求：不想传递参数（麻烦），还得保证工具类的通用性。
• 解决：用配置文件。
  代码实现：

/*JDBC工具类*/
public class JDBCUtils {
    private static String url;
    private static String user;
    private static String password;
    private static String driver;
    //文件的读取，只需要读取一次就可以拿到这些值，只用静态代码块
    static {
        //读取资源文件，获取值
        try {
            //1.创建properties集合类
            Properties pro=new Properties();
            //获取src路径下的文件的方式，ClassLoader类加载器把对应的字节码文件加载进内存
            ClassLoader classloader=JDBCUtils.class.getClassLoader();
            //返回一个统一资源定位符对象，定位文件的绝对路径
            URL resurl=classloader.getResource("jdbc.properties");
            String path=resurl.getPath();//获取字符串路径
            //System.out.println(path);
            //2.加载文件
            pro.load(new FileReader(path));//因为是静态代码块不是方法，只能处理，不能抛
            //3.获取数据，赋值
            url=pro.getProperty("url");
            user=pro.getProperty("user");
            password=pro.getProperty("password");
            driver=pro.getProperty("driver");
            //4.注册驱动
            try {
                Class.forName(driver);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //获取连接对象
    public static Connection getConnection() throws SQLException {
            return DriverManager.getConnection(url,user,password);

    }

    //释放资源
    public static void close(Statement stmt,Connection conn){

        if(stmt!=null){
            try {
                stmt.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
    public static void close(ResultSet res,Statement stmt,Connection conn){

        if(res!=null){
            try {
                res.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        if(stmt!=null){
            try {
                stmt.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

src路径下的jdbc属性文件：

• jdbc工具类的使用：
  上代码demo:

public class propertiesDemo {
    public static void main(String[] args) {
        List<Grade> list=new propertiesDemo().findAll2();
        System.out.println(list);
    }
    //查询所有Grade对象
    public List<Grade> findAll2(){
        Connection conn=null;
        Statement stmt=null;
        ResultSet res=null;
        List<Grade> list=null;
        try {
            //注册驱动
            //Class.forName("com.mysql.jdbc.Driver");
            //获取连接
            //conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/student","root","123456");
            conn= JDBCUtils.getConnection();
            //定义sql
            String sql="select * from grade";
            //获取执行sql的对象
            stmt=conn.createStatement();
            //执行sql
            res=stmt.executeQuery(sql);
            //遍历结果集，封装对象，装载集合
            Grade grade=null;
            list=new ArrayList<Grade>();
            while(res.next()){
                //获取数据
                int id=res.getInt("id");
                String name=res.getString("name");
                //复用对象
                grade=new Grade();
                grade.setId(id);
                grade.setName(name);
                //装载集合
                list.add(grade);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JDBCUtils.close(res,stmt,conn);
           /* if(res!=null){
                try {
                    res.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(stmt!=null){
                try {
                    stmt.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(conn!=null){
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }*/
        }
        return list;
    }
}

可以省略好几行代码，注册驱动，获取连接，释放资源都可以通过调用工具类的方法传参来实现，非常好用。

5.JDBC控制事务：

1. 事务：一个包含多个步骤的业务操作。如果这个业务操作被事务管理，则这多个步骤要么同时成功，要么同时失败。
2. 操作：
   1. 开启事务
   2. 提交事务
   3. 回滚事务
3. 使用Connection对象来管理事务
   • 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
     • 在执行sql之前开启事务
   • 提交事务：commit()
     • 当所有sql都执行完提交事务
   • 回滚事务：rollback()
     • 在catch中回滚事务

代码实现银行转账，假如操作数据库失败则事务回滚：

public class JDBCDemo10 {

	    public static void main(String[] args) {
	        Connection conn = null;
	        PreparedStatement pstmt1 = null;
	        PreparedStatement pstmt2 = null;
	
	        try {
	            //1.获取连接
	            conn = JDBCUtils.getConnection();
	            //开启事务
	            conn.setAutoCommit(false);
	            //2.定义sql
	            //2.1 张三 - 500
	            String sql1 = "update account set balance = balance - ? where id = ?";
	            //2.2 李四 + 500
	            String sql2 = "update account set balance = balance + ? where id = ?";
	            //3.获取执行sql对象
	            pstmt1 = conn.prepareStatement(sql1);
	            pstmt2 = conn.prepareStatement(sql2);
	            //4. 设置参数
	            pstmt1.setDouble(1,500);
	            pstmt1.setInt(2,1);
	
	            pstmt2.setDouble(1,500);
	            pstmt2.setInt(2,2);
	            //5.执行sql
	            pstmt1.executeUpdate();
	            // 手动制造异常
	            int i = 3/0;
	
	            pstmt2.executeUpdate();
	            //提交事务
	            conn.commit();
	        } catch (Exception e) {
	            //事务回滚
	            try {
	                if(conn != null) {
	                    conn.rollback();
	                }
	            } catch (SQLException e1) {
	                e1.printStackTrace();
	            }
	            e.printStackTrace();
	        }finally {
	            JDBCUtils.close(pstmt1,conn);
	            JDBCUtils.close(pstmt2,null);
	        }

这样，遇到异常，双方用户的账号金额不会改变，不然，转账方数据库数值改变，但是被转账方不改变，钱未到帐户上。

终于写完了，以上是放假2天来对jdbc的深入学习，并在idea写的代码，别的不说，idea真的香，用户体验贼拉丝滑~